diff --git a/flang/include/flang/Common/Fortran-features.h b/flang/include/flang/Common/Fortran-features.h
index dfce05c99cd5..823fa85ad12e 100644
--- a/flang/include/flang/Common/Fortran-features.h
+++ b/flang/include/flang/Common/Fortran-features.h
@@ -61,5 +61,5 @@ private:
   LanguageFeatures warn_;
   bool warnAll_{false};
 };
-}
-#endif  // FORTRAN_COMMON_FORTRAN_FEATURES_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_FORTRAN_FEATURES_H_
diff --git a/flang/include/flang/Common/Fortran.h b/flang/include/flang/Common/Fortran.h
index 20a507aed415..df6b27c8ce3b 100644
--- a/flang/include/flang/Common/Fortran.h
+++ b/flang/include/flang/Common/Fortran.h
@@ -52,21 +52,21 @@ ENUM_CLASS(IoSpecKind, Access, Action, Advance, Asynchronous, Blank, Decimal,
     Id, Iomsg, Iostat, Name, Named, Newunit, Nextrec, Nml, Number, Opened, Pad,
     Pending, Pos, Position, Read, Readwrite, Rec, Recl, Round, Sequential, Sign,
     Size, Status, Stream, Unformatted, Unit, Write,
-    Convert,  // nonstandard
-    Dispose,  // nonstandard
+    Convert, // nonstandard
+    Dispose, // nonstandard
 )
 
 // Floating-point rounding modes; these are packed into a byte to save
 // room in the runtime's format processing context structure.
 enum class RoundingMode : std::uint8_t {
-  TiesToEven,  // ROUND=NEAREST, RN - default IEEE rounding
-  ToZero,  // ROUND=ZERO, RZ - truncation
-  Down,  // ROUND=DOWN, RD
-  Up,  // ROUND=UP, RU
-  TiesAwayFromZero,  // ROUND=COMPATIBLE, RC - ties round away from zero
+  TiesToEven, // ROUND=NEAREST, RN - default IEEE rounding
+  ToZero, // ROUND=ZERO, RZ - truncation
+  Down, // ROUND=DOWN, RD
+  Up, // ROUND=UP, RU
+  TiesAwayFromZero, // ROUND=COMPATIBLE, RC - ties round away from zero
 };
 
 // Fortran arrays may have up to 15 dimensions (See Fortran 2018 section 5.4.6).
 static constexpr int maxRank{15};
-}
-#endif  // FORTRAN_COMMON_FORTRAN_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_FORTRAN_H_
diff --git a/flang/include/flang/Common/bit-population-count.h b/flang/include/flang/Common/bit-population-count.h
index af3a1f22fd30..83d767ce0eee 100644
--- a/flang/include/flang/Common/bit-population-count.h
+++ b/flang/include/flang/Common/bit-population-count.h
@@ -70,18 +70,18 @@ inline constexpr int BitPopulationCount(std::uint8_t x) {
   return (x & 0xf) + (x >> 4);
 }
 
-template<typename UINT> inline constexpr bool Parity(UINT x) {
+template <typename UINT> inline constexpr bool Parity(UINT x) {
   return BitPopulationCount(x) & 1;
 }
 
 // "Parity is for farmers." -- Seymour R. Cray
 
-template<typename UINT> inline constexpr int TrailingZeroBitCount(UINT x) {
+template <typename UINT> inline constexpr int TrailingZeroBitCount(UINT x) {
   if ((x & 1) != 0) {
-    return 0;  // fast path for odd values
+    return 0; // fast path for odd values
   } else {
     return BitPopulationCount(static_cast<UINT>(x ^ (x - 1))) - !!x;
   }
 }
-}
-#endif  // FORTRAN_COMMON_BIT_POPULATION_COUNT_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_BIT_POPULATION_COUNT_H_
diff --git a/flang/include/flang/Common/constexpr-bitset.h b/flang/include/flang/Common/constexpr-bitset.h
index eae11f57d1e1..f1f468268909 100644
--- a/flang/include/flang/Common/constexpr-bitset.h
+++ b/flang/include/flang/Common/constexpr-bitset.h
@@ -21,7 +21,7 @@
 
 namespace Fortran::common {
 
-template<int BITS> class BitSet {
+template <int BITS> class BitSet {
   static_assert(BITS > 0 && BITS <= 64);
   static constexpr bool partialWord{BITS != 32 && BITS != 64};
   using Word = std::conditional_t<(BITS > 32), std::uint64_t, std::uint32_t>;
@@ -143,5 +143,5 @@ public:
 private:
   Word bits_{0};
 };
-}
-#endif  // FORTRAN_COMMON_CONSTEXPR_BITSET_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_CONSTEXPR_BITSET_H_
diff --git a/flang/include/flang/Common/default-kinds.h b/flang/include/flang/Common/default-kinds.h
index c3610b23745f..6c66b98e98a0 100644
--- a/flang/include/flang/Common/default-kinds.h
+++ b/flang/include/flang/Common/default-kinds.h
@@ -50,12 +50,12 @@ private:
   // comprise two default REAL components.
   int defaultIntegerKind_{4};
   int subscriptIntegerKind_{8};
-  int sizeIntegerKind_{4};  // SIZE(), UBOUND(), &c. default KIND=
+  int sizeIntegerKind_{4}; // SIZE(), UBOUND(), &c. default KIND=
   int defaultRealKind_{defaultIntegerKind_};
   int doublePrecisionKind_{2 * defaultRealKind_};
   int quadPrecisionKind_{2 * doublePrecisionKind_};
   int defaultCharacterKind_{1};
   int defaultLogicalKind_{defaultIntegerKind_};
 };
-}
-#endif  // FORTRAN_COMMON_DEFAULT_KINDS_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_DEFAULT_KINDS_H_
diff --git a/flang/include/flang/Common/enum-set.h b/flang/include/flang/Common/enum-set.h
index ca8bc0cbd838..185c48825621 100644
--- a/flang/include/flang/Common/enum-set.h
+++ b/flang/include/flang/Common/enum-set.h
@@ -26,7 +26,7 @@
 
 namespace Fortran::common {
 
-template<typename ENUM, std::size_t BITS> class EnumSet {
+template <typename ENUM, std::size_t BITS> class EnumSet {
   static_assert(BITS > 0);
 
 public:
@@ -191,7 +191,7 @@ public:
     }
   }
 
-  template<typename FUNC> void IterateOverMembers(const FUNC &f) const {
+  template <typename FUNC> void IterateOverMembers(const FUNC &f) const {
     EnumSet copy{*this};
     while (auto least{copy.LeastElement()}) {
       f(*least);
@@ -212,13 +212,13 @@ public:
 private:
   bitsetType bitset_{};
 };
-}
+} // namespace Fortran::common
 
-template<typename ENUM, std::size_t values>
+template <typename ENUM, std::size_t values>
 struct std::hash<Fortran::common::EnumSet<ENUM, values>> {
   std::size_t operator()(
       const Fortran::common::EnumSet<ENUM, values> &x) const {
     return std::hash(x.bitset());
   }
 };
-#endif  // FORTRAN_COMMON_ENUM_SET_H_
+#endif // FORTRAN_COMMON_ENUM_SET_H_
diff --git a/flang/include/flang/Common/format.h b/flang/include/flang/Common/format.h
index 4cb274c81cd5..99b8cbe41d7c 100644
--- a/flang/include/flang/Common/format.h
+++ b/flang/include/flang/Common/format.h
@@ -29,30 +29,30 @@
 namespace Fortran::common {
 
 struct FormatMessage {
-  const char *text;  // message text; may have one %s argument
-  const char *arg;  // optional %s argument value
-  int offset;  // offset to message marker
-  int length;  // length of message marker
-  bool isError;  // vs. warning
+  const char *text; // message text; may have one %s argument
+  const char *arg; // optional %s argument value
+  int offset; // offset to message marker
+  int length; // length of message marker
+  bool isError; // vs. warning
 };
 
 // This declaration is logically private to class FormatValidator.
 // It is placed here to work around a clang compilation problem.
 ENUM_CLASS(TokenKind, None, A, B, BN, BZ, D, DC, DP, DT, E, EN, ES, EX, F, G, I,
     L, O, P, RC, RD, RN, RP, RU, RZ, S, SP, SS, T, TL, TR, X, Z, Colon, Slash,
-    Backslash,  // nonstandard: inhibit newline on output
-    Dollar,  // nonstandard: inhibit newline on output on terminals
+    Backslash, // nonstandard: inhibit newline on output
+    Dollar, // nonstandard: inhibit newline on output on terminals
     Star, LParen, RParen, Comma, Point, Sign,
-    UnsignedInteger,  // value in integerValue_
-    String)  // char-literal-constant or Hollerith constant
+    UnsignedInteger, // value in integerValue_
+    String) // char-literal-constant or Hollerith constant
 
-template<typename CHAR = char> class FormatValidator {
+template <typename CHAR = char> class FormatValidator {
 public:
   using Reporter = std::function<bool(const FormatMessage &)>;
   FormatValidator(const CHAR *format, size_t length, Reporter reporter,
       IoStmtKind stmt = IoStmtKind::None)
-    : format_{format}, end_{format + length}, reporter_{reporter}, stmt_{stmt},
-      cursor_{format - 1} {
+      : format_{format}, end_{format + length}, reporter_{reporter},
+        stmt_{stmt}, cursor_{format - 1} {
     CHECK(format);
   }
 
@@ -128,54 +128,54 @@ private:
   bool check_d();
   void check_e();
 
-  const CHAR *const format_;  // format text
-  const CHAR *const end_;  // one-past-last of format_ text
+  const CHAR *const format_; // format text
+  const CHAR *const end_; // one-past-last of format_ text
   Reporter reporter_;
   IoStmtKind stmt_;
 
-  const CHAR *cursor_{};  // current location in format_
-  const CHAR *laCursor_{};  // lookahead cursor
-  Token token_{};  // current token
-  int64_t integerValue_{-1};  // value of UnsignedInteger token
-  Token knrToken_{};  // k, n, or r UnsignedInteger token
-  int64_t knrValue_{-1};  // -1 ==> not present
+  const CHAR *cursor_{}; // current location in format_
+  const CHAR *laCursor_{}; // lookahead cursor
+  Token token_{}; // current token
+  int64_t integerValue_{-1}; // value of UnsignedInteger token
+  Token knrToken_{}; // k, n, or r UnsignedInteger token
+  int64_t knrValue_{-1}; // -1 ==> not present
   int64_t wValue_{-1};
   bool previousTokenWasInt_{false};
-  char argString_[3]{};  // 1-2 character msg arg; usually edit descriptor name
+  char argString_[3]{}; // 1-2 character msg arg; usually edit descriptor name
   bool formatHasErrors_{false};
   bool unterminatedFormatError_{false};
   bool suppressMessageCascade_{false};
   bool reporterExit_{false};
-  int maxNesting_{0};  // max level of nested parentheses
+  int maxNesting_{0}; // max level of nested parentheses
 };
 
-template<typename CHAR> CHAR FormatValidator<CHAR>::NextChar() {
+template <typename CHAR> CHAR FormatValidator<CHAR>::NextChar() {
   for (++cursor_; cursor_ < end_; ++cursor_) {
     if (*cursor_ != ' ') {
       return toupper(*cursor_);
     }
   }
-  cursor_ = end_;  // don't allow cursor_ > end_
+  cursor_ = end_; // don't allow cursor_ > end_
   return ' ';
 }
 
-template<typename CHAR> CHAR FormatValidator<CHAR>::LookAheadChar() {
+template <typename CHAR> CHAR FormatValidator<CHAR>::LookAheadChar() {
   for (laCursor_ = cursor_ + 1; laCursor_ < end_; ++laCursor_) {
     if (*laCursor_ != ' ') {
       return toupper(*laCursor_);
     }
   }
-  laCursor_ = end_;  // don't allow laCursor_ > end_
+  laCursor_ = end_; // don't allow laCursor_ > end_
   return ' ';
 }
 
 // After a call to LookAheadChar, set token kind and advance cursor to laCursor.
-template<typename CHAR> void FormatValidator<CHAR>::Advance(TokenKind tk) {
+template <typename CHAR> void FormatValidator<CHAR>::Advance(TokenKind tk) {
   cursor_ = laCursor_;
   token_.set_kind(tk);
 }
 
-template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
+template <typename CHAR> void FormatValidator<CHAR>::NextToken() {
   // At entry, cursor_ points before the start of the next token.
   // At exit, cursor_ points to last CHAR of token_.
 
@@ -184,7 +184,7 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
   token_.set_kind(TokenKind::None);
   token_.set_offset(cursor_ - format_);
   token_.set_length(1);
-  if (c == '_' && integerValue_ >= 0) {  // C1305, C1309, C1310, C1312, C1313
+  if (c == '_' && integerValue_ >= 0) { // C1305, C1309, C1310, C1312, C1313
     ReportError("Kind parameter '_' character in format expression");
   }
   integerValue_ = -1;
@@ -232,7 +232,7 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
       cursor_ = end_;
     }
     SetLength();
-    if (stmt_ == IoStmtKind::Read) {  // 13.3.2p6
+    if (stmt_ == IoStmtKind::Read) { // 13.3.2p6
       ReportError("'H' edit descriptor in READ format expression");
     } else if (token_.kind() == TokenKind::None) {
       ReportError("Unterminated 'H' edit descriptor");
@@ -241,72 +241,154 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
     }
     break;
   }
-  case 'A': token_.set_kind(TokenKind::A); break;
+  case 'A':
+    token_.set_kind(TokenKind::A);
+    break;
   case 'B':
     switch (LookAheadChar()) {
-    case 'N': Advance(TokenKind::BN); break;
-    case 'Z': Advance(TokenKind::BZ); break;
-    default: token_.set_kind(TokenKind::B); break;
+    case 'N':
+      Advance(TokenKind::BN);
+      break;
+    case 'Z':
+      Advance(TokenKind::BZ);
+      break;
+    default:
+      token_.set_kind(TokenKind::B);
+      break;
     }
     break;
   case 'D':
     switch (LookAheadChar()) {
-    case 'C': Advance(TokenKind::DC); break;
-    case 'P': Advance(TokenKind::DP); break;
-    case 'T': Advance(TokenKind::DT); break;
-    default: token_.set_kind(TokenKind::D); break;
+    case 'C':
+      Advance(TokenKind::DC);
+      break;
+    case 'P':
+      Advance(TokenKind::DP);
+      break;
+    case 'T':
+      Advance(TokenKind::DT);
+      break;
+    default:
+      token_.set_kind(TokenKind::D);
+      break;
     }
     break;
   case 'E':
     switch (LookAheadChar()) {
-    case 'N': Advance(TokenKind::EN); break;
-    case 'S': Advance(TokenKind::ES); break;
-    case 'X': Advance(TokenKind::EX); break;
-    default: token_.set_kind(TokenKind::E); break;
+    case 'N':
+      Advance(TokenKind::EN);
+      break;
+    case 'S':
+      Advance(TokenKind::ES);
+      break;
+    case 'X':
+      Advance(TokenKind::EX);
+      break;
+    default:
+      token_.set_kind(TokenKind::E);
+      break;
     }
     break;
-  case 'F': token_.set_kind(TokenKind::F); break;
-  case 'G': token_.set_kind(TokenKind::G); break;
-  case 'I': token_.set_kind(TokenKind::I); break;
-  case 'L': token_.set_kind(TokenKind::L); break;
-  case 'O': token_.set_kind(TokenKind::O); break;
-  case 'P': token_.set_kind(TokenKind::P); break;
+  case 'F':
+    token_.set_kind(TokenKind::F);
+    break;
+  case 'G':
+    token_.set_kind(TokenKind::G);
+    break;
+  case 'I':
+    token_.set_kind(TokenKind::I);
+    break;
+  case 'L':
+    token_.set_kind(TokenKind::L);
+    break;
+  case 'O':
+    token_.set_kind(TokenKind::O);
+    break;
+  case 'P':
+    token_.set_kind(TokenKind::P);
+    break;
   case 'R':
     switch (LookAheadChar()) {
-    case 'C': Advance(TokenKind::RC); break;
-    case 'D': Advance(TokenKind::RD); break;
-    case 'N': Advance(TokenKind::RN); break;
-    case 'P': Advance(TokenKind::RP); break;
-    case 'U': Advance(TokenKind::RU); break;
-    case 'Z': Advance(TokenKind::RZ); break;
-    default: token_.set_kind(TokenKind::None); break;
+    case 'C':
+      Advance(TokenKind::RC);
+      break;
+    case 'D':
+      Advance(TokenKind::RD);
+      break;
+    case 'N':
+      Advance(TokenKind::RN);
+      break;
+    case 'P':
+      Advance(TokenKind::RP);
+      break;
+    case 'U':
+      Advance(TokenKind::RU);
+      break;
+    case 'Z':
+      Advance(TokenKind::RZ);
+      break;
+    default:
+      token_.set_kind(TokenKind::None);
+      break;
     }
     break;
   case 'S':
     switch (LookAheadChar()) {
-    case 'P': Advance(TokenKind::SP); break;
-    case 'S': Advance(TokenKind::SS); break;
-    default: token_.set_kind(TokenKind::S); break;
+    case 'P':
+      Advance(TokenKind::SP);
+      break;
+    case 'S':
+      Advance(TokenKind::SS);
+      break;
+    default:
+      token_.set_kind(TokenKind::S);
+      break;
     }
     break;
   case 'T':
     switch (LookAheadChar()) {
-    case 'L': Advance(TokenKind::TL); break;
-    case 'R': Advance(TokenKind::TR); break;
-    default: token_.set_kind(TokenKind::T); break;
+    case 'L':
+      Advance(TokenKind::TL);
+      break;
+    case 'R':
+      Advance(TokenKind::TR);
+      break;
+    default:
+      token_.set_kind(TokenKind::T);
+      break;
     }
     break;
-  case 'X': token_.set_kind(TokenKind::X); break;
-  case 'Z': token_.set_kind(TokenKind::Z); break;
+  case 'X':
+    token_.set_kind(TokenKind::X);
+    break;
+  case 'Z':
+    token_.set_kind(TokenKind::Z);
+    break;
   case '-':
-  case '+': token_.set_kind(TokenKind::Sign); break;
-  case '/': token_.set_kind(TokenKind::Slash); break;
-  case '(': token_.set_kind(TokenKind::LParen); break;
-  case ')': token_.set_kind(TokenKind::RParen); break;
-  case '.': token_.set_kind(TokenKind::Point); break;
-  case ':': token_.set_kind(TokenKind::Colon); break;
-  case '\\': token_.set_kind(TokenKind::Backslash); break;
-  case '$': token_.set_kind(TokenKind::Dollar); break;
+  case '+':
+    token_.set_kind(TokenKind::Sign);
+    break;
+  case '/':
+    token_.set_kind(TokenKind::Slash);
+    break;
+  case '(':
+    token_.set_kind(TokenKind::LParen);
+    break;
+  case ')':
+    token_.set_kind(TokenKind::RParen);
+    break;
+  case '.':
+    token_.set_kind(TokenKind::Point);
+    break;
+  case ':':
+    token_.set_kind(TokenKind::Colon);
+    break;
+  case '\\':
+    token_.set_kind(TokenKind::Backslash);
+    break;
+  case '$':
+    token_.set_kind(TokenKind::Dollar);
+    break;
   case '*':
     token_.set_kind(LookAheadChar() == '(' ? TokenKind::Star : TokenKind::None);
     break;
@@ -334,7 +416,7 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
       }
     }
     SetLength();
-    if (stmt_ == IoStmtKind::Read) {  // 13.3.2p6
+    if (stmt_ == IoStmtKind::Read) { // 13.3.2p6
       ReportError("String edit descriptor in READ format expression");
     } else if (token_.kind() != TokenKind::String) {
       ReportError("Unterminated string");
@@ -353,34 +435,34 @@ template<typename CHAR> void FormatValidator<CHAR>::NextToken() {
   SetLength();
 }
 
-template<typename CHAR> void FormatValidator<CHAR>::check_r(bool allowed) {
+template <typename CHAR> void FormatValidator<CHAR>::check_r(bool allowed) {
   if (!allowed && knrValue_ >= 0) {
     ReportError("Repeat specifier before '%s' edit descriptor", knrToken_);
   } else if (knrValue_ == 0) {
     ReportError("'%s' edit descriptor repeat specifier must be positive",
-        knrToken_);  // C1304
+        knrToken_); // C1304
   }
 }
 
 // Return the predicate "w value is present" to control further processing.
-template<typename CHAR> bool FormatValidator<CHAR>::check_w() {
+template <typename CHAR> bool FormatValidator<CHAR>::check_w() {
   if (token_.kind() == TokenKind::UnsignedInteger) {
     wValue_ = integerValue_;
     if (wValue_ == 0 &&
         (*argString_ == 'A' || *argString_ == 'L' ||
-            stmt_ == IoStmtKind::Read)) {  // C1306, 13.7.2.1p6
+            stmt_ == IoStmtKind::Read)) { // C1306, 13.7.2.1p6
       ReportError("'%s' edit descriptor 'w' value must be positive");
     }
     NextToken();
     return true;
   }
   if (*argString_ != 'A') {
-    ReportWarning("Expected '%s' edit descriptor 'w' value");  // C1306
+    ReportWarning("Expected '%s' edit descriptor 'w' value"); // C1306
   }
   return false;
 }
 
-template<typename CHAR> void FormatValidator<CHAR>::check_m() {
+template <typename CHAR> void FormatValidator<CHAR>::check_m() {
   if (token_.kind() != TokenKind::Point) {
     return;
   }
@@ -390,14 +472,14 @@ template<typename CHAR> void FormatValidator<CHAR>::check_m() {
     return;
   }
   if ((stmt_ == IoStmtKind::Print || stmt_ == IoStmtKind::Write) &&
-      wValue_ > 0 && integerValue_ > wValue_) {  // 13.7.2.2p5, 13.7.2.4p6
+      wValue_ > 0 && integerValue_ > wValue_) { // 13.7.2.2p5, 13.7.2.4p6
     ReportError("'%s' edit descriptor 'm' value is greater than 'w' value");
   }
   NextToken();
 }
 
 // Return the predicate "d value is present" to control further processing.
-template<typename CHAR> bool FormatValidator<CHAR>::check_d() {
+template <typename CHAR> bool FormatValidator<CHAR>::check_d() {
   if (token_.kind() != TokenKind::Point) {
     ReportError("Expected '%s' edit descriptor '.d' value");
     return false;
@@ -411,7 +493,7 @@ template<typename CHAR> bool FormatValidator<CHAR>::check_d() {
   return true;
 }
 
-template<typename CHAR> void FormatValidator<CHAR>::check_e() {
+template <typename CHAR> void FormatValidator<CHAR>::check_e() {
   if (token_.kind() != TokenKind::E) {
     return;
   }
@@ -423,7 +505,7 @@ template<typename CHAR> void FormatValidator<CHAR>::check_e() {
   NextToken();
 }
 
-template<typename CHAR> bool FormatValidator<CHAR>::Check() {
+template <typename CHAR> bool FormatValidator<CHAR>::Check() {
   if (!*format_) {
     ReportError("Empty format expression");
     return formatHasErrors_;
@@ -435,8 +517,8 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
   }
   NextToken();
 
-  int nestLevel{0};  // Outer level ()s are at level 0.
-  Token starToken{};  // unlimited format token
+  int nestLevel{0}; // Outer level ()s are at level 0.
+  Token starToken{}; // unlimited format token
   bool hasDataEditDesc{false};
 
   // Subject to error recovery exceptions, a loop iteration processes one
@@ -446,7 +528,7 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
   //  - the error reporter requests termination (error threshold reached)
   while (!reporterExit_) {
     Token signToken{};
-    knrValue_ = -1;  // -1 ==> not present
+    knrValue_ = -1; // -1 ==> not present
     wValue_ = -1;
     bool commaRequired{true};
 
@@ -519,12 +601,12 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
       NextToken();
       if (check_w()) {
         if (wValue_ > 0) {
-          if (check_d()) {  // C1307
+          if (check_d()) { // C1307
             check_e();
           }
         } else if (token_.kind() == TokenKind::Point && check_d() &&
             token_.kind() == TokenKind::E) {
-          ReportError("Unexpected 'e' in 'G0' edit descriptor");  // C1308
+          ReportError("Unexpected 'e' in 'G0' edit descriptor"); // C1308
           NextToken();
           if (token_.kind() == TokenKind::UnsignedInteger) {
             NextToken();
@@ -616,7 +698,9 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
       case TokenKind::ES:
       case TokenKind::EX:
       case TokenKind::F:
-      case TokenKind::G: commaRequired = false; break;
+      case TokenKind::G:
+        commaRequired = false;
+        break;
       default:;
       }
       cursor_ = saveCursor;
@@ -629,14 +713,14 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
       // R1315 position-edit-desc -> T n | TL n | TR n
       check_r(false);
       NextToken();
-      if (integerValue_ <= 0) {  // C1311
+      if (integerValue_ <= 0) { // C1311
         ReportError("'%s' edit descriptor must have a positive position value");
       }
       NextToken();
       break;
     case TokenKind::X:
       // R1315 position-edit-desc -> n X
-      if (knrValue_ == 0) {  // C1311
+      if (knrValue_ == 0) { // C1311
         ReportError("'X' edit descriptor must have a positive position value",
             knrToken_);
       } else if (knrValue_ < 0) {
@@ -695,11 +779,11 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
       do {
         if (nestLevel == 0) {
           // Any characters after level-0 ) are ignored.
-          return formatHasErrors_;  // normal exit (may have messages)
+          return formatHasErrors_; // normal exit (may have messages)
         }
         if (nestLevel == 1 && starToken.IsSet() && !hasDataEditDesc) {
           SetLength(starToken);
-          ReportError(  // C1303
+          ReportError( // C1303
               "Unlimited format item list must contain a data edit descriptor",
               starToken);
         }
@@ -718,31 +802,33 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
         break;
       }
       [[fallthrough]];
-    default: ReportError("Unexpected '%s' in format expression"); NextToken();
+    default:
+      ReportError("Unexpected '%s' in format expression");
+      NextToken();
     }
 
     // Process comma separator and exit an incomplete format.
     switch (token_.kind()) {
-    case TokenKind::Colon:  // Comma not required; token not yet processed.
-    case TokenKind::Slash:  // Comma not required; token not yet processed.
-    case TokenKind::RParen:  // Comma not allowed; token not yet processed.
+    case TokenKind::Colon: // Comma not required; token not yet processed.
+    case TokenKind::Slash: // Comma not required; token not yet processed.
+    case TokenKind::RParen: // Comma not allowed; token not yet processed.
       suppressMessageCascade_ = false;
       break;
-    case TokenKind::LParen:  // Comma not allowed; token already processed.
-    case TokenKind::Comma:  // Normal comma case; move past token.
+    case TokenKind::LParen: // Comma not allowed; token already processed.
+    case TokenKind::Comma: // Normal comma case; move past token.
       suppressMessageCascade_ = false;
       NextToken();
       break;
-    case TokenKind::Sign:  // Error; main switch has a better message.
-    case TokenKind::None:  // Error; token not yet processed.
+    case TokenKind::Sign: // Error; main switch has a better message.
+    case TokenKind::None: // Error; token not yet processed.
       if (cursor_ >= end_) {
-        return formatHasErrors_;  // incomplete format error exit
+        return formatHasErrors_; // incomplete format error exit
       }
       break;
     default:
       // Possible first token of the next format item; token not yet processed.
       if (commaRequired) {
-        const char *s{"Expected ',' or ')' in format expression"};  // C1302
+        const char *s{"Expected ',' or ')' in format expression"}; // C1302
         if (previousTokenWasInt_ && itemsWithLeadingInts_.test(token_.kind())) {
           ReportError(s);
         } else {
@@ -752,8 +838,8 @@ template<typename CHAR> bool FormatValidator<CHAR>::Check() {
     }
   }
 
-  return formatHasErrors_;  // error reporter (message threshold) exit
+  return formatHasErrors_; // error reporter (message threshold) exit
 }
 
-}
-#endif  // FORTRAN_COMMON_FORMAT_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_FORMAT_H_
diff --git a/flang/include/flang/Common/idioms.h b/flang/include/flang/Common/idioms.h
index 84862f4976da..3f4f8f2eec6b 100644
--- a/flang/include/flang/Common/idioms.h
+++ b/flang/include/flang/Common/idioms.h
@@ -34,11 +34,11 @@
 #if __GNUC__ == 7
 // Avoid a deduction bug in GNU 7.x headers by forcing the answer.
 namespace std {
-template<typename A>
+template <typename A>
 struct is_trivially_copy_constructible<list<A>> : false_type {};
-template<typename A>
+template <typename A>
 struct is_trivially_copy_constructible<optional<list<A>>> : false_type {};
-}
+} // namespace std
 #endif
 
 // enable "this is a std::string"s with the 's' suffix
@@ -54,11 +54,11 @@ namespace Fortran::common {
 //         ...
 //         [&](const auto &catchAll) { ... }}, variantObject);
 
-template<typename... LAMBDAS> struct visitors : LAMBDAS... {
+template <typename... LAMBDAS> struct visitors : LAMBDAS... {
   using LAMBDAS::operator()...;
 };
 
-template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
+template <typename... LAMBDAS> visitors(LAMBDAS... x) -> visitors<LAMBDAS...>;
 
 // Calls std::fprintf(stderr, ...), then abort().
 [[noreturn]] void die(const char *, ...);
@@ -93,11 +93,11 @@ template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
 // in template specialization definitions.
 #define CLASS_TRAIT(T) \
   namespace class_trait_ns_##T { \
-    template<typename A> std::true_type test(typename A::T *); \
-    template<typename A> std::false_type test(...); \
-    template<typename A> \
+    template <typename A> std::true_type test(typename A::T *); \
+    template <typename A> std::false_type test(...); \
+    template <typename A> \
     constexpr bool has_trait{decltype(test<A>(nullptr))::value}; \
-    template<typename A> constexpr bool trait_value() { \
+    template <typename A> constexpr bool trait_value() { \
       if constexpr (has_trait<A>) { \
         using U = typename A::T; \
         return U::value; \
@@ -106,7 +106,7 @@ template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
       } \
     } \
   } \
-  template<typename A> constexpr bool T{class_trait_ns_##T::trait_value<A>()};
+  template <typename A> constexpr bool T{class_trait_ns_##T::trait_value<A>()};
 
 #if !defined ATTRIBUTE_UNUSED && (__clang__ || __GNUC__)
 #define ATTRIBUTE_UNUSED __attribute__((unused))
@@ -119,7 +119,7 @@ template<typename... LAMBDAS> visitors(LAMBDAS... x)->visitors<LAMBDAS...>;
 
 std::string EnumIndexToString(int index, const char *names);
 
-template<typename A> struct ListItemCount {
+template <typename A> struct ListItemCount {
   constexpr ListItemCount(std::initializer_list<A> list) : value{list.size()} {}
   const std::size_t value;
 };
@@ -138,7 +138,7 @@ template<typename A> struct ListItemCount {
 // Check that a pointer is non-null and dereference it
 #define DEREF(p) Fortran::common::Deref(p, __FILE__, __LINE__)
 
-template<typename T> constexpr T &Deref(T *p, const char *file, int line) {
+template <typename T> constexpr T &Deref(T *p, const char *file, int line) {
   if (!p) {
     Fortran::common::die("nullptr dereference at %s(%d)", file, line);
   }
@@ -146,7 +146,7 @@ template<typename T> constexpr T &Deref(T *p, const char *file, int line) {
 }
 
 // Given a const reference to a value, return a copy of the value.
-template<typename A> A Clone(const A &x) { return x; }
+template <typename A> A Clone(const A &x) { return x; }
 
 // C++ does a weird and dangerous thing when deducing template type parameters
 // from function arguments: lvalue references are allowed to match rvalue
@@ -159,8 +159,8 @@ template<typename A> A Clone(const A &x) { return x; }
 // or, for constructors,
 //   template<typename A, typename = common::NoLvalue<A>> int foo(A &&);
 // This works with parameter packs too.
-template<typename A, typename... B>
+template <typename A, typename... B>
 using IfNoLvalue = std::enable_if_t<(... && !std::is_lvalue_reference_v<B>), A>;
-template<typename... RVREF> using NoLvalue = IfNoLvalue<void, RVREF...>;
-}
-#endif  // FORTRAN_COMMON_IDIOMS_H_
+template <typename... RVREF> using NoLvalue = IfNoLvalue<void, RVREF...>;
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_IDIOMS_H_
diff --git a/flang/include/flang/Common/indirection.h b/flang/include/flang/Common/indirection.h
index a79fc19a388f..f34d561ae049 100644
--- a/flang/include/flang/Common/indirection.h
+++ b/flang/include/flang/Common/indirection.h
@@ -28,7 +28,7 @@
 namespace Fortran::common {
 
 // The default case does not support (deep) copy construction or assignment.
-template<typename A, bool COPY = false> class Indirection {
+template <typename A, bool COPY = false> class Indirection {
 public:
   using element_type = A;
   Indirection() = delete;
@@ -59,7 +59,7 @@ public:
   bool operator==(const A &that) const { return *p_ == that; }
   bool operator==(const Indirection &that) const { return *p_ == *that.p_; }
 
-  template<typename... ARGS>
+  template <typename... ARGS>
   static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&... args) {
     return {new A(std::move(args)...)};
   }
@@ -69,7 +69,7 @@ private:
 };
 
 // Variant with copy construction and assignment
-template<typename A> class Indirection<A, true> {
+template <typename A> class Indirection<A, true> {
 public:
   using element_type = A;
 
@@ -111,7 +111,7 @@ public:
   bool operator==(const A &that) const { return *p_ == that; }
   bool operator==(const Indirection &that) const { return *p_ == *that.p_; }
 
-  template<typename... ARGS>
+  template <typename... ARGS>
   static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&... args) {
     return {new A(std::move(args)...)};
   }
@@ -120,7 +120,7 @@ private:
   A *p_{nullptr};
 };
 
-template<typename A> using CopyableIndirection = Indirection<A, true>;
+template <typename A> using CopyableIndirection = Indirection<A, true>;
 
 // For use with std::unique_ptr<> when declaring owning pointers to
 // forward-referenced types, here's a minimal custom deleter that avoids
@@ -129,13 +129,13 @@ template<typename A> using CopyableIndirection = Indirection<A, true>;
 // type is visible.  Be advised, std::unique_ptr<> does not have copy
 // semantics; if you need ownership, copy semantics, and nullability,
 // std::optional<CopyableIndirection<>> works.
-template<typename A> class Deleter {
+template <typename A> class Deleter {
 public:
   void operator()(A *) const;
 };
-}
+} // namespace Fortran::common
 #define DEFINE_DELETER(A) \
-  template<> void Fortran::common::Deleter<A>::operator()(A *p) const { \
+  template <> void Fortran::common::Deleter<A>::operator()(A *p) const { \
     delete p; \
   }
-#endif  // FORTRAN_COMMON_INDIRECTION_H_
+#endif // FORTRAN_COMMON_INDIRECTION_H_
diff --git a/flang/include/flang/Common/interval.h b/flang/include/flang/Common/interval.h
index c1d1cfb890c8..baaa35b9efc5 100644
--- a/flang/include/flang/Common/interval.h
+++ b/flang/include/flang/Common/interval.h
@@ -19,13 +19,13 @@
 
 namespace Fortran::common {
 
-template<typename A> class Interval {
+template <typename A> class Interval {
 public:
   using type = A;
   constexpr Interval() {}
   constexpr Interval(const A &s, std::size_t n = 1) : start_{s}, size_{n} {}
   constexpr Interval(A &&s, std::size_t n = 1)
-    : start_{std::move(s)}, size_{n} {}
+      : start_{std::move(s)}, size_{n} {}
   constexpr Interval(const Interval &) = default;
   constexpr Interval(Interval &&) = default;
   constexpr Interval &operator=(const Interval &) = default;
@@ -111,5 +111,5 @@ private:
   A start_;
   std::size_t size_{0};
 };
-}
-#endif  // FORTRAN_COMMON_INTERVAL_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_INTERVAL_H_
diff --git a/flang/include/flang/Common/leading-zero-bit-count.h b/flang/include/flang/Common/leading-zero-bit-count.h
index 48fc3f129059..a296e0b44691 100644
--- a/flang/include/flang/Common/leading-zero-bit-count.h
+++ b/flang/include/flang/Common/leading-zero-bit-count.h
@@ -40,7 +40,7 @@ static constexpr std::uint8_t mapping[64]{63, 0, 58, 1, 59, 47, 53, 2, 60, 39,
     48, 27, 54, 33, 42, 3, 61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43,
     14, 22, 4, 62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21,
     56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5};
-}
+} // namespace
 
 inline constexpr int LeadingZeroBitCount(std::uint64_t x) {
   if (x == 0) {
@@ -53,13 +53,13 @@ inline constexpr int LeadingZeroBitCount(std::uint64_t x) {
     x |= x >> 16;
     x |= x >> 32;
     // All of the bits below the uppermost set bit are now also set.
-    x -= x >> 1;  // All of the bits below the uppermost are now clear.
+    x -= x >> 1; // All of the bits below the uppermost are now clear.
     // x now has exactly one bit set, so it is a power of two, so
     // multiplication by x is equivalent to a left shift by its
     // base-2 logarithm.  We calculate that unknown base-2 logarithm
     // by shifting the deBruijn sequence and mapping the framed value.
     int base2Log{mapping[(x * deBruijn) >> 58]};
-    return 63 - base2Log;  // convert to leading zero count
+    return 63 - base2Log; // convert to leading zero count
   }
 }
 
@@ -89,8 +89,8 @@ inline constexpr int LeadingZeroBitCount(std::uint8_t x) {
   return eightBitLeadingZeroBitCount[x];
 }
 
-template<typename A> inline constexpr int BitsNeededFor(A x) {
+template <typename A> inline constexpr int BitsNeededFor(A x) {
   return 8 * sizeof x - LeadingZeroBitCount(x);
 }
-}
-#endif  // FORTRAN_COMMON_LEADING_ZERO_BIT_COUNT_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_LEADING_ZERO_BIT_COUNT_H_
diff --git a/flang/include/flang/Common/real.h b/flang/include/flang/Common/real.h
index 4688e440a82d..eec29f1ca7b3 100644
--- a/flang/include/flang/Common/real.h
+++ b/flang/include/flang/Common/real.h
@@ -20,14 +20,22 @@ namespace Fortran::common {
 // Total representation size in bits for each type
 static constexpr int BitsForBinaryPrecision(int binaryPrecision) {
   switch (binaryPrecision) {
-  case 8: return 16;  // IEEE single (truncated): 1+8+7
-  case 11: return 16;  // IEEE half precision: 1+5+10
-  case 24: return 32;  // IEEE single precision: 1+8+23
-  case 53: return 64;  // IEEE double precision: 1+11+52
-  case 64: return 80;  // x87 extended precision: 1+15+64
-  case 106: return 128;  // "double-double": 2*(1+11+52)
-  case 113: return 128;  // IEEE quad precision: 1+15+112
-  default: return -1;
+  case 8:
+    return 16; // IEEE single (truncated): 1+8+7
+  case 11:
+    return 16; // IEEE half precision: 1+5+10
+  case 24:
+    return 32; // IEEE single precision: 1+8+23
+  case 53:
+    return 64; // IEEE double precision: 1+11+52
+  case 64:
+    return 80; // x87 extended precision: 1+15+64
+  case 106:
+    return 128; // "double-double": 2*(1+11+52)
+  case 113:
+    return 128; // IEEE quad precision: 1+15+112
+  default:
+    return -1;
   }
 }
 
@@ -37,18 +45,26 @@ static constexpr int BitsForBinaryPrecision(int binaryPrecision) {
 // exactly with FORMAT(E0.22981).
 static constexpr int MaxDecimalConversionDigits(int binaryPrecision) {
   switch (binaryPrecision) {
-  case 8: return 93;
-  case 11: return 17;
-  case 24: return 105;
-  case 53: return 751;
-  case 64: return 11495;
-  case 106: return 2 * 751;
-  case 113: return 11530;
-  default: return -1;
+  case 8:
+    return 93;
+  case 11:
+    return 17;
+  case 24:
+    return 105;
+  case 53:
+    return 751;
+  case 64:
+    return 11495;
+  case 106:
+    return 2 * 751;
+  case 113:
+    return 11530;
+  default:
+    return -1;
   }
 }
 
-template<int BINARY_PRECISION> class RealDetails {
+template <int BINARY_PRECISION> class RealDetails {
 private:
   // Converts bit widths to whole decimal digits
   static constexpr int LogBaseTwoToLogBaseTen(int logb2) {
@@ -82,5 +98,5 @@ public:
   static_assert(exponentBits <= 15);
 };
 
-}
-#endif  // FORTRAN_COMMON_REAL_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_REAL_H_
diff --git a/flang/include/flang/Common/reference-counted.h b/flang/include/flang/Common/reference-counted.h
index 2a96741bb8f7..6aae6cface46 100644
--- a/flang/include/flang/Common/reference-counted.h
+++ b/flang/include/flang/Common/reference-counted.h
@@ -16,7 +16,7 @@
 namespace Fortran::common {
 
 // A base class for reference-counted objects.  Must be public.
-template<typename A> class ReferenceCounted {
+template <typename A> class ReferenceCounted {
 public:
   ReferenceCounted() {}
   void TakeReference() { ++references_; }
@@ -31,7 +31,7 @@ private:
 };
 
 // A reference to a reference-counted object.
-template<typename A> class CountedReference {
+template <typename A> class CountedReference {
 public:
   using type = A;
   CountedReference() {}
@@ -72,5 +72,5 @@ private:
 
   type *p_{nullptr};
 };
-}
-#endif  // FORTRAN_COMMON_REFERENCE_COUNTED_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_REFERENCE_COUNTED_H_
diff --git a/flang/include/flang/Common/reference.h b/flang/include/flang/Common/reference.h
index f204b8f8b352..0c579de44bd7 100644
--- a/flang/include/flang/Common/reference.h
+++ b/flang/include/flang/Common/reference.h
@@ -15,7 +15,7 @@
 #define FORTRAN_COMMON_REFERENCE_H_
 #include <type_traits>
 namespace Fortran::common {
-template<typename A> class Reference {
+template <typename A> class Reference {
 public:
   using type = A;
   Reference(type &x) : p_{&x} {}
@@ -35,8 +35,8 @@ public:
   // creation of a temporary copy in cases like:
   //   Reference<type> ref;
   //   const Type &x{ref};  // creates ref to temp copy!
-  operator std::conditional_t<std::is_const_v<type>, type &, void>() const
-      noexcept {
+  operator std::conditional_t<std::is_const_v<type>, type &, void>()
+      const noexcept {
     if constexpr (std::is_const_v<type>) {
       return *p_;
     }
@@ -56,8 +56,8 @@ public:
   bool operator!=(const Reference &that) const { return !(*this == that); }
 
 private:
-  type *p_;  // never null
+  type *p_; // never null
 };
-template<typename A> Reference(A &)->Reference<A>;
-}
+template <typename A> Reference(A &) -> Reference<A>;
+} // namespace Fortran::common
 #endif
diff --git a/flang/include/flang/Common/restorer.h b/flang/include/flang/Common/restorer.h
index 26ddcfca0820..47e54237fe43 100644
--- a/flang/include/flang/Common/restorer.h
+++ b/flang/include/flang/Common/restorer.h
@@ -20,7 +20,7 @@
 #define FORTRAN_COMMON_RESTORER_H_
 #include "idioms.h"
 namespace Fortran::common {
-template<typename A> class Restorer {
+template <typename A> class Restorer {
 public:
   explicit Restorer(A &p) : p_{p}, original_{std::move(p)} {}
   ~Restorer() { p_ = std::move(original_); }
@@ -30,17 +30,17 @@ private:
   A original_;
 };
 
-template<typename A, typename B>
+template <typename A, typename B>
 common::IfNoLvalue<Restorer<A>, B> ScopedSet(A &to, B &&from) {
   Restorer<A> result{to};
   to = std::move(from);
   return result;
 }
-template<typename A, typename B>
+template <typename A, typename B>
 common::IfNoLvalue<Restorer<A>, B> ScopedSet(A &to, const B &from) {
   Restorer<A> result{to};
   to = from;
   return result;
 }
-}
-#endif  // FORTRAN_COMMON_RESTORER_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_RESTORER_H_
diff --git a/flang/include/flang/Common/template.h b/flang/include/flang/Common/template.h
index 2f726fe6cc39..866292cfcf48 100644
--- a/flang/include/flang/Common/template.h
+++ b/flang/include/flang/Common/template.h
@@ -26,7 +26,7 @@ namespace Fortran::common {
 // index of the first type T in the list for which PREDICATE<T>::value() is
 // true is returned, or -1 if the predicate is false for every type in the list.
 // This is a compile-time operation; see SearchTypes below for a run-time form.
-template<int N, template<typename> class PREDICATE, typename TUPLE>
+template <int N, template <typename> class PREDICATE, typename TUPLE>
 struct SearchTypeListHelper {
   static constexpr int value() {
     if constexpr (N >= std::tuple_size_v<TUPLE>) {
@@ -39,41 +39,41 @@ struct SearchTypeListHelper {
   }
 };
 
-template<template<typename> class PREDICATE, typename... TYPES>
+template <template <typename> class PREDICATE, typename... TYPES>
 constexpr int SearchTypeList{
     SearchTypeListHelper<0, PREDICATE, std::tuple<TYPES...>>::value()};
 
 // TypeIndex<A, TYPES...> scans a list of types for simple type equality.
 // The zero-based index of A in the list is returned, or -1 if A is not present.
-template<typename A> struct MatchType {
-  template<typename B> struct Match {
+template <typename A> struct MatchType {
+  template <typename B> struct Match {
     static constexpr bool value() {
       return std::is_same_v<std::decay_t<A>, std::decay_t<B>>;
     }
   };
 };
 
-template<typename A, typename... TYPES>
+template <typename A, typename... TYPES>
 constexpr int TypeIndex{SearchTypeList<MatchType<A>::template Match, TYPES...>};
 
 // IsTypeInList<A, TYPES...> is a simple presence predicate.
-template<typename A, typename... TYPES>
+template <typename A, typename... TYPES>
 constexpr bool IsTypeInList{TypeIndex<A, TYPES...> >= 0};
 
 // OverMembers extracts the list of types that constitute the alternatives
 // of a std::variant or elements of a std::tuple and passes that list as
 // parameter types to a given variadic template.
-template<template<typename...> class, typename> struct OverMembersHelper;
-template<template<typename...> class T, typename... Ts>
+template <template <typename...> class, typename> struct OverMembersHelper;
+template <template <typename...> class T, typename... Ts>
 struct OverMembersHelper<T, std::variant<Ts...>> {
   using type = T<Ts...>;
 };
-template<template<typename...> class T, typename... Ts>
+template <template <typename...> class T, typename... Ts>
 struct OverMembersHelper<T, std::tuple<Ts...>> {
   using type = T<Ts...>;
 };
 
-template<template<typename...> class T, typename TUPLEorVARIANT>
+template <template <typename...> class T, typename TUPLEorVARIANT>
 using OverMembers =
     typename OverMembersHelper<T, std::decay_t<TUPLEorVARIANT>>::type;
 
@@ -82,23 +82,23 @@ using OverMembers =
 // The zero-based index of the first type T among the alternatives for which
 // PREDICATE<T>::value() is true is returned, or -1 when the predicate is false
 // for every type in the set.
-template<template<typename> class PREDICATE> struct SearchMembersHelper {
-  template<typename... Ts> struct Scanner {
+template <template <typename> class PREDICATE> struct SearchMembersHelper {
+  template <typename... Ts> struct Scanner {
     static constexpr int value() { return SearchTypeList<PREDICATE, Ts...>; }
   };
 };
 
-template<template<typename> class PREDICATE, typename TUPLEorVARIANT>
+template <template <typename> class PREDICATE, typename TUPLEorVARIANT>
 constexpr int SearchMembers{
     OverMembers<SearchMembersHelper<PREDICATE>::template Scanner,
         TUPLEorVARIANT>::value()};
 
-template<typename A, typename TUPLEorVARIANT>
+template <typename A, typename TUPLEorVARIANT>
 constexpr bool HasMember{
     SearchMembers<MatchType<A>::template Match, TUPLEorVARIANT> >= 0};
 
 // std::optional<std::optional<A>> -> std::optional<A>
-template<typename A>
+template <typename A>
 std::optional<A> JoinOptional(std::optional<std::optional<A>> &&x) {
   if (x) {
     return std::move(*x);
@@ -107,7 +107,7 @@ std::optional<A> JoinOptional(std::optional<std::optional<A>> &&x) {
 }
 
 // Convert an std::optional to an ordinary pointer
-template<typename A> const A *GetPtrFromOptional(const std::optional<A> &x) {
+template <typename A> const A *GetPtrFromOptional(const std::optional<A> &x) {
   if (x) {
     return &*x;
   } else {
@@ -117,13 +117,13 @@ template<typename A> const A *GetPtrFromOptional(const std::optional<A> &x) {
 
 // Copy a value from one variant type to another.  The types allowed in the
 // source variant must all be allowed in the destination variant type.
-template<typename TOV, typename FROMV> TOV CopyVariant(const FROMV &u) {
+template <typename TOV, typename FROMV> TOV CopyVariant(const FROMV &u) {
   return std::visit([](const auto &x) -> TOV { return {x}; }, u);
 }
 
 // Move a value from one variant type to another.  The types allowed in the
 // source variant must all be allowed in the destination variant type.
-template<typename TOV, typename FROMV>
+template <typename TOV, typename FROMV>
 common::IfNoLvalue<TOV, FROMV> MoveVariant(FROMV &&u) {
   return std::visit(
       [](auto &&x) -> TOV { return {std::move(x)}; }, std::move(u));
@@ -134,26 +134,26 @@ common::IfNoLvalue<TOV, FROMV> MoveVariant(FROMV &&u) {
 // types.  E.g.,
 //   CombineTuples<std::tuple<char, int>, std::tuple<float, double>>
 // is std::tuple<char, int, float, double>.
-template<typename... TUPLES> struct CombineTuplesHelper {
+template <typename... TUPLES> struct CombineTuplesHelper {
   static decltype(auto) f(TUPLES *... a) {
     return std::tuple_cat(std::move(*a)...);
   }
   using type = decltype(f(static_cast<TUPLES *>(nullptr)...));
 };
-template<typename... TUPLES>
+template <typename... TUPLES>
 using CombineTuples = typename CombineTuplesHelper<TUPLES...>::type;
 
 // CombineVariants takes a list of std::variant<> instantiations and constructs
 // a new instantiation that holds all of their alternatives, which must be
 // pairwise distinct.
-template<typename> struct VariantToTupleHelper;
-template<typename... Ts> struct VariantToTupleHelper<std::variant<Ts...>> {
+template <typename> struct VariantToTupleHelper;
+template <typename... Ts> struct VariantToTupleHelper<std::variant<Ts...>> {
   using type = std::tuple<Ts...>;
 };
-template<typename VARIANT>
+template <typename VARIANT>
 using VariantToTuple = typename VariantToTupleHelper<VARIANT>::type;
 
-template<typename A, typename... REST> struct AreTypesDistinctHelper {
+template <typename A, typename... REST> struct AreTypesDistinctHelper {
   static constexpr bool value() {
     if constexpr (sizeof...(REST) > 0) {
       // extra () for clang-format
@@ -163,10 +163,10 @@ template<typename A, typename... REST> struct AreTypesDistinctHelper {
     return true;
   }
 };
-template<typename... Ts>
+template <typename... Ts>
 constexpr bool AreTypesDistinct{AreTypesDistinctHelper<Ts...>::value()};
 
-template<typename A, typename... Ts> struct AreSameTypeHelper {
+template <typename A, typename... Ts> struct AreSameTypeHelper {
   using type = A;
   static constexpr bool value() {
     if constexpr (sizeof...(Ts) == 0) {
@@ -178,53 +178,53 @@ template<typename A, typename... Ts> struct AreSameTypeHelper {
   }
 };
 
-template<typename... Ts>
+template <typename... Ts>
 constexpr bool AreSameType{AreSameTypeHelper<Ts...>::value()};
 
-template<typename> struct TupleToVariantHelper;
-template<typename... Ts> struct TupleToVariantHelper<std::tuple<Ts...>> {
+template <typename> struct TupleToVariantHelper;
+template <typename... Ts> struct TupleToVariantHelper<std::tuple<Ts...>> {
   static_assert(AreTypesDistinct<Ts...>,
       "TupleToVariant: types are not pairwise distinct");
   using type = std::variant<Ts...>;
 };
-template<typename TUPLE>
+template <typename TUPLE>
 using TupleToVariant = typename TupleToVariantHelper<TUPLE>::type;
 
-template<typename... VARIANTS> struct CombineVariantsHelper {
+template <typename... VARIANTS> struct CombineVariantsHelper {
   using type = TupleToVariant<CombineTuples<VariantToTuple<VARIANTS>...>>;
 };
-template<typename... VARIANTS>
+template <typename... VARIANTS>
 using CombineVariants = typename CombineVariantsHelper<VARIANTS...>::type;
 
 // SquashVariantOfVariants: given a std::variant whose alternatives are
 // all std::variant instantiations, form a new union over their alternatives.
-template<typename VARIANT>
+template <typename VARIANT>
 using SquashVariantOfVariants = OverMembers<CombineVariants, VARIANT>;
 
 // Given a type function, MapTemplate applies it to each of the types
 // in a tuple or variant, and collect the results in a given variadic
 // template (typically a std::variant).
-template<template<typename> class, template<typename...> class, typename...>
+template <template <typename> class, template <typename...> class, typename...>
 struct MapTemplateHelper;
-template<template<typename> class F, template<typename...> class PACKAGE,
+template <template <typename> class F, template <typename...> class PACKAGE,
     typename... Ts>
 struct MapTemplateHelper<F, PACKAGE, std::tuple<Ts...>> {
   using type = PACKAGE<F<Ts>...>;
 };
-template<template<typename> class F, template<typename...> class PACKAGE,
+template <template <typename> class F, template <typename...> class PACKAGE,
     typename... Ts>
 struct MapTemplateHelper<F, PACKAGE, std::variant<Ts...>> {
   using type = PACKAGE<F<Ts>...>;
 };
-template<template<typename> class F, typename TUPLEorVARIANT,
-    template<typename...> class PACKAGE = std::variant>
+template <template <typename> class F, typename TUPLEorVARIANT,
+    template <typename...> class PACKAGE = std::variant>
 using MapTemplate =
     typename MapTemplateHelper<F, PACKAGE, TUPLEorVARIANT>::type;
 
 // std::tuple<std::optional<>...> -> std::optional<std::tuple<...>>
 // i.e., inverts a tuple of optional values into an optional tuple that has
 // a value only if all of the original elements were present.
-template<typename... A, std::size_t... J>
+template <typename... A, std::size_t... J>
 std::optional<std::tuple<A...>> AllElementsPresentHelper(
     std::tuple<std::optional<A>...> &&t, std::index_sequence<J...>) {
   bool present[]{std::get<J>(t).has_value()...};
@@ -236,7 +236,7 @@ std::optional<std::tuple<A...>> AllElementsPresentHelper(
   return {std::make_tuple(*std::get<J>(t)...)};
 }
 
-template<typename... A>
+template <typename... A>
 std::optional<std::tuple<A...>> AllElementsPresent(
     std::tuple<std::optional<A>...> &&t) {
   return AllElementsPresentHelper(
@@ -246,7 +246,7 @@ std::optional<std::tuple<A...>> AllElementsPresent(
 // std::vector<std::optional<A>> -> std::optional<std::vector<A>>
 // i.e., inverts a vector of optional values into an optional vector that
 // will have a value only when all of the original elements are present.
-template<typename A>
+template <typename A>
 std::optional<std::vector<A>> AllElementsPresent(
     std::vector<std::optional<A>> &&v) {
   for (const auto &maybeA : v) {
@@ -264,7 +264,7 @@ std::optional<std::vector<A>> AllElementsPresent(
 // (std::optional<>...) -> std::optional<std::tuple<...>>
 // i.e., given some number of optional values, return a optional tuple of
 // those values that is present only of all of the values were so.
-template<typename... A>
+template <typename... A>
 std::optional<std::tuple<A...>> AllPresent(std::optional<A> &&... x) {
   return AllElementsPresent(std::make_tuple(std::move(x)...));
 }
@@ -274,7 +274,7 @@ std::optional<std::tuple<A...>> AllPresent(std::optional<A> &&... x) {
 // N.B. If the function returns std::optional, MapOptional will return
 // std::optional<std::optional<...>> and you will probably want to
 // run it through JoinOptional to "squash" it.
-template<typename R, typename... A>
+template <typename R, typename... A>
 std::optional<R> MapOptional(
     std::function<R(A &&...)> &&f, std::optional<A> &&... x) {
   if (auto args{AllPresent(std::move(x)...)}) {
@@ -282,7 +282,7 @@ std::optional<R> MapOptional(
   }
   return std::nullopt;
 }
-template<typename R, typename... A>
+template <typename R, typename... A>
 std::optional<R> MapOptional(R (*f)(A &&...), std::optional<A> &&... x) {
   return MapOptional(std::function<R(A && ...)>{f}, std::move(x)...);
 }
@@ -297,7 +297,7 @@ std::optional<R> MapOptional(R (*f)(A &&...), std::optional<A> &&... x) {
 // and invoke VISITOR::Test<T>() on each until it returns a value that
 // casts to true.  If no invocation of Test succeeds, SearchTypes will
 // return a default value.
-template<std::size_t J, typename VISITOR>
+template <std::size_t J, typename VISITOR>
 common::IfNoLvalue<typename VISITOR::Result, VISITOR> SearchTypesHelper(
     VISITOR &&visitor, typename VISITOR::Result &&defaultResult) {
   using Tuple = typename VISITOR::Types;
@@ -312,12 +312,12 @@ common::IfNoLvalue<typename VISITOR::Result, VISITOR> SearchTypesHelper(
   }
 }
 
-template<typename VISITOR>
+template <typename VISITOR>
 common::IfNoLvalue<typename VISITOR::Result, VISITOR> SearchTypes(
     VISITOR &&visitor,
     typename VISITOR::Result defaultResult = typename VISITOR::Result{}) {
   return SearchTypesHelper<0, VISITOR>(
       std::move(visitor), std::move(defaultResult));
 }
-}
-#endif  // FORTRAN_COMMON_TEMPLATE_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_TEMPLATE_H_
diff --git a/flang/include/flang/Common/uint128.h b/flang/include/flang/Common/uint128.h
index 48e1f49e8e90..996b13778322 100644
--- a/flang/include/flang/Common/uint128.h
+++ b/flang/include/flang/Common/uint128.h
@@ -13,7 +13,7 @@
 #define FORTRAN_COMMON_UINT128_H_
 
 #ifndef AVOID_NATIVE_UINT128_T
-#define AVOID_NATIVE_UINT128_T 1  // always use this code for now for testing
+#define AVOID_NATIVE_UINT128_T 1 // always use this code for now for testing
 #endif
 
 #include "leading-zero-bit-count.h"
@@ -31,14 +31,14 @@ public:
   constexpr UnsignedInt128(unsigned long n) : low_{n} {}
   constexpr UnsignedInt128(unsigned long long n) : low_{n} {}
   constexpr UnsignedInt128(int n)
-    : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                               n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
+                                                 n < 0)} {}
   constexpr UnsignedInt128(long n)
-    : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                               n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
+                                                 n < 0)} {}
   constexpr UnsignedInt128(long long n)
-    : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                               n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
+                                                 n < 0)} {}
   constexpr UnsignedInt128(const UnsignedInt128 &) = default;
   constexpr UnsignedInt128(UnsignedInt128 &&) = default;
   constexpr UnsignedInt128 &operator=(const UnsignedInt128 &) = default;
@@ -241,7 +241,7 @@ public:
 
 private:
   constexpr UnsignedInt128(std::uint64_t hi, std::uint64_t lo)
-    : low_{lo}, high_{hi} {}
+      : low_{lo}, high_{hi} {}
   constexpr int LeadingZeroes() const {
     if (high_ == 0) {
       return 64 + LeadingZeroBitCount(low_);
@@ -261,14 +261,14 @@ using uint128_t = __uint128_t;
 using uint128_t = UnsignedInt128;
 #endif
 
-template<int BITS> struct HostUnsignedIntTypeHelper {
+template <int BITS> struct HostUnsignedIntTypeHelper {
   using type = std::conditional_t<(BITS <= 8), std::uint8_t,
       std::conditional_t<(BITS <= 16), std::uint16_t,
           std::conditional_t<(BITS <= 32), std::uint32_t,
               std::conditional_t<(BITS <= 64), std::uint64_t, uint128_t>>>>;
 };
-template<int BITS>
+template <int BITS>
 using HostUnsignedIntType = typename HostUnsignedIntTypeHelper<BITS>::type;
 
-}
+} // namespace Fortran::common
 #endif
diff --git a/flang/include/flang/Common/unsigned-const-division.h b/flang/include/flang/Common/unsigned-const-division.h
index 752bbd94e7fa..0799edbe0ef9 100644
--- a/flang/include/flang/Common/unsigned-const-division.h
+++ b/flang/include/flang/Common/unsigned-const-division.h
@@ -22,7 +22,7 @@
 
 namespace Fortran::common {
 
-template<typename UINT> class FixedPointReciprocal {
+template <typename UINT> class FixedPointReciprocal {
 public:
   using type = UINT;
 
@@ -36,7 +36,7 @@ public:
   static constexpr FixedPointReciprocal For(type n) {
     if (n == 0) {
       return {0, 0};
-    } else if ((n & (n - 1)) == 0) {  // n is a power of two
+    } else if ((n & (n - 1)) == 0) { // n is a power of two
       return {TrailingZeroBitCount(n), 1};
     } else {
       int shift{bits - 1 + BitsNeededFor(n)};
@@ -60,7 +60,7 @@ static_assert(FixedPointReciprocal<std::uint32_t>::For(5).Divide(2000000000u) ==
 static_assert(FixedPointReciprocal<std::uint64_t>::For(10).Divide(
                   10000000000000000u) == 1000000000000000u);
 
-template<typename UINT, std::uint64_t DENOM>
+template <typename UINT, std::uint64_t DENOM>
 inline constexpr UINT DivideUnsignedBy(UINT n) {
   if constexpr (std::is_same_v<UINT, uint128_t>) {
     return n / static_cast<UINT>(DENOM);
@@ -73,5 +73,5 @@ inline constexpr UINT DivideUnsignedBy(UINT n) {
     return recip.Divide(n);
   }
 }
-}
+} // namespace Fortran::common
 #endif
diff --git a/flang/include/flang/Common/unwrap.h b/flang/include/flang/Common/unwrap.h
index 8a14bf68fb27..339b6a77edc0 100644
--- a/flang/include/flang/Common/unwrap.h
+++ b/flang/include/flang/Common/unwrap.h
@@ -37,7 +37,7 @@
 namespace Fortran::common {
 
 // Utility: Produces "const A" if B is const and A is not already so.
-template<typename A, typename B>
+template <typename A, typename B>
 using Constify = std::conditional_t<std::is_const_v<B> && !std::is_const_v<A>,
     std::add_const_t<A>, A>;
 
@@ -46,7 +46,7 @@ using Constify = std::conditional_t<std::is_const_v<B> && !std::is_const_v<A>,
 struct UnwrapperHelper {
 
   // Base case
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(B &x) -> Constify<A, B> * {
     if constexpr (std::is_same_v<std::decay_t<A>, std::decay_t<B>>) {
       return &x;
@@ -56,7 +56,7 @@ struct UnwrapperHelper {
   }
 
   // Implementations of specializations
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(B *p) -> Constify<A, B> * {
     if (p) {
       return Unwrap<A>(*p);
@@ -65,7 +65,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const std::unique_ptr<B> &p) -> Constify<A, B> * {
     if (p.get()) {
       return Unwrap<A>(*p);
@@ -74,7 +74,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const std::shared_ptr<B> &p) -> Constify<A, B> * {
     if (p.get()) {
       return Unwrap<A>(*p);
@@ -83,7 +83,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(std::optional<B> &x) -> Constify<A, B> * {
     if (x) {
       return Unwrap<A>(*x);
@@ -92,7 +92,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const std::optional<B> &x) -> Constify<A, B> * {
     if (x) {
       return Unwrap<A>(*x);
@@ -101,7 +101,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename... Bs>
+  template <typename A, typename... Bs>
   static A *Unwrap(std::variant<Bs...> &u) {
     return std::visit(
         [](auto &x) -> A * {
@@ -115,23 +115,23 @@ struct UnwrapperHelper {
         u);
   }
 
-  template<typename A, typename... Bs>
+  template <typename A, typename... Bs>
   static auto Unwrap(const std::variant<Bs...> &u) -> std::add_const_t<A> * {
     return std::visit(
         [](const auto &x) -> std::add_const_t<A> * { return Unwrap<A>(x); }, u);
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const Reference<B> &ref) -> Constify<A, B> * {
     return Unwrap<A>(*ref);
   }
 
-  template<typename A, typename B, bool COPY>
+  template <typename A, typename B, bool COPY>
   static auto Unwrap(const Indirection<B, COPY> &p) -> Constify<A, B> * {
     return Unwrap<A>(*p);
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static auto Unwrap(const CountedReference<B> &p) -> Constify<A, B> * {
     if (p.get()) {
       return Unwrap<A>(*p);
@@ -141,17 +141,17 @@ struct UnwrapperHelper {
   }
 };
 
-template<typename A, typename B> auto Unwrap(B &x) -> Constify<A, B> * {
+template <typename A, typename B> auto Unwrap(B &x) -> Constify<A, B> * {
   return UnwrapperHelper::Unwrap<A>(x);
 }
 
 // Returns a copy of a wrapped value, if present, otherwise a vacant optional.
-template<typename A, typename B> std::optional<A> UnwrapCopy(const B &x) {
+template <typename A, typename B> std::optional<A> UnwrapCopy(const B &x) {
   if (const A * p{Unwrap<A>(x)}) {
     return std::make_optional<A>(*p);
   } else {
     return std::nullopt;
   }
 }
-}
-#endif  // FORTRAN_COMMON_UNWRAP_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_UNWRAP_H_
diff --git a/flang/include/flang/Decimal/binary-floating-point.h b/flang/include/flang/Decimal/binary-floating-point.h
index ad3eb3e47ad1..7cc8384861fb 100644
--- a/flang/include/flang/Decimal/binary-floating-point.h
+++ b/flang/include/flang/Decimal/binary-floating-point.h
@@ -21,9 +21,9 @@
 
 namespace Fortran::decimal {
 
-template<int BINARY_PRECISION>
+template <int BINARY_PRECISION>
 struct BinaryFloatingPointNumber
-  : public common::RealDetails<BINARY_PRECISION> {
+    : public common::RealDetails<BINARY_PRECISION> {
 
   using Details = common::RealDetails<BINARY_PRECISION>;
   using Details::bits;
@@ -40,7 +40,7 @@ struct BinaryFloatingPointNumber
   static_assert(CHAR_BIT * sizeof(RawType) >= bits);
   static constexpr RawType significandMask{(RawType{1} << significandBits) - 1};
 
-  constexpr BinaryFloatingPointNumber() {}  // zero
+  constexpr BinaryFloatingPointNumber() {} // zero
   constexpr BinaryFloatingPointNumber(
       const BinaryFloatingPointNumber &that) = default;
   constexpr BinaryFloatingPointNumber(
@@ -50,7 +50,7 @@ struct BinaryFloatingPointNumber
   constexpr BinaryFloatingPointNumber &operator=(
       BinaryFloatingPointNumber &&that) = default;
 
-  template<typename A> explicit constexpr BinaryFloatingPointNumber(A x) {
+  template <typename A> explicit constexpr BinaryFloatingPointNumber(A x) {
     static_assert(sizeof raw <= sizeof x);
     std::memcpy(reinterpret_cast<void *>(&raw),
         reinterpret_cast<const void *>(&x), sizeof raw);
@@ -92,5 +92,5 @@ struct BinaryFloatingPointNumber
 
   RawType raw{0};
 };
-}
+} // namespace Fortran::decimal
 #endif
diff --git a/flang/include/flang/Decimal/decimal.h b/flang/include/flang/Decimal/decimal.h
index 5f80ab6f349f..0bc9deb08f4c 100644
--- a/flang/include/flang/Decimal/decimal.h
+++ b/flang/include/flang/Decimal/decimal.h
@@ -72,7 +72,7 @@ enum DecimalConversionFlags {
 #define EXTRA_DECIMAL_CONVERSION_SPACE (1 + 1 + 16 - 1)
 
 #ifdef __cplusplus
-template<int PREC>
+template <int PREC>
 ConversionToDecimalResult ConvertToDecimal(char *, size_t,
     DecimalConversionFlags, int digits, enum FortranRounding rounding,
     BinaryFloatingPointNumber<PREC> x);
@@ -96,12 +96,12 @@ extern template ConversionToDecimalResult ConvertToDecimal<113>(char *, size_t,
     enum DecimalConversionFlags, int, enum FortranRounding,
     BinaryFloatingPointNumber<113>);
 
-template<int PREC> struct ConversionToBinaryResult {
+template <int PREC> struct ConversionToBinaryResult {
   BinaryFloatingPointNumber<PREC> binary;
   enum ConversionResultFlags flags { Exact };
 };
 
-template<int PREC>
+template <int PREC>
 ConversionToBinaryResult<PREC> ConvertToBinary(
     const char *&, enum FortranRounding = RoundNearest);
 
@@ -117,7 +117,7 @@ extern template ConversionToBinaryResult<64> ConvertToBinary<64>(
     const char *&, enum FortranRounding = RoundNearest);
 extern template ConversionToBinaryResult<113> ConvertToBinary<113>(
     const char *&, enum FortranRounding = RoundNearest);
-}  // namespace Fortran::decimal
+} // namespace Fortran::decimal
 extern "C" {
 #define NS(x) Fortran::decimal::x
 #else /* C++ */
@@ -146,6 +146,6 @@ enum NS(ConversionResultFlags) ConvertDecimalToLongDouble(
 #endif
 #undef NS
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 #endif
diff --git a/flang/include/flang/Evaluate/call.h b/flang/include/flang/Evaluate/call.h
index e083c75708b9..15fe5b879dc4 100644
--- a/flang/include/flang/Evaluate/call.h
+++ b/flang/include/flang/Evaluate/call.h
@@ -33,11 +33,11 @@ class Symbol;
 namespace Fortran::evaluate {
 class Component;
 class IntrinsicProcTable;
-}
+} // namespace Fortran::evaluate
 namespace Fortran::evaluate::characteristics {
 struct DummyArgument;
 struct Procedure;
-}
+} // namespace Fortran::evaluate::characteristics
 
 extern template class Fortran::common::Indirection<Fortran::evaluate::Component,
     true>;
@@ -133,7 +133,7 @@ private:
   // in the parse tree.
   std::variant<common::CopyableIndirection<Expr<SomeType>>, AssumedType> u_;
   std::optional<parser::CharBlock> keyword_;
-  bool isAlternateReturn_{false};  // whether expr is a "*label" number
+  bool isAlternateReturn_{false}; // whether expr is a "*label" number
   bool isPassedObject_{false};
   common::Intent dummyIntent_{common::Intent::Default};
 };
@@ -152,7 +152,7 @@ struct SpecificIntrinsic {
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
   IntrinsicProcedure name;
-  bool isRestrictedSpecific{false};  // if true, can only call it, not pass it
+  bool isRestrictedSpecific{false}; // if true, can only call it, not pass it
   common::CopyableIndirection<characteristics::Procedure> characteristics;
 };
 
@@ -164,7 +164,7 @@ struct ProcedureDesignator {
 
   // Exactly one of these will return a non-null pointer.
   const SpecificIntrinsic *GetSpecificIntrinsic() const;
-  const Symbol *GetSymbol() const;  // symbol or component symbol
+  const Symbol *GetSymbol() const; // symbol or component symbol
 
   // For references to NOPASS components and bindings only.
   // References to PASS components and bindings are represented
@@ -191,7 +191,7 @@ class ProcedureRef {
 public:
   CLASS_BOILERPLATE(ProcedureRef)
   ProcedureRef(ProcedureDesignator &&p, ActualArguments &&a)
-    : proc_{std::move(p)}, arguments_(std::move(a)) {}
+      : proc_{std::move(p)}, arguments_(std::move(a)) {}
   ~ProcedureRef();
 
   ProcedureDesignator &proc() { return proc_; }
@@ -210,18 +210,18 @@ protected:
   ActualArguments arguments_;
 };
 
-template<typename A> class FunctionRef : public ProcedureRef {
+template <typename A> class FunctionRef : public ProcedureRef {
 public:
   using Result = A;
   CLASS_BOILERPLATE(FunctionRef)
   explicit FunctionRef(ProcedureRef &&pr) : ProcedureRef{std::move(pr)} {}
   FunctionRef(ProcedureDesignator &&p, ActualArguments &&a)
-    : ProcedureRef{std::move(p), std::move(a)} {}
+      : ProcedureRef{std::move(p), std::move(a)} {}
 
   std::optional<DynamicType> GetType() const { return proc_.GetType(); }
-  std::optional<Constant<Result>> Fold(FoldingContext &);  // for intrinsics
+  std::optional<Constant<Result>> Fold(FoldingContext &); // for intrinsics
 };
 
 FOR_EACH_SPECIFIC_TYPE(extern template class FunctionRef, )
-}
-#endif  // FORTRAN_EVALUATE_CALL_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_CALL_H_
diff --git a/flang/include/flang/Evaluate/characteristics.h b/flang/include/flang/Evaluate/characteristics.h
index 50717f04c515..5233c5785d95 100644
--- a/flang/include/flang/Evaluate/characteristics.h
+++ b/flang/include/flang/Evaluate/characteristics.h
@@ -91,7 +91,7 @@ public:
   static std::optional<TypeAndShape> Characterize(
       const semantics::DeclTypeSpec &);
 
-  template<typename A>
+  template <typename A>
   static std::optional<TypeAndShape> Characterize(
       const A &x, FoldingContext &context) {
     if (const auto *symbol{UnwrapWholeSymbolDataRef(x)}) {
@@ -197,9 +197,9 @@ struct AlternateReturn {
 struct DummyArgument {
   DECLARE_CONSTRUCTORS_AND_ASSIGNMENTS(DummyArgument)
   DummyArgument(std::string &&name, DummyDataObject &&x)
-    : name{std::move(name)}, u{std::move(x)} {}
+      : name{std::move(name)}, u{std::move(x)} {}
   DummyArgument(std::string &&name, DummyProcedure &&x)
-    : name{std::move(name)}, u{std::move(x)} {}
+      : name{std::move(name)}, u{std::move(x)} {}
   explicit DummyArgument(AlternateReturn &&x) : u{std::move(x)} {}
   ~DummyArgument();
   bool operator==(const DummyArgument &) const;
@@ -215,7 +215,7 @@ struct DummyArgument {
   // name and pass are not characteristics and so does not participate in
   // operator== but are needed to determine if procedures are distinguishable
   std::string name;
-  bool pass{false};  // is this the PASS argument of its procedure
+  bool pass{false}; // is this the PASS argument of its procedure
   std::variant<DummyDataObject, DummyProcedure, AlternateReturn> u;
 };
 
@@ -262,7 +262,7 @@ struct Procedure {
       Attr, Pure, Elemental, BindC, ImplicitInterface, NullPointer, Subroutine)
   using Attrs = common::EnumSet<Attr, Attr_enumSize>;
   Procedure(FunctionResult &&, DummyArguments &&, Attrs);
-  Procedure(DummyArguments &&, Attrs);  // for subroutines and NULL()
+  Procedure(DummyArguments &&, Attrs); // for subroutines and NULL()
   DECLARE_CONSTRUCTORS_AND_ASSIGNMENTS(Procedure)
   ~Procedure();
   bool operator==(const Procedure &) const;
@@ -301,5 +301,5 @@ private:
   Procedure() {}
 };
 
-}
-#endif  // FORTRAN_EVALUATE_CHARACTERISTICS_H_
+} // namespace Fortran::evaluate::characteristics
+#endif // FORTRAN_EVALUATE_CHARACTERISTICS_H_
diff --git a/flang/include/flang/Evaluate/check-expression.h b/flang/include/flang/Evaluate/check-expression.h
index 2285881c329a..4e93b2ab4f32 100644
--- a/flang/include/flang/Evaluate/check-expression.h
+++ b/flang/include/flang/Evaluate/check-expression.h
@@ -28,7 +28,7 @@ class IntrinsicProcTable;
 // Predicate: true when an expression is a constant expression (in the
 // strict sense of the Fortran standard); it may not (yet) be a hard
 // constant value.
-template<typename A> bool IsConstantExpr(const A &);
+template <typename A> bool IsConstantExpr(const A &);
 extern template bool IsConstantExpr(const Expr<SomeType> &);
 extern template bool IsConstantExpr(const Expr<SomeInteger> &);
 extern template bool IsConstantExpr(const Expr<SubscriptInteger> &);
@@ -40,7 +40,7 @@ bool IsInitialDataTarget(const Expr<SomeType> &, parser::ContextualMessages &);
 // Check whether an expression is a specification expression
 // (10.1.11(2), C1010).  Constant expressions are always valid
 // specification expressions.
-template<typename A>
+template <typename A>
 void CheckSpecificationExpr(
     const A &, parser::ContextualMessages &, const semantics::Scope &);
 extern template void CheckSpecificationExpr(const Expr<SomeType> &x,
@@ -60,10 +60,10 @@ extern template void CheckSpecificationExpr(
     parser::ContextualMessages &, const semantics::Scope &);
 
 // Simple contiguity (9.5.4)
-template<typename A>
+template <typename A>
 bool IsSimplyContiguous(const A &, const IntrinsicProcTable &);
 extern template bool IsSimplyContiguous(
     const Expr<SomeType> &, const IntrinsicProcTable &);
 
-}
+} // namespace Fortran::evaluate
 #endif
diff --git a/flang/include/flang/Evaluate/common.h b/flang/include/flang/Evaluate/common.h
index 639ff0c82e2e..7065977ca577 100644
--- a/flang/include/flang/Evaluate/common.h
+++ b/flang/include/flang/Evaluate/common.h
@@ -35,7 +35,8 @@ using common::RelationalOperator;
 ENUM_CLASS(Ordering, Less, Equal, Greater)
 ENUM_CLASS(Relation, Less, Equal, Greater, Unordered)
 
-template<typename A> static constexpr Ordering Compare(const A &x, const A &y) {
+template <typename A>
+static constexpr Ordering Compare(const A &x, const A &y) {
   if (x < y) {
     return Ordering::Less;
   } else if (x > y) {
@@ -87,17 +88,21 @@ static constexpr bool Satisfies(RelationalOperator op, Ordering order) {
     return op == RelationalOperator::NE || op == RelationalOperator::GE ||
         op == RelationalOperator::GT;
   }
-  return false;  // silence g++ warning
+  return false; // silence g++ warning
 }
 
 static constexpr bool Satisfies(RelationalOperator op, Relation relation) {
   switch (relation) {
-  case Relation::Less: return Satisfies(op, Ordering::Less);
-  case Relation::Equal: return Satisfies(op, Ordering::Equal);
-  case Relation::Greater: return Satisfies(op, Ordering::Greater);
-  case Relation::Unordered: return false;
+  case Relation::Less:
+    return Satisfies(op, Ordering::Less);
+  case Relation::Equal:
+    return Satisfies(op, Ordering::Equal);
+  case Relation::Greater:
+    return Satisfies(op, Ordering::Greater);
+  case Relation::Unordered:
+    return false;
   }
-  return false;  // silence g++ warning
+  return false; // silence g++ warning
 }
 
 ENUM_CLASS(
@@ -105,7 +110,7 @@ ENUM_CLASS(
 
 using RealFlags = common::EnumSet<RealFlag, RealFlag_enumSize>;
 
-template<typename A> struct ValueWithRealFlags {
+template <typename A> struct ValueWithRealFlags {
   A AccumulateFlags(RealFlags &f) {
     f |= flags;
     return value;
@@ -139,20 +144,20 @@ constexpr bool isHostLittleEndian{true};
 
 // HostUnsignedInt<BITS> finds the smallest native unsigned integer type
 // whose size is >= BITS.
-template<bool LE8, bool LE16, bool LE32, bool LE64> struct SmallestUInt {};
-template<> struct SmallestUInt<true, true, true, true> {
+template <bool LE8, bool LE16, bool LE32, bool LE64> struct SmallestUInt {};
+template <> struct SmallestUInt<true, true, true, true> {
   using type = std::uint8_t;
 };
-template<> struct SmallestUInt<false, true, true, true> {
+template <> struct SmallestUInt<false, true, true, true> {
   using type = std::uint16_t;
 };
-template<> struct SmallestUInt<false, false, true, true> {
+template <> struct SmallestUInt<false, false, true, true> {
   using type = std::uint32_t;
 };
-template<> struct SmallestUInt<false, false, false, true> {
+template <> struct SmallestUInt<false, false, false, true> {
   using type = std::uint64_t;
 };
-template<int BITS>
+template <int BITS>
 using HostUnsignedInt =
     typename SmallestUInt<BITS <= 8, BITS <= 16, BITS <= 32, BITS <= 64>::type;
 
@@ -188,8 +193,8 @@ using HostUnsignedInt =
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(t)
 
 #define UNION_CONSTRUCTORS(t) \
-  template<typename _A> explicit t(const _A &x) : u{x} {} \
-  template<typename _A, typename = common::NoLvalue<_A>> \
+  template <typename _A> explicit t(const _A &x) : u{x} {} \
+  template <typename _A, typename = common::NoLvalue<_A>> \
   explicit t(_A &&x) : u(std::move(x)) {}
 
 #define EVALUATE_UNION_CLASS_BOILERPLATE(t) \
@@ -199,29 +204,29 @@ using HostUnsignedInt =
 
 // Forward definition of Expr<> so that it can be indirectly used in its own
 // definition
-template<typename A> class Expr;
+template <typename A> class Expr;
 
 class FoldingContext {
 public:
   FoldingContext(
       const common::IntrinsicTypeDefaultKinds &d, const IntrinsicProcTable &t)
-    : defaults_{d}, intrinsics_{t} {}
+      : defaults_{d}, intrinsics_{t} {}
   FoldingContext(const parser::ContextualMessages &m,
       const common::IntrinsicTypeDefaultKinds &d, const IntrinsicProcTable &t,
       Rounding round = defaultRounding, bool flush = false)
-    : messages_{m}, defaults_{d}, intrinsics_{t}, rounding_{round},
-      flushSubnormalsToZero_{flush} {}
+      : messages_{m}, defaults_{d}, intrinsics_{t}, rounding_{round},
+        flushSubnormalsToZero_{flush} {}
   FoldingContext(const FoldingContext &that)
-    : messages_{that.messages_}, defaults_{that.defaults_},
-      intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
-      flushSubnormalsToZero_{that.flushSubnormalsToZero_},
-      pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
+      : messages_{that.messages_}, defaults_{that.defaults_},
+        intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
+        flushSubnormalsToZero_{that.flushSubnormalsToZero_},
+        pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
   FoldingContext(
       const FoldingContext &that, const parser::ContextualMessages &m)
-    : messages_{m}, defaults_{that.defaults_},
-      intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
-      flushSubnormalsToZero_{that.flushSubnormalsToZero_},
-      pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
+      : messages_{m}, defaults_{that.defaults_},
+        intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
+        flushSubnormalsToZero_{that.flushSubnormalsToZero_},
+        pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
 
   parser::ContextualMessages &messages() { return messages_; }
   const parser::ContextualMessages &messages() const { return messages_; }
@@ -263,5 +268,5 @@ private:
 };
 
 void RealFlagWarnings(FoldingContext &, const RealFlags &, const char *op);
-}
-#endif  // FORTRAN_EVALUATE_COMMON_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_COMMON_H_
diff --git a/flang/include/flang/Evaluate/complex.h b/flang/include/flang/Evaluate/complex.h
index 6c404638ab4f..5b8861caf4bf 100644
--- a/flang/include/flang/Evaluate/complex.h
+++ b/flang/include/flang/Evaluate/complex.h
@@ -19,12 +19,12 @@ class raw_ostream;
 
 namespace Fortran::evaluate::value {
 
-template<typename REAL_TYPE> class Complex {
+template <typename REAL_TYPE> class Complex {
 public:
   using Part = REAL_TYPE;
   static constexpr int bits{2 * Part::bits};
 
-  constexpr Complex() {}  // (+0.0, +0.0)
+  constexpr Complex() {} // (+0.0, +0.0)
   constexpr Complex(const Complex &) = default;
   constexpr Complex(const Part &r, const Part &i) : re_{r}, im_{i} {}
   explicit constexpr Complex(const Part &r) : re_{r} {}
@@ -59,7 +59,7 @@ public:
     return re_.IsSignalingNaN() || im_.IsSignalingNaN();
   }
 
-  template<typename INT>
+  template <typename INT>
   static ValueWithRealFlags<Complex> FromInteger(
       const INT &n, Rounding rounding = defaultRounding) {
     ValueWithRealFlags<Complex> result;
@@ -101,5 +101,5 @@ extern template class Complex<Real<Integer<32>, 24>>;
 extern template class Complex<Real<Integer<64>, 53>>;
 extern template class Complex<Real<Integer<80>, 64>>;
 extern template class Complex<Real<Integer<128>, 113>>;
-}
-#endif  // FORTRAN_EVALUATE_COMPLEX_H_
+} // namespace Fortran::evaluate::value
+#endif // FORTRAN_EVALUATE_COMPLEX_H_
diff --git a/flang/include/flang/Evaluate/constant.h b/flang/include/flang/Evaluate/constant.h
index e57563a6ee8c..04ebc991d215 100644
--- a/flang/include/flang/Evaluate/constant.h
+++ b/flang/include/flang/Evaluate/constant.h
@@ -37,7 +37,7 @@ using SymbolRef = common::Reference<const Symbol>;
 // constants, use a generic expression like Expr<SomeInteger> &
 // Expr<SomeType>) to wrap the appropriate instantiation of Constant<>.
 
-template<typename> class Constant;
+template <typename> class Constant;
 
 // When describing shapes of constants or specifying 1-based subscript
 // values as indices into constants, use a vector of integers.
@@ -87,7 +87,7 @@ private:
 // Constant<> is specialized for Character kinds and SomeDerived.
 // The non-Character intrinsic types, and SomeDerived, share enough
 // common behavior that they use this common base class.
-template<typename RESULT, typename ELEMENT = Scalar<RESULT>>
+template <typename RESULT, typename ELEMENT = Scalar<RESULT>>
 class ConstantBase : public ConstantBounds {
   static_assert(RESULT::category != TypeCategory::Character);
 
@@ -95,11 +95,11 @@ public:
   using Result = RESULT;
   using Element = ELEMENT;
 
-  template<typename A>
+  template <typename A>
   ConstantBase(const A &x, Result res = Result{}) : result_{res}, values_{x} {}
-  template<typename A, typename = common::NoLvalue<A>>
+  template <typename A, typename = common::NoLvalue<A>>
   ConstantBase(A &&x, Result res = Result{})
-    : result_{res}, values_{std::move(x)} {}
+      : result_{res}, values_{std::move(x)} {}
   ConstantBase(
       std::vector<Element> &&, ConstantSubscripts &&, Result = Result{});
 
@@ -124,7 +124,7 @@ protected:
   std::vector<Element> values_;
 };
 
-template<typename T> class Constant : public ConstantBase<T> {
+template <typename T> class Constant : public ConstantBase<T> {
 public:
   using Result = T;
   using Base = ConstantBase<T>;
@@ -149,7 +149,7 @@ public:
       ConstantSubscripts &resultSubscripts, const std::vector<int> *dimOrder);
 };
 
-template<int KIND>
+template <int KIND>
 class Constant<Type<TypeCategory::Character, KIND>> : public ConstantBounds {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
@@ -189,7 +189,7 @@ public:
       ConstantSubscripts &resultSubscripts, const std::vector<int> *dimOrder);
 
 private:
-  Scalar<Result> values_;  // one contiguous string
+  Scalar<Result> values_; // one contiguous string
   ConstantSubscript length_;
   ConstantSubscripts shape_;
   ConstantSubscripts lbounds_;
@@ -199,9 +199,9 @@ class StructureConstructor;
 using StructureConstructorValues =
     std::map<SymbolRef, common::CopyableIndirection<Expr<SomeType>>>;
 
-template<>
+template <>
 class Constant<SomeDerived>
-  : public ConstantBase<SomeDerived, StructureConstructorValues> {
+    : public ConstantBase<SomeDerived, StructureConstructorValues> {
 public:
   using Result = SomeDerived;
   using Element = StructureConstructorValues;
@@ -231,5 +231,5 @@ FOR_EACH_INTRINSIC_KIND(extern template class Constant, )
   FOR_EACH_LENGTHLESS_INTRINSIC_KIND(template class ConstantBase, ) \
   template class ConstantBase<SomeDerived, StructureConstructorValues>; \
   FOR_EACH_INTRINSIC_KIND(template class Constant, )
-}
-#endif  // FORTRAN_EVALUATE_CONSTANT_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_CONSTANT_H_
diff --git a/flang/include/flang/Evaluate/expression.h b/flang/include/flang/Evaluate/expression.h
index b63fb1ede37b..ebeb78f558d1 100644
--- a/flang/include/flang/Evaluate/expression.h
+++ b/flang/include/flang/Evaluate/expression.h
@@ -60,10 +60,10 @@ using common::RelationalOperator;
 // represented with an instance of some class containing a Result typedef that
 // maps to some instantiation of Type<CATEGORY, KIND>, SomeKind<CATEGORY>,
 // or SomeType.  (Exception: BOZ literal constants in generic Expr<SomeType>.)
-template<typename A> using ResultType = typename std::decay_t<A>::Result;
+template <typename A> using ResultType = typename std::decay_t<A>::Result;
 
 // Common Expr<> behaviors: every Expr<T> derives from ExpressionBase<T>.
-template<typename RESULT> class ExpressionBase {
+template <typename RESULT> class ExpressionBase {
 public:
   using Result = RESULT;
 
@@ -78,13 +78,13 @@ private:
 #endif
 
 public:
-  template<typename A> Derived &operator=(const A &x) {
+  template <typename A> Derived &operator=(const A &x) {
     Derived &d{derived()};
     d.u = x;
     return d;
   }
 
-  template<typename A> common::IfNoLvalue<Derived &, A> operator=(A &&x) {
+  template <typename A> common::IfNoLvalue<Derived &, A> operator=(A &&x) {
     Derived &d{derived()};
     d.u = std::move(x);
     return d;
@@ -106,7 +106,7 @@ public:
 // struct Add : public Operation<Add, ...>.  Uses of instances of Operation<>,
 // including its own member functions, can access each specific class derived
 // from it via its derived() member function with compile-time type safety.
-template<typename DERIVED, typename RESULT, typename... OPERANDS>
+template <typename DERIVED, typename RESULT, typename... OPERANDS>
 class Operation {
   // The extra final member is a dummy that allows a safe unused reference
   // to element 1 to arise indirectly in the definition of "right()" below
@@ -118,7 +118,7 @@ public:
   using Result = RESULT;
   static_assert(IsSpecificIntrinsicType<Result>);
   static constexpr std::size_t operands{sizeof...(OPERANDS)};
-  template<int J> using Operand = std::tuple_element_t<J, OperandTypes>;
+  template <int J> using Operand = std::tuple_element_t<J, OperandTypes>;
 
   // Unary operations wrap a single Expr with a CopyableIndirection.
   // Binary operations wrap a tuple of CopyableIndirections to Exprs.
@@ -140,7 +140,7 @@ public:
   // which must be spelled like "this->template operand<0>()" when
   // inherited in a derived class template.  There are convenience aliases
   // left() and right() that are not templates.
-  template<int J> Expr<Operand<J>> &operand() {
+  template <int J> Expr<Operand<J>> &operand() {
     if constexpr (operands == 1) {
       static_assert(J == 0);
       return operand_.value();
@@ -148,7 +148,7 @@ public:
       return std::get<J>(operand_).value();
     }
   }
-  template<int J> const Expr<Operand<J>> &operand() const {
+  template <int J> const Expr<Operand<J>> &operand() const {
     if constexpr (operands == 1) {
       static_assert(J == 0);
       return operand_.value();
@@ -198,7 +198,7 @@ private:
 
 // Conversions to specific types from expressions of known category and
 // dynamic kind.
-template<typename TO, TypeCategory FROMCAT = TO::category>
+template <typename TO, TypeCategory FROMCAT = TO::category>
 struct Convert : public Operation<Convert<TO, FROMCAT>, TO, SomeKind<FROMCAT>> {
   // Fortran doesn't have conversions between kinds of CHARACTER apart from
   // assignments, and in those the data must be convertible to/from 7-bit ASCII.
@@ -218,7 +218,7 @@ struct Convert : public Operation<Convert<TO, FROMCAT>, TO, SomeKind<FROMCAT>> {
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 };
 
-template<typename A>
+template <typename A>
 struct Parentheses : public Operation<Parentheses<A>, A, A> {
   using Result = A;
   using Operand = A;
@@ -226,30 +226,30 @@ struct Parentheses : public Operation<Parentheses<A>, A, A> {
   using Base::Base;
 };
 
-template<typename A> struct Negate : public Operation<Negate<A>, A, A> {
+template <typename A> struct Negate : public Operation<Negate<A>, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Negate, A, A>;
   using Base::Base;
 };
 
-template<int KIND>
+template <int KIND>
 struct ComplexComponent
-  : public Operation<ComplexComponent<KIND>, Type<TypeCategory::Real, KIND>,
-        Type<TypeCategory::Complex, KIND>> {
+    : public Operation<ComplexComponent<KIND>, Type<TypeCategory::Real, KIND>,
+          Type<TypeCategory::Complex, KIND>> {
   using Result = Type<TypeCategory::Real, KIND>;
   using Operand = Type<TypeCategory::Complex, KIND>;
   using Base = Operation<ComplexComponent, Result, Operand>;
   CLASS_BOILERPLATE(ComplexComponent)
   ComplexComponent(bool isImaginary, const Expr<Operand> &x)
-    : Base{x}, isImaginaryPart{isImaginary} {}
+      : Base{x}, isImaginaryPart{isImaginary} {}
   ComplexComponent(bool isImaginary, Expr<Operand> &&x)
-    : Base{std::move(x)}, isImaginaryPart{isImaginary} {}
+      : Base{std::move(x)}, isImaginaryPart{isImaginary} {}
 
   bool isImaginaryPart{true};
 };
 
-template<int KIND>
+template <int KIND>
 struct Not : public Operation<Not<KIND>, Type<TypeCategory::Logical, KIND>,
                  Type<TypeCategory::Logical, KIND>> {
   using Result = Type<TypeCategory::Logical, KIND>;
@@ -262,10 +262,10 @@ struct Not : public Operation<Not<KIND>, Type<TypeCategory::Logical, KIND>,
 // have explicit syntax for changing them.  Expressions represent
 // changes of length (e.g., for assignments and structure constructors)
 // with this operation.
-template<int KIND>
+template <int KIND>
 struct SetLength
-  : public Operation<SetLength<KIND>, Type<TypeCategory::Character, KIND>,
-        Type<TypeCategory::Character, KIND>, SubscriptInteger> {
+    : public Operation<SetLength<KIND>, Type<TypeCategory::Character, KIND>,
+          Type<TypeCategory::Character, KIND>, SubscriptInteger> {
   using Result = Type<TypeCategory::Character, KIND>;
   using CharacterOperand = Result;
   using LengthOperand = SubscriptInteger;
@@ -275,42 +275,42 @@ struct SetLength
 
 // Binary operations
 
-template<typename A> struct Add : public Operation<Add<A>, A, A, A> {
+template <typename A> struct Add : public Operation<Add<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Add, A, A, A>;
   using Base::Base;
 };
 
-template<typename A> struct Subtract : public Operation<Subtract<A>, A, A, A> {
+template <typename A> struct Subtract : public Operation<Subtract<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Subtract, A, A, A>;
   using Base::Base;
 };
 
-template<typename A> struct Multiply : public Operation<Multiply<A>, A, A, A> {
+template <typename A> struct Multiply : public Operation<Multiply<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Multiply, A, A, A>;
   using Base::Base;
 };
 
-template<typename A> struct Divide : public Operation<Divide<A>, A, A, A> {
+template <typename A> struct Divide : public Operation<Divide<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Divide, A, A, A>;
   using Base::Base;
 };
 
-template<typename A> struct Power : public Operation<Power<A>, A, A, A> {
+template <typename A> struct Power : public Operation<Power<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Power, A, A, A>;
   using Base::Base;
 };
 
-template<typename A>
+template <typename A>
 struct RealToIntPower : public Operation<RealToIntPower<A>, A, A, SomeInteger> {
   using Base = Operation<RealToIntPower, A, A, SomeInteger>;
   using Result = A;
@@ -319,74 +319,75 @@ struct RealToIntPower : public Operation<RealToIntPower<A>, A, A, SomeInteger> {
   using Base::Base;
 };
 
-template<typename A> struct Extremum : public Operation<Extremum<A>, A, A, A> {
+template <typename A> struct Extremum : public Operation<Extremum<A>, A, A, A> {
   using Result = A;
   using Operand = A;
   using Base = Operation<Extremum, A, A, A>;
   CLASS_BOILERPLATE(Extremum)
   Extremum(Ordering ord, const Expr<Operand> &x, const Expr<Operand> &y)
-    : Base{x, y}, ordering{ord} {}
+      : Base{x, y}, ordering{ord} {}
   Extremum(Ordering ord, Expr<Operand> &&x, Expr<Operand> &&y)
-    : Base{std::move(x), std::move(y)}, ordering{ord} {}
+      : Base{std::move(x), std::move(y)}, ordering{ord} {}
   Ordering ordering{Ordering::Greater};
 };
 
-template<int KIND>
+template <int KIND>
 struct ComplexConstructor
-  : public Operation<ComplexConstructor<KIND>,
-        Type<TypeCategory::Complex, KIND>, Type<TypeCategory::Real, KIND>,
-        Type<TypeCategory::Real, KIND>> {
+    : public Operation<ComplexConstructor<KIND>,
+          Type<TypeCategory::Complex, KIND>, Type<TypeCategory::Real, KIND>,
+          Type<TypeCategory::Real, KIND>> {
   using Result = Type<TypeCategory::Complex, KIND>;
   using Operand = Type<TypeCategory::Real, KIND>;
   using Base = Operation<ComplexConstructor, Result, Operand, Operand>;
   using Base::Base;
 };
 
-template<int KIND>
+template <int KIND>
 struct Concat
-  : public Operation<Concat<KIND>, Type<TypeCategory::Character, KIND>,
-        Type<TypeCategory::Character, KIND>,
-        Type<TypeCategory::Character, KIND>> {
+    : public Operation<Concat<KIND>, Type<TypeCategory::Character, KIND>,
+          Type<TypeCategory::Character, KIND>,
+          Type<TypeCategory::Character, KIND>> {
   using Result = Type<TypeCategory::Character, KIND>;
   using Operand = Result;
   using Base = Operation<Concat, Result, Operand, Operand>;
   using Base::Base;
 };
 
-template<int KIND>
+template <int KIND>
 struct LogicalOperation
-  : public Operation<LogicalOperation<KIND>, Type<TypeCategory::Logical, KIND>,
-        Type<TypeCategory::Logical, KIND>, Type<TypeCategory::Logical, KIND>> {
+    : public Operation<LogicalOperation<KIND>,
+          Type<TypeCategory::Logical, KIND>, Type<TypeCategory::Logical, KIND>,
+          Type<TypeCategory::Logical, KIND>> {
   using Result = Type<TypeCategory::Logical, KIND>;
   using Operand = Result;
   using Base = Operation<LogicalOperation, Result, Operand, Operand>;
   CLASS_BOILERPLATE(LogicalOperation)
   LogicalOperation(
       LogicalOperator opr, const Expr<Operand> &x, const Expr<Operand> &y)
-    : Base{x, y}, logicalOperator{opr} {}
+      : Base{x, y}, logicalOperator{opr} {}
   LogicalOperation(LogicalOperator opr, Expr<Operand> &&x, Expr<Operand> &&y)
-    : Base{std::move(x), std::move(y)}, logicalOperator{opr} {}
+      : Base{std::move(x), std::move(y)}, logicalOperator{opr} {}
   LogicalOperator logicalOperator;
 };
 
 // Array constructors
-template<typename RESULT> class ArrayConstructorValues;
+template <typename RESULT> class ArrayConstructorValues;
 
 struct ImpliedDoIndex {
   using Result = SubscriptInteger;
   bool operator==(const ImpliedDoIndex &) const;
   static constexpr int Rank() { return 0; }
-  parser::CharBlock name;  // nested implied DOs must use distinct names
+  parser::CharBlock name; // nested implied DOs must use distinct names
 };
 
-template<typename RESULT> class ImpliedDo {
+template <typename RESULT> class ImpliedDo {
 public:
   using Result = RESULT;
   using Index = ResultType<ImpliedDoIndex>;
   ImpliedDo(parser::CharBlock name, Expr<Index> &&lower, Expr<Index> &&upper,
       Expr<Index> &&stride, ArrayConstructorValues<Result> &&values)
-    : name_{name}, lower_{std::move(lower)}, upper_{std::move(upper)},
-      stride_{std::move(stride)}, values_{std::move(values)} {}
+      : name_{name}, lower_{std::move(lower)}, upper_{std::move(upper)},
+        stride_{std::move(stride)}, values_{std::move(values)} {}
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ImpliedDo)
   bool operator==(const ImpliedDo &) const;
   parser::CharBlock name() const { return name_; }
@@ -407,13 +408,13 @@ private:
   common::CopyableIndirection<ArrayConstructorValues<Result>> values_;
 };
 
-template<typename RESULT> struct ArrayConstructorValue {
+template <typename RESULT> struct ArrayConstructorValue {
   using Result = RESULT;
   EVALUATE_UNION_CLASS_BOILERPLATE(ArrayConstructorValue)
   std::variant<Expr<Result>, ImpliedDo<Result>> u;
 };
 
-template<typename RESULT> class ArrayConstructorValues {
+template <typename RESULT> class ArrayConstructorValues {
 public:
   using Result = RESULT;
   using Values = std::vector<ArrayConstructorValue<Result>>;
@@ -422,7 +423,7 @@ public:
 
   bool operator==(const ArrayConstructorValues &) const;
   static constexpr int Rank() { return 1; }
-  template<typename A> common::NoLvalue<A> Push(A &&x) {
+  template <typename A> common::NoLvalue<A> Push(A &&x) {
     values_.emplace_back(std::move(x));
   }
 
@@ -439,31 +440,31 @@ protected:
 // and derived types, since they must carry additional type information,
 // but that an empty ArrayConstructor can be constructed for any type
 // given an expression from which such type information may be gleaned.
-template<typename RESULT>
+template <typename RESULT>
 class ArrayConstructor : public ArrayConstructorValues<RESULT> {
 public:
   using Result = RESULT;
   using Base = ArrayConstructorValues<Result>;
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ArrayConstructor)
   explicit ArrayConstructor(Base &&values) : Base{std::move(values)} {}
-  template<typename T> explicit ArrayConstructor(const Expr<T> &) {}
+  template <typename T> explicit ArrayConstructor(const Expr<T> &) {}
   static constexpr Result result() { return Result{}; }
   static constexpr DynamicType GetType() { return Result::GetType(); }
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 };
 
-template<int KIND>
+template <int KIND>
 class ArrayConstructor<Type<TypeCategory::Character, KIND>>
-  : public ArrayConstructorValues<Type<TypeCategory::Character, KIND>> {
+    : public ArrayConstructorValues<Type<TypeCategory::Character, KIND>> {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
   using Base = ArrayConstructorValues<Result>;
   CLASS_BOILERPLATE(ArrayConstructor)
   ArrayConstructor(Expr<SubscriptInteger> &&len, Base &&v)
-    : Base{std::move(v)}, length_{std::move(len)} {}
-  template<typename A>
+      : Base{std::move(v)}, length_{std::move(len)} {}
+  template <typename A>
   explicit ArrayConstructor(const A &prototype)
-    : length_{prototype.LEN().value()} {}
+      : length_{prototype.LEN().value()} {}
   bool operator==(const ArrayConstructor &) const;
   static constexpr Result result() { return Result{}; }
   static constexpr DynamicType GetType() { return Result::GetType(); }
@@ -474,19 +475,19 @@ private:
   common::CopyableIndirection<Expr<SubscriptInteger>> length_;
 };
 
-template<>
+template <>
 class ArrayConstructor<SomeDerived>
-  : public ArrayConstructorValues<SomeDerived> {
+    : public ArrayConstructorValues<SomeDerived> {
 public:
   using Result = SomeDerived;
   using Base = ArrayConstructorValues<Result>;
   CLASS_BOILERPLATE(ArrayConstructor)
 
   ArrayConstructor(const semantics::DerivedTypeSpec &spec, Base &&v)
-    : Base{std::move(v)}, result_{spec} {}
-  template<typename A>
+      : Base{std::move(v)}, result_{spec} {}
+  template <typename A>
   explicit ArrayConstructor(const A &prototype)
-    : result_{prototype.GetType().value().GetDerivedTypeSpec()} {}
+      : result_{prototype.GetType().value().GetDerivedTypeSpec()} {}
 
   bool operator==(const ArrayConstructor &) const;
   constexpr Result result() const { return result_; }
@@ -499,9 +500,9 @@ private:
 
 // Expression representations for each type category.
 
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Integer, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Integer, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Integer, KIND>> {
 public:
   using Result = Type<TypeCategory::Integer, KIND>;
 
@@ -527,9 +528,9 @@ public:
       u;
 };
 
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Real, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Real, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Real, KIND>> {
 public:
   using Result = Type<TypeCategory::Real, KIND>;
 
@@ -552,9 +553,9 @@ public:
   common::CombineVariants<Operations, Conversions, Others> u;
 };
 
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Complex, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Complex, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Complex, KIND>> {
 public:
   using Result = Type<TypeCategory::Complex, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -576,9 +577,9 @@ FOR_EACH_INTEGER_KIND(extern template class Expr, )
 FOR_EACH_REAL_KIND(extern template class Expr, )
 FOR_EACH_COMPLEX_KIND(extern template class Expr, )
 
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Character, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Character, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Character, KIND>> {
 public:
   using Result = Type<TypeCategory::Character, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -603,7 +604,7 @@ FOR_EACH_CHARACTER_KIND(extern template class Expr, )
 // addition operator.  Character relations must have the same kind.
 // There are no relations between LOGICAL values.
 
-template<typename T>
+template <typename T>
 struct Relational : public Operation<Relational<T>, LogicalResult, T, T> {
   using Result = LogicalResult;
   using Base = Operation<Relational, LogicalResult, T, T>;
@@ -614,13 +615,13 @@ struct Relational : public Operation<Relational<T>, LogicalResult, T, T> {
   CLASS_BOILERPLATE(Relational)
   Relational(
       RelationalOperator r, const Expr<Operand> &a, const Expr<Operand> &b)
-    : Base{a, b}, opr{r} {}
+      : Base{a, b}, opr{r} {}
   Relational(RelationalOperator r, Expr<Operand> &&a, Expr<Operand> &&b)
-    : Base{std::move(a), std::move(b)}, opr{r} {}
+      : Base{std::move(a), std::move(b)}, opr{r} {}
   RelationalOperator opr;
 };
 
-template<> class Relational<SomeType> {
+template <> class Relational<SomeType> {
   // COMPLEX data are compared piecewise.
   using DirectlyComparableTypes =
       common::CombineTuples<IntegerTypes, RealTypes, CharacterTypes>;
@@ -645,9 +646,9 @@ extern template struct Relational<SomeType>;
 // do not include Relational<> operations as possibilities,
 // since the results of Relationals are always LogicalResult
 // (kind=1).
-template<int KIND>
+template <int KIND>
 class Expr<Type<TypeCategory::Logical, KIND>>
-  : public ExpressionBase<Type<TypeCategory::Logical, KIND>> {
+    : public ExpressionBase<Type<TypeCategory::Logical, KIND>> {
 public:
   using Result = Type<TypeCategory::Logical, KIND>;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -688,7 +689,7 @@ public:
   using Result = SomeDerived;
 
   explicit StructureConstructor(const semantics::DerivedTypeSpec &spec)
-    : result_{spec} {}
+      : result_{spec} {}
   StructureConstructor(
       const semantics::DerivedTypeSpec &, const StructureConstructorValues &);
   StructureConstructor(
@@ -713,7 +714,7 @@ public:
     return values_.end();
   }
 
-  const Expr<SomeType> *Find(const Symbol &) const;  // can return null
+  const Expr<SomeType> *Find(const Symbol &) const; // can return null
 
   StructureConstructor &Add(const semantics::Symbol &, Expr<SomeType> &&);
   int Rank() const { return 0; }
@@ -726,7 +727,7 @@ private:
 };
 
 // An expression whose result has a derived type.
-template<> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
+template <> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
 public:
   using Result = SomeDerived;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -738,7 +739,7 @@ public:
 // A polymorphic expression of known intrinsic type category, but dynamic
 // kind, represented as a discriminated union over Expr<Type<CAT, K>>
 // for each supported kind K in the category.
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 class Expr<SomeKind<CAT>> : public ExpressionBase<SomeKind<CAT>> {
 public:
   using Result = SomeKind<CAT>;
@@ -747,7 +748,7 @@ public:
   common::MapTemplate<Expr, CategoryTypes<CAT>> u;
 };
 
-template<> class Expr<SomeCharacter> : public ExpressionBase<SomeCharacter> {
+template <> class Expr<SomeCharacter> : public ExpressionBase<SomeCharacter> {
 public:
   using Result = SomeCharacter;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -780,7 +781,7 @@ using TypelessExpression = std::variant<BOZLiteralConstant, NullPointer,
 
 // A completely generic expression, polymorphic across all of the intrinsic type
 // categories and each of their kinds.
-template<> class Expr<SomeType> : public ExpressionBase<SomeType> {
+template <> class Expr<SomeType> : public ExpressionBase<SomeType> {
 public:
   using Result = SomeType;
   EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
@@ -790,20 +791,20 @@ public:
   // its destructor is externalized to reduce redundant default instances.
   ~Expr();
 
-  template<TypeCategory CAT, int KIND>
+  template <TypeCategory CAT, int KIND>
   explicit Expr(const Expr<Type<CAT, KIND>> &x) : u{Expr<SomeKind<CAT>>{x}} {}
 
-  template<TypeCategory CAT, int KIND>
+  template <TypeCategory CAT, int KIND>
   explicit Expr(Expr<Type<CAT, KIND>> &&x)
-    : u{Expr<SomeKind<CAT>>{std::move(x)}} {}
+      : u{Expr<SomeKind<CAT>>{std::move(x)}} {}
 
-  template<TypeCategory CAT, int KIND>
+  template <TypeCategory CAT, int KIND>
   Expr &operator=(const Expr<Type<CAT, KIND>> &x) {
     u = Expr<SomeKind<CAT>>{x};
     return *this;
   }
 
-  template<TypeCategory CAT, int KIND>
+  template <TypeCategory CAT, int KIND>
   Expr &operator=(Expr<Type<CAT, KIND>> &&x) {
     u = Expr<SomeKind<CAT>>{std::move(x)};
     return *this;
@@ -820,7 +821,7 @@ public:
 class Assignment {
 public:
   Assignment(Expr<SomeType> &&lhs, Expr<SomeType> &&rhs)
-    : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
+      : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
 
   struct Intrinsic {};
   using BoundsSpec = std::vector<Expr<SubscriptInteger>>;
@@ -838,9 +839,9 @@ public:
 struct GenericExprWrapper {
   GenericExprWrapper() {}
   explicit GenericExprWrapper(std::optional<Expr<SomeType>> &&x)
-    : v{std::move(x)} {}
+      : v{std::move(x)} {}
   ~GenericExprWrapper();
-  std::optional<Expr<SomeType>> v;  // vacant if error
+  std::optional<Expr<SomeType>> v; // vacant if error
 };
 
 // Like GenericExprWrapper but for analyzed assignments
@@ -848,7 +849,7 @@ struct GenericAssignmentWrapper {
   GenericAssignmentWrapper() {}
   explicit GenericAssignmentWrapper(Assignment &&x) : v{std::move(x)} {}
   ~GenericAssignmentWrapper();
-  std::optional<Assignment> v;  // vacant if error
+  std::optional<Assignment> v; // vacant if error
 };
 
 FOR_EACH_CATEGORY_TYPE(extern template class Expr, )
@@ -867,5 +868,5 @@ FOR_EACH_INTRINSIC_KIND(extern template class ArrayConstructor, )
   FOR_EACH_TYPE_AND_KIND(template class ExpressionBase, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructorValues, ) \
   FOR_EACH_INTRINSIC_KIND(template class ArrayConstructor, )
-}
-#endif  // FORTRAN_EVALUATE_EXPRESSION_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_EXPRESSION_H_
diff --git a/flang/include/flang/Evaluate/fold.h b/flang/include/flang/Evaluate/fold.h
index 85e497464508..ae06a9f138e0 100644
--- a/flang/include/flang/Evaluate/fold.h
+++ b/flang/include/flang/Evaluate/fold.h
@@ -28,11 +28,11 @@ using namespace Fortran::parser::literals;
 // be able to extract it.
 // Note the rvalue reference argument: the rewrites are performed in place
 // for efficiency.
-template<typename T> Expr<T> Fold(FoldingContext &context, Expr<T> &&expr) {
+template <typename T> Expr<T> Fold(FoldingContext &context, Expr<T> &&expr) {
   return Expr<T>::Rewrite(context, std::move(expr));
 }
 
-template<typename T>
+template <typename T>
 std::optional<Expr<T>> Fold(
     FoldingContext &context, std::optional<Expr<T>> &&expr) {
   if (expr) {
@@ -46,7 +46,7 @@ std::optional<Expr<T>> Fold(
 // an expression, if it has one.  It returns a pointer, which is
 // const-qualified when the expression is so.  The value can be
 // parenthesized.
-template<typename T, typename EXPR>
+template <typename T, typename EXPR>
 auto UnwrapConstantValue(EXPR &expr) -> common::Constify<Constant<T>, EXPR> * {
   if (auto *c{UnwrapExpr<Constant<T>>(expr)}) {
     return c;
@@ -62,7 +62,7 @@ auto UnwrapConstantValue(EXPR &expr) -> common::Constify<Constant<T>, EXPR> * {
 
 // GetScalarConstantValue() extracts the known scalar constant value of
 // an expression, if it has one.  The value can be parenthesized.
-template<typename T, typename EXPR>
+template <typename T, typename EXPR>
 auto GetScalarConstantValue(const EXPR &expr) -> std::optional<Scalar<T>> {
   if (const Constant<T> *constant{UnwrapConstantValue<T>(expr)}) {
     return constant->GetScalarValue();
@@ -74,7 +74,7 @@ auto GetScalarConstantValue(const EXPR &expr) -> std::optional<Scalar<T>> {
 // When an expression is a constant integer, ToInt64() extracts its value.
 // Ensure that the expression has been folded beforehand when folding might
 // be required.
-template<int KIND>
+template <int KIND>
 std::optional<std::int64_t> ToInt64(
     const Expr<Type<TypeCategory::Integer, KIND>> &expr) {
   if (auto scalar{
@@ -88,7 +88,7 @@ std::optional<std::int64_t> ToInt64(
 std::optional<std::int64_t> ToInt64(const Expr<SomeInteger> &);
 std::optional<std::int64_t> ToInt64(const Expr<SomeType> &);
 
-template<typename A>
+template <typename A>
 std::optional<std::int64_t> ToInt64(const std::optional<A> &x) {
   if (x) {
     return ToInt64(*x);
@@ -96,5 +96,5 @@ std::optional<std::int64_t> ToInt64(const std::optional<A> &x) {
     return std::nullopt;
   }
 }
-}
-#endif  // FORTRAN_EVALUATE_FOLD_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_FOLD_H_
diff --git a/flang/include/flang/Evaluate/formatting.h b/flang/include/flang/Evaluate/formatting.h
index b9f9c2f2e15a..aa82f56107fd 100644
--- a/flang/include/flang/Evaluate/formatting.h
+++ b/flang/include/flang/Evaluate/formatting.h
@@ -26,24 +26,25 @@
 
 namespace Fortran::evaluate {
 
-template<typename A>
+template <typename A>
 auto operator<<(llvm::raw_ostream &o, const A &x) -> decltype(x.AsFortran(o)) {
   return x.AsFortran(o);
 }
 
-template<typename A>
-auto operator<<(llvm::raw_ostream &o, const A &x) -> decltype(o << x.AsFortran()) {
+template <typename A>
+auto operator<<(llvm::raw_ostream &o, const A &x)
+    -> decltype(o << x.AsFortran()) {
   return o << x.AsFortran();
 }
 
-template<typename A, bool COPYABLE>
+template <typename A, bool COPYABLE>
 auto operator<<(
     llvm::raw_ostream &o, const Fortran::common::Indirection<A, COPYABLE> &x)
     -> decltype(o << x.value()) {
   return o << x.value();
 }
 
-template<typename A>
+template <typename A>
 auto operator<<(llvm::raw_ostream &o, const std::optional<A> &x)
     -> decltype(o << *x) {
   if (x) {
@@ -53,5 +54,5 @@ auto operator<<(llvm::raw_ostream &o, const std::optional<A> &x)
   }
   return o;
 }
-}
-#endif  // FORTRAN_EVALUATE_FORMATTING_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_FORMATTING_H_
diff --git a/flang/include/flang/Evaluate/intrinsics-library.h b/flang/include/flang/Evaluate/intrinsics-library.h
index 3e1bf5471c2c..9853bee1ca87 100644
--- a/flang/include/flang/Evaluate/intrinsics-library.h
+++ b/flang/include/flang/Evaluate/intrinsics-library.h
@@ -28,17 +28,17 @@ class FoldingContext;
 
 using TypeCode = unsigned char;
 
-template<typename TR, typename... TA> using FuncPointer = TR (*)(TA...);
+template <typename TR, typename... TA> using FuncPointer = TR (*)(TA...);
 // This specific type signature prevents GCC complaining about function casts.
 using GenericFunctionPointer = void (*)(void);
 
 enum class PassBy { Ref, Val };
-template<typename TA, PassBy Pass = PassBy::Ref> struct ArgumentInfo {
+template <typename TA, PassBy Pass = PassBy::Ref> struct ArgumentInfo {
   using Type = TA;
   static constexpr PassBy pass{Pass};
 };
 
-template<typename TR, typename... ArgInfo> struct Signature {
+template <typename TR, typename... ArgInfo> struct Signature {
   // Note valid template argument are of form
   //<TR, ArgumentInfo<TA, PassBy>...> where TA and TR belong to RuntimeTypes.
   // RuntimeTypes is a type union defined in intrinsics-library-templates.h to
@@ -55,7 +55,7 @@ struct IntrinsicProcedureRuntimeDescription {
   const bool isElemental;
   const GenericFunctionPointer callable;
   // Construct from description using host independent types (RuntimeTypes)
-  template<typename TR, typename... ArgInfo>
+  template <typename TR, typename... ArgInfo>
   IntrinsicProcedureRuntimeDescription(
       const Signature<TR, ArgInfo...> &signature, bool isElemental = false);
 };
@@ -64,19 +64,19 @@ struct IntrinsicProcedureRuntimeDescription {
 // constant folding.
 struct HostRuntimeIntrinsicProcedure : IntrinsicProcedureRuntimeDescription {
   // Construct from runtime pointer with host types (float, double....)
-  template<typename HostTR, typename... HostTA>
+  template <typename HostTR, typename... HostTA>
   HostRuntimeIntrinsicProcedure(const std::string &name,
       FuncPointer<HostTR, HostTA...> func, bool isElemental = false);
   HostRuntimeIntrinsicProcedure(
       const IntrinsicProcedureRuntimeDescription &rteProc,
       GenericFunctionPointer handle)
-    : IntrinsicProcedureRuntimeDescription{rteProc}, handle{handle} {}
+      : IntrinsicProcedureRuntimeDescription{rteProc}, handle{handle} {}
   GenericFunctionPointer handle;
 };
 
 // Defines a wrapper type that indirects calls to host runtime functions.
 // Valid ConstantContainer are Scalar (only for elementals) and Constant.
-template<template<typename> typename ConstantContainer, typename TR,
+template <template <typename> typename ConstantContainer, typename TR,
     typename... TA>
 using HostProcedureWrapper = std::function<ConstantContainer<TR>(
     FoldingContext &, ConstantContainer<TA>...)>;
@@ -95,7 +95,7 @@ public:
   }
   bool HasEquivalentProcedure(
       const IntrinsicProcedureRuntimeDescription &sym) const;
-  template<template<typename> typename ConstantContainer, typename TR,
+  template <template <typename> typename ConstantContainer, typename TR,
       typename... TA>
   std::optional<HostProcedureWrapper<ConstantContainer, TR, TA...>>
   GetHostProcedureWrapper(const std::string &name) const;
@@ -104,5 +104,5 @@ private:
   std::multimap<std::string, const HostRuntimeIntrinsicProcedure> procedures_;
 };
 
-}
-#endif  // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_H_
diff --git a/flang/include/flang/Evaluate/intrinsics.h b/flang/include/flang/Evaluate/intrinsics.h
index 2cc523b037e7..fc7963818919 100644
--- a/flang/include/flang/Evaluate/intrinsics.h
+++ b/flang/include/flang/Evaluate/intrinsics.h
@@ -39,7 +39,7 @@ struct CallCharacteristics {
 
 struct SpecificCall {
   SpecificCall(SpecificIntrinsic &&si, ActualArguments &&as)
-    : specificIntrinsic{std::move(si)}, arguments{std::move(as)} {}
+      : specificIntrinsic{std::move(si)}, arguments{std::move(as)} {}
   SpecificIntrinsic specificIntrinsic;
   ActualArguments arguments;
 };
@@ -47,8 +47,8 @@ struct SpecificCall {
 struct SpecificIntrinsicFunctionInterface : public characteristics::Procedure {
   SpecificIntrinsicFunctionInterface(
       characteristics::Procedure &&p, std::string n, bool isRestrictedSpecific)
-    : characteristics::Procedure{std::move(p)}, genericName{n},
-      isRestrictedSpecific{isRestrictedSpecific} {}
+      : characteristics::Procedure{std::move(p)}, genericName{n},
+        isRestrictedSpecific{isRestrictedSpecific} {}
   std::string genericName;
   bool isRestrictedSpecific;
   // N.B. If there are multiple arguments, they all have the same type.
@@ -82,7 +82,7 @@ public:
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
-  Implementation *impl_{nullptr};  // owning pointer
+  Implementation *impl_{nullptr}; // owning pointer
 };
-}
-#endif  // FORTRAN_EVALUATE_INTRINSICS_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_INTRINSICS_H_
diff --git a/flang/include/flang/Evaluate/real.h b/flang/include/flang/Evaluate/real.h
index 43b3aebbac84..3af11d2058fd 100644
--- a/flang/include/flang/Evaluate/real.h
+++ b/flang/include/flang/Evaluate/real.h
@@ -35,7 +35,7 @@ static constexpr std::int64_t ScaledLogBaseTenOfTwo{301029995664};
 // class template must be (or look like) an instance of Integer<>;
 // the second specifies the number of effective bits (binary precision)
 // in the fraction.
-template<typename WORD, int PREC>
+template <typename WORD, int PREC>
 class Real : public common::RealDetails<PREC> {
 public:
   using Word = WORD;
@@ -49,11 +49,11 @@ public:
 
   static constexpr int bits{Word::bits};
   static_assert(bits >= Details::bits);
-  using Fraction = Integer<binaryPrecision>;  // all bits made explicit
+  using Fraction = Integer<binaryPrecision>; // all bits made explicit
 
-  template<typename W, int P> friend class Real;
+  template <typename W, int P> friend class Real;
 
-  constexpr Real() {}  // +0.0
+  constexpr Real() {} // +0.0
   constexpr Real(const Real &) = default;
   constexpr Real(const Word &bits) : word_{bits} {}
   constexpr Real &operator=(const Real &) = default;
@@ -91,10 +91,10 @@ public:
     return Exponent() == 0 && !GetSignificand().IsZero();
   }
 
-  constexpr Real ABS() const {  // non-arithmetic, no flags returned
+  constexpr Real ABS() const { // non-arithmetic, no flags returned
     return {word_.IBCLR(bits - 1)};
   }
-  constexpr Real SetSign(bool toNegative) const {  // non-arithmetic
+  constexpr Real SetSign(bool toNegative) const { // non-arithmetic
     if (toNegative) {
       return {word_.IBSET(bits - 1)};
     } else {
@@ -122,7 +122,7 @@ public:
   ValueWithRealFlags<Real> HYPOT(
       const Real &, Rounding rounding = defaultRounding) const;
 
-  template<typename INT> constexpr INT EXPONENT() const {
+  template <typename INT> constexpr INT EXPONENT() const {
     if (Exponent() == maxExponent) {
       return INT::HUGE();
     } else {
@@ -143,7 +143,7 @@ public:
   }
   static constexpr Real TINY() {
     Real tiny;
-    tiny.Normalize(false, 1, Fraction::MASKL(1));  // minimum *normal* number
+    tiny.Normalize(false, 1, Fraction::MASKL(1)); // minimum *normal* number
     return tiny;
   }
 
@@ -177,17 +177,17 @@ public:
     return {infinity};
   }
 
-  template<typename INT>
+  template <typename INT>
   static ValueWithRealFlags<Real> FromInteger(
       const INT &n, Rounding rounding = defaultRounding) {
     bool isNegative{n.IsNegative()};
     INT absN{n};
     if (isNegative) {
-      absN = n.Negate().value;  // overflow is safe to ignore
+      absN = n.Negate().value; // overflow is safe to ignore
     }
     int leadz{absN.LEADZ()};
     if (leadz >= absN.bits) {
-      return {};  // all bits zero -> +0.0
+      return {}; // all bits zero -> +0.0
     }
     ValueWithRealFlags<Real> result;
     int exponent{exponentBias + absN.bits - leadz - 1};
@@ -211,7 +211,7 @@ public:
       common::RoundingMode = common::RoundingMode::ToZero) const;
 
   // Conversion to an integer (INT(), NINT(), FLOOR(), CEILING())
-  template<typename INT>
+  template <typename INT>
   constexpr ValueWithRealFlags<INT> ToInteger(
       common::RoundingMode mode = common::RoundingMode::ToZero) const {
     ValueWithRealFlags<INT> result;
@@ -226,7 +226,7 @@ public:
         RealFlag::Overflow, exponent >= exponentBias + result.value.bits);
     result.flags |= intPart.flags;
     int shift{
-        exponent - exponentBias - binaryPrecision + 1};  // positive -> left
+        exponent - exponentBias - binaryPrecision + 1}; // positive -> left
     result.value =
         result.value.ConvertUnsigned(intPart.value.GetFraction().SHIFTR(-shift))
             .value.SHIFTL(shift);
@@ -244,7 +244,7 @@ public:
     return result;
   }
 
-  template<typename A>
+  template <typename A>
   static ValueWithRealFlags<Real> Convert(
       const A &x, Rounding rounding = defaultRounding) {
     bool isNegative{x.IsNegative()};
@@ -312,10 +312,11 @@ public:
 
   // Emits a character representation for an equivalent Fortran constant
   // or parenthesized constant expression that produces this value.
-  llvm::raw_ostream &AsFortran(llvm::raw_ostream &, int kind, bool minimal = false) const;
+  llvm::raw_ostream &AsFortran(
+      llvm::raw_ostream &, int kind, bool minimal = false) const;
 
 private:
-  using Significand = Integer<significandBits>;  // no implicit bit
+  using Significand = Integer<significandBits>; // no implicit bit
 
   constexpr Significand GetSignificand() const {
     return Significand::ConvertUnsigned(word_).value;
@@ -361,15 +362,15 @@ private:
       bool isNegative, int exponent, const Fraction &, Rounding, RoundingBits,
       bool multiply = false);
 
-  Word word_{};  // an Integer<>
+  Word word_{}; // an Integer<>
 };
 
-extern template class Real<Integer<16>, 11>;  // IEEE half format
-extern template class Real<Integer<16>, 8>;  // the "other" half format
-extern template class Real<Integer<32>, 24>;  // IEEE single
-extern template class Real<Integer<64>, 53>;  // IEEE double
-extern template class Real<Integer<80>, 64>;  // 80387 extended precision
-extern template class Real<Integer<128>, 113>;  // IEEE quad
+extern template class Real<Integer<16>, 11>; // IEEE half format
+extern template class Real<Integer<16>, 8>; // the "other" half format
+extern template class Real<Integer<32>, 24>; // IEEE single
+extern template class Real<Integer<64>, 53>; // IEEE double
+extern template class Real<Integer<80>, 64>; // 80387 extended precision
+extern template class Real<Integer<128>, 113>; // IEEE quad
 // N.B. No "double-double" support.
-}
-#endif  // FORTRAN_EVALUATE_REAL_H_
+} // namespace Fortran::evaluate::value
+#endif // FORTRAN_EVALUATE_REAL_H_
diff --git a/flang/include/flang/Evaluate/rounding-bits.h b/flang/include/flang/Evaluate/rounding-bits.h
index 271d780b923f..7fddaa0fce73 100644
--- a/flang/include/flang/Evaluate/rounding-bits.h
+++ b/flang/include/flang/Evaluate/rounding-bits.h
@@ -19,9 +19,9 @@ class RoundingBits {
 public:
   constexpr RoundingBits(
       bool guard = false, bool round = false, bool sticky = false)
-    : guard_{guard}, round_{round}, sticky_{sticky} {}
+      : guard_{guard}, round_{round}, sticky_{sticky} {}
 
-  template<typename FRACTION>
+  template <typename FRACTION>
   constexpr RoundingBits(const FRACTION &fraction, int rshift) {
     if (rshift > 0 && rshift < fraction.bits + 1) {
       guard_ = fraction.BTEST(rshift - 1);
@@ -76,23 +76,30 @@ public:
   // fraction, given a rounding mode and a summary of the lost bits.
   constexpr bool MustRound(
       Rounding rounding, bool isNegative, bool isOdd) const {
-    bool round{false};  // to dodge bogus g++ warning about missing return
+    bool round{false}; // to dodge bogus g++ warning about missing return
     switch (rounding.mode) {
     case common::RoundingMode::TiesToEven:
       round = guard_ && (round_ | sticky_ | isOdd);
       break;
-    case common::RoundingMode::ToZero: break;
-    case common::RoundingMode::Down: round = isNegative && !empty(); break;
-    case common::RoundingMode::Up: round = !isNegative && !empty(); break;
-    case common::RoundingMode::TiesAwayFromZero: round = guard_; break;
+    case common::RoundingMode::ToZero:
+      break;
+    case common::RoundingMode::Down:
+      round = isNegative && !empty();
+      break;
+    case common::RoundingMode::Up:
+      round = !isNegative && !empty();
+      break;
+    case common::RoundingMode::TiesAwayFromZero:
+      round = guard_;
+      break;
     }
     return round;
   }
 
 private:
-  bool guard_{false};  // 0.5 * ulp (unit in lowest place)
-  bool round_{false};  // 0.25 * ulp
-  bool sticky_{false};  // true if any lesser-valued bit would be set
+  bool guard_{false}; // 0.5 * ulp (unit in lowest place)
+  bool round_{false}; // 0.25 * ulp
+  bool sticky_{false}; // true if any lesser-valued bit would be set
 };
-}
-#endif  // FORTRAN_EVALUATE_ROUNDING_BITS_H_
+} // namespace Fortran::evaluate::value
+#endif // FORTRAN_EVALUATE_ROUNDING_BITS_H_
diff --git a/flang/include/flang/Evaluate/shape.h b/flang/include/flang/Evaluate/shape.h
index 00724c259b2c..4c46d89e3406 100644
--- a/flang/include/flang/Evaluate/shape.h
+++ b/flang/include/flang/Evaluate/shape.h
@@ -53,7 +53,8 @@ std::optional<ConstantSubscripts> AsConstantExtents(
 
 inline int GetRank(const Shape &s) { return static_cast<int>(s.size()); }
 
-template<typename A> std::optional<Shape> GetShape(FoldingContext &, const A &);
+template <typename A>
+std::optional<Shape> GetShape(FoldingContext &, const A &);
 
 // The dimension argument to these inquiries is zero-based,
 // unlike the DIM= arguments to many intrinsics.
@@ -83,7 +84,7 @@ MaybeExtentExpr GetSize(Shape &&);
 bool ContainsAnyImpliedDoIndex(const ExtentExpr &);
 
 class GetShapeHelper
-  : public AnyTraverse<GetShapeHelper, std::optional<Shape>> {
+    : public AnyTraverse<GetShapeHelper, std::optional<Shape>> {
 public:
   using Result = std::optional<Shape>;
   using Base = AnyTraverse<GetShapeHelper, Result>;
@@ -92,7 +93,7 @@ public:
 
   Result operator()(const ImpliedDoIndex &) const { return Scalar(); }
   Result operator()(const DescriptorInquiry &) const { return Scalar(); }
-  template<int KIND> Result operator()(const TypeParamInquiry<KIND> &) const {
+  template <int KIND> Result operator()(const TypeParamInquiry<KIND> &) const {
     return Scalar();
   }
   Result operator()(const BOZLiteralConstant &) const { return Scalar(); }
@@ -101,7 +102,7 @@ public:
   }
   Result operator()(const StructureConstructor &) const { return Scalar(); }
 
-  template<typename T> Result operator()(const Constant<T> &c) const {
+  template <typename T> Result operator()(const Constant<T> &c) const {
     return AsShape(c.SHAPE());
   }
 
@@ -112,11 +113,11 @@ public:
   Result operator()(const Substring &) const;
   Result operator()(const ProcedureRef &) const;
 
-  template<typename T>
+  template <typename T>
   Result operator()(const ArrayConstructor<T> &aconst) const {
     return Shape{GetArrayConstructorExtent(aconst)};
   }
-  template<typename D, typename R, typename LO, typename RO>
+  template <typename D, typename R, typename LO, typename RO>
   Result operator()(const Operation<D, R, LO, RO> &operation) const {
     if (operation.right().Rank() > 0) {
       return (*this)(operation.right());
@@ -128,7 +129,7 @@ public:
 private:
   static Result Scalar() { return Shape{}; }
 
-  template<typename T>
+  template <typename T>
   MaybeExtentExpr GetArrayConstructorValueExtent(
       const ArrayConstructorValue<T> &value) const {
     return std::visit(
@@ -159,7 +160,7 @@ private:
         value.u);
   }
 
-  template<typename T>
+  template <typename T>
   MaybeExtentExpr GetArrayConstructorExtent(
       const ArrayConstructorValues<T> &values) const {
     ExtentExpr result{0};
@@ -176,7 +177,7 @@ private:
   FoldingContext &context_;
 };
 
-template<typename A>
+template <typename A>
 std::optional<Shape> GetShape(FoldingContext &context, const A &x) {
   return GetShapeHelper{context}(x);
 }
@@ -187,5 +188,5 @@ bool CheckConformance(parser::ContextualMessages &, const Shape &left,
     const Shape &right, const char *leftIs = "left operand",
     const char *rightIs = "right operand");
 
-}
-#endif  // FORTRAN_EVALUATE_SHAPE_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_SHAPE_H_
diff --git a/flang/include/flang/Evaluate/static-data.h b/flang/include/flang/Evaluate/static-data.h
index c588a77beee2..8a12c9893e61 100644
--- a/flang/include/flang/Evaluate/static-data.h
+++ b/flang/include/flang/Evaluate/static-data.h
@@ -78,5 +78,5 @@ private:
   int itemBytes_{1};
   std::vector<std::uint8_t> data_;
 };
-}
-#endif  // FORTRAN_EVALUATE_STATIC_DATA_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_STATIC_DATA_H_
diff --git a/flang/include/flang/Evaluate/traverse.h b/flang/include/flang/Evaluate/traverse.h
index 23b3d4cf682c..8d70c39513ef 100644
--- a/flang/include/flang/Evaluate/traverse.h
+++ b/flang/include/flang/Evaluate/traverse.h
@@ -41,42 +41,43 @@
 #include <type_traits>
 
 namespace Fortran::evaluate {
-template<typename Visitor, typename Result> class Traverse {
+template <typename Visitor, typename Result> class Traverse {
 public:
   explicit Traverse(Visitor &v) : visitor_{v} {}
 
   // Packaging
-  template<typename A, bool C>
+  template <typename A, bool C>
   Result operator()(const common::Indirection<A, C> &x) const {
     return visitor_(x.value());
   }
-  template<typename A> Result operator()(SymbolRef x) const {
+  template <typename A> Result operator()(SymbolRef x) const {
     return visitor_(*x);
   }
-  template<typename A> Result operator()(const std::unique_ptr<A> &x) const {
+  template <typename A> Result operator()(const std::unique_ptr<A> &x) const {
     return visitor_(x.get());
   }
-  template<typename A> Result operator()(const std::shared_ptr<A> &x) const {
+  template <typename A> Result operator()(const std::shared_ptr<A> &x) const {
     return visitor_(x.get());
   }
-  template<typename A> Result operator()(const A *x) const {
+  template <typename A> Result operator()(const A *x) const {
     if (x) {
       return visitor_(*x);
     } else {
       return visitor_.Default();
     }
   }
-  template<typename A> Result operator()(const std::optional<A> &x) const {
+  template <typename A> Result operator()(const std::optional<A> &x) const {
     if (x) {
       return visitor_(*x);
     } else {
       return visitor_.Default();
     }
   }
-  template<typename... A> Result operator()(const std::variant<A...> &u) const {
+  template <typename... A>
+  Result operator()(const std::variant<A...> &u) const {
     return std::visit(visitor_, u);
   }
-  template<typename A> Result operator()(const std::vector<A> &x) const {
+  template <typename A> Result operator()(const std::vector<A> &x) const {
     return CombineContents(x);
   }
 
@@ -85,7 +86,7 @@ public:
     return visitor_.Default();
   }
   Result operator()(const NullPointer &) const { return visitor_.Default(); }
-  template<typename T> Result operator()(const Constant<T> &x) const {
+  template <typename T> Result operator()(const Constant<T> &x) const {
     if constexpr (T::category == TypeCategory::Derived) {
       std::optional<Result> result;
       for (const StructureConstructorValues &map : x.values()) {
@@ -119,7 +120,7 @@ public:
       return visitor_(x.GetFirstSymbol());
     }
   }
-  template<int KIND> Result operator()(const TypeParamInquiry<KIND> &x) const {
+  template <int KIND> Result operator()(const TypeParamInquiry<KIND> &x) const {
     return visitor_(x.base());
   }
   Result operator()(const Triplet &x) const {
@@ -140,10 +141,10 @@ public:
   Result operator()(const ComplexPart &x) const {
     return visitor_(x.complex());
   }
-  template<typename T> Result operator()(const Designator<T> &x) const {
+  template <typename T> Result operator()(const Designator<T> &x) const {
     return visitor_(x.u);
   }
-  template<typename T> Result operator()(const Variable<T> &x) const {
+  template <typename T> Result operator()(const Variable<T> &x) const {
     return visitor_(x.u);
   }
   Result operator()(const DescriptorInquiry &x) const {
@@ -173,20 +174,20 @@ public:
   Result operator()(const ProcedureRef &x) const {
     return Combine(x.proc(), x.arguments());
   }
-  template<typename T> Result operator()(const FunctionRef<T> &x) const {
+  template <typename T> Result operator()(const FunctionRef<T> &x) const {
     return visitor_(static_cast<const ProcedureRef &>(x));
   }
 
   // Other primaries
-  template<typename T>
+  template <typename T>
   Result operator()(const ArrayConstructorValue<T> &x) const {
     return visitor_(x.u);
   }
-  template<typename T>
+  template <typename T>
   Result operator()(const ArrayConstructorValues<T> &x) const {
     return CombineContents(x);
   }
-  template<typename T> Result operator()(const ImpliedDo<T> &x) const {
+  template <typename T> Result operator()(const ImpliedDo<T> &x) const {
     return Combine(x.lower(), x.upper(), x.stride(), x.values());
   }
   Result operator()(const semantics::ParamValue &x) const {
@@ -207,23 +208,23 @@ public:
   }
 
   // Operations and wrappers
-  template<typename D, typename R, typename O>
+  template <typename D, typename R, typename O>
   Result operator()(const Operation<D, R, O> &op) const {
     return visitor_(op.left());
   }
-  template<typename D, typename R, typename LO, typename RO>
+  template <typename D, typename R, typename LO, typename RO>
   Result operator()(const Operation<D, R, LO, RO> &op) const {
     return Combine(op.left(), op.right());
   }
   Result operator()(const Relational<SomeType> &x) const {
     return visitor_(x.u);
   }
-  template<typename T> Result operator()(const Expr<T> &x) const {
+  template <typename T> Result operator()(const Expr<T> &x) const {
     return visitor_(x.u);
   }
 
 private:
-  template<typename ITER> Result CombineRange(ITER iter, ITER end) const {
+  template <typename ITER> Result CombineRange(ITER iter, ITER end) const {
     if (iter == end) {
       return visitor_.Default();
     } else {
@@ -235,11 +236,11 @@ private:
     }
   }
 
-  template<typename A> Result CombineContents(const A &x) const {
+  template <typename A> Result CombineContents(const A &x) const {
     return CombineRange(x.begin(), x.end());
   }
 
-  template<typename A, typename... Bs>
+  template <typename A, typename... Bs>
   Result Combine(const A &x, const Bs &... ys) const {
     if constexpr (sizeof...(Bs) == 0) {
       return visitor_(x);
@@ -253,7 +254,7 @@ private:
 
 // For validity checks across an expression: if any operator() result is
 // false, so is the overall result.
-template<typename Visitor, bool DefaultValue,
+template <typename Visitor, bool DefaultValue,
     typename Base = Traverse<Visitor, bool>>
 struct AllTraverse : public Base {
   AllTraverse(Visitor &v) : Base{v} {}
@@ -265,7 +266,7 @@ struct AllTraverse : public Base {
 // For searches over an expression: the first operator() result that
 // is truthful is the final result.  Works for Booleans, pointers,
 // and std::optional<>.
-template<typename Visitor, typename Result = bool,
+template <typename Visitor, typename Result = bool,
     typename Base = Traverse<Visitor, Result>>
 struct AnyTraverse : public Base {
   AnyTraverse(Visitor &v) : Base{v} {}
@@ -280,7 +281,8 @@ struct AnyTraverse : public Base {
   }
 };
 
-template<typename Visitor, typename Set, typename Base = Traverse<Visitor, Set>>
+template <typename Visitor, typename Set,
+    typename Base = Traverse<Visitor, Set>>
 struct SetTraverse : public Base {
   SetTraverse(Visitor &v) : Base{v} {}
   using Base::operator();
@@ -298,5 +300,5 @@ struct SetTraverse : public Base {
   }
 };
 
-}
+} // namespace Fortran::evaluate
 #endif
diff --git a/flang/include/flang/Evaluate/type.h b/flang/include/flang/Evaluate/type.h
index 97700f30e29c..93de6242aa30 100644
--- a/flang/include/flang/Evaluate/type.h
+++ b/flang/include/flang/Evaluate/type.h
@@ -37,7 +37,7 @@ class DerivedTypeSpec;
 class ParamValue;
 class Symbol;
 bool IsDescriptor(const Symbol &);
-}
+} // namespace Fortran::semantics
 
 namespace Fortran::evaluate {
 
@@ -45,7 +45,7 @@ using common::TypeCategory;
 
 // Specific intrinsic types are represented by specializations of
 // this class template Type<CATEGORY, KIND>.
-template<TypeCategory CATEGORY, int KIND = 0> class Type;
+template <TypeCategory CATEGORY, int KIND = 0> class Type;
 
 using SubscriptInteger = Type<TypeCategory::Integer, 8>;
 using CInteger = Type<TypeCategory::Integer, 4>;
@@ -65,10 +65,12 @@ static constexpr bool IsValidKindOfIntrinsicType(
   case TypeCategory::Complex:
     return kind == 2 || kind == 3 || kind == 4 || kind == 8 || kind == 10 ||
         kind == 16;
-  case TypeCategory::Character: return kind == 1 || kind == 2 || kind == 4;
+  case TypeCategory::Character:
+    return kind == 1 || kind == 2 || kind == 4;
   case TypeCategory::Logical:
     return kind == 1 || kind == 2 || kind == 4 || kind == 8;
-  default: return false;
+  default:
+    return false;
   }
 }
 
@@ -86,12 +88,12 @@ public:
     CHECK(IsValidKindOfIntrinsicType(category_, kind_));
   }
   constexpr DynamicType(int k, const semantics::ParamValue &pv)
-    : category_{TypeCategory::Character}, kind_{k}, charLength_{&pv} {
+      : category_{TypeCategory::Character}, kind_{k}, charLength_{&pv} {
     CHECK(IsValidKindOfIntrinsicType(category_, kind_));
   }
   explicit constexpr DynamicType(
       const semantics::DerivedTypeSpec &dt, bool poly = false)
-    : category_{TypeCategory::Derived}, derived_{&dt} {
+      : category_{TypeCategory::Derived}, derived_{&dt} {
     if (poly) {
       kind_ = ClassKind;
     }
@@ -113,7 +115,7 @@ public:
     result.category_ = TypeCategory::Derived;
     result.kind_ = ClassKind;
     result.derived_ = nullptr;
-    return result;  // CLASS(*)
+    return result; // CLASS(*)
   }
 
   static constexpr DynamicType AssumedType() {
@@ -121,7 +123,7 @@ public:
     result.category_ = TypeCategory::Derived;
     result.kind_ = AssumedTypeKind;
     result.derived_ = nullptr;
-    return result;  // TYPE(*)
+    return result; // TYPE(*)
   }
 
   // Comparison is deep -- type parameters are compared independently.
@@ -145,13 +147,13 @@ public:
   bool IsAssumedLengthCharacter() const;
   bool IsUnknownLengthCharacter() const;
   bool IsTypelessIntrinsicArgument() const;
-  constexpr bool IsAssumedType() const {  // TYPE(*)
+  constexpr bool IsAssumedType() const { // TYPE(*)
     return kind_ == AssumedTypeKind;
   }
-  constexpr bool IsPolymorphic() const {  // TYPE(*) or CLASS()
+  constexpr bool IsPolymorphic() const { // TYPE(*) or CLASS()
     return kind_ == ClassKind || IsAssumedType();
   }
-  constexpr bool IsUnlimitedPolymorphic() const {  // TYPE(*) or CLASS(*)
+  constexpr bool IsUnlimitedPolymorphic() const { // TYPE(*) or CLASS(*)
     return IsPolymorphic() && !derived_;
   }
   constexpr const semantics::DerivedTypeSpec &GetDerivedTypeSpec() const {
@@ -174,17 +176,17 @@ public:
   static std::optional<DynamicType> From(const semantics::DeclTypeSpec &);
   static std::optional<DynamicType> From(const semantics::Symbol &);
 
-  template<typename A> static std::optional<DynamicType> From(const A &x) {
+  template <typename A> static std::optional<DynamicType> From(const A &x) {
     return x.GetType();
   }
-  template<typename A> static std::optional<DynamicType> From(const A *p) {
+  template <typename A> static std::optional<DynamicType> From(const A *p) {
     if (!p) {
       return std::nullopt;
     } else {
       return From(*p);
     }
   }
-  template<typename A>
+  template <typename A>
   static std::optional<DynamicType> From(const std::optional<A> &x) {
     if (x) {
       return From(*x);
@@ -196,17 +198,17 @@ public:
 private:
   // Special kind codes are used to distinguish the following Fortran types.
   enum SpecialKind {
-    TypelessKind = -1,  // BOZ actual argument to intrinsic function
-    ClassKind = -2,  // CLASS(T) or CLASS(*)
-    AssumedTypeKind = -3,  // TYPE(*)
+    TypelessKind = -1, // BOZ actual argument to intrinsic function
+    ClassKind = -2, // CLASS(T) or CLASS(*)
+    AssumedTypeKind = -3, // TYPE(*)
   };
 
   constexpr DynamicType() {}
 
-  TypeCategory category_{TypeCategory::Derived};  // overridable default
+  TypeCategory category_{TypeCategory::Derived}; // overridable default
   int kind_{0};
   const semantics::ParamValue *charLength_{nullptr};
-  const semantics::DerivedTypeSpec *derived_{nullptr};  // TYPE(T), CLASS(T)
+  const semantics::DerivedTypeSpec *derived_{nullptr}; // TYPE(T), CLASS(T)
 };
 
 // Return the DerivedTypeSpec of a DynamicType if it has one.
@@ -216,7 +218,7 @@ const semantics::DerivedTypeSpec *GetDerivedTypeSpec(
 
 std::string DerivedTypeSpecAsFortran(const semantics::DerivedTypeSpec &);
 
-template<TypeCategory CATEGORY, int KIND = 0> struct TypeBase {
+template <TypeCategory CATEGORY, int KIND = 0> struct TypeBase {
   static constexpr TypeCategory category{CATEGORY};
   static constexpr int kind{KIND};
   constexpr bool operator==(const TypeBase &) const { return true; }
@@ -224,15 +226,15 @@ template<TypeCategory CATEGORY, int KIND = 0> struct TypeBase {
   static std::string AsFortran() { return GetType().AsFortran(); }
 };
 
-template<int KIND>
+template <int KIND>
 class Type<TypeCategory::Integer, KIND>
-  : public TypeBase<TypeCategory::Integer, KIND> {
+    : public TypeBase<TypeCategory::Integer, KIND> {
 public:
   using Scalar = value::Integer<8 * KIND>;
 };
 
 // REAL(KIND=2) is IEEE half-precision (16 bits)
-template<>
+template <>
 class Type<TypeCategory::Real, 2> : public TypeBase<TypeCategory::Real, 2> {
 public:
   using Scalar =
@@ -241,7 +243,7 @@ public:
 
 // REAL(KIND=3) identifies the "other" half-precision format, which is
 // basically REAL(4) without its least-order 16 fraction bits.
-template<>
+template <>
 class Type<TypeCategory::Real, 3> : public TypeBase<TypeCategory::Real, 3> {
 public:
   using Scalar =
@@ -249,7 +251,7 @@ public:
 };
 
 // REAL(KIND=4) is IEEE-754 single precision (32 bits)
-template<>
+template <>
 class Type<TypeCategory::Real, 4> : public TypeBase<TypeCategory::Real, 4> {
 public:
   using Scalar =
@@ -257,7 +259,7 @@ public:
 };
 
 // REAL(KIND=8) is IEEE double precision (64 bits)
-template<>
+template <>
 class Type<TypeCategory::Real, 8> : public TypeBase<TypeCategory::Real, 8> {
 public:
   using Scalar =
@@ -265,52 +267,52 @@ public:
 };
 
 // REAL(KIND=10) is x87 FPU extended precision (80 bits, all explicit)
-template<>
+template <>
 class Type<TypeCategory::Real, 10> : public TypeBase<TypeCategory::Real, 10> {
 public:
   using Scalar = value::Real<value::Integer<80>, 64>;
 };
 
 // REAL(KIND=16) is IEEE quad precision (128 bits)
-template<>
+template <>
 class Type<TypeCategory::Real, 16> : public TypeBase<TypeCategory::Real, 16> {
 public:
   using Scalar = value::Real<value::Integer<128>, 113>;
 };
 
 // The KIND type parameter on COMPLEX is the kind of each of its components.
-template<int KIND>
+template <int KIND>
 class Type<TypeCategory::Complex, KIND>
-  : public TypeBase<TypeCategory::Complex, KIND> {
+    : public TypeBase<TypeCategory::Complex, KIND> {
 public:
   using Part = Type<TypeCategory::Real, KIND>;
   using Scalar = value::Complex<typename Part::Scalar>;
 };
 
-template<>
+template <>
 class Type<TypeCategory::Character, 1>
-  : public TypeBase<TypeCategory::Character, 1> {
+    : public TypeBase<TypeCategory::Character, 1> {
 public:
   using Scalar = std::string;
 };
 
-template<>
+template <>
 class Type<TypeCategory::Character, 2>
-  : public TypeBase<TypeCategory::Character, 2> {
+    : public TypeBase<TypeCategory::Character, 2> {
 public:
   using Scalar = std::u16string;
 };
 
-template<>
+template <>
 class Type<TypeCategory::Character, 4>
-  : public TypeBase<TypeCategory::Character, 4> {
+    : public TypeBase<TypeCategory::Character, 4> {
 public:
   using Scalar = std::u32string;
 };
 
-template<int KIND>
+template <int KIND>
 class Type<TypeCategory::Logical, KIND>
-  : public TypeBase<TypeCategory::Logical, KIND> {
+    : public TypeBase<TypeCategory::Logical, KIND> {
 public:
   using Scalar = value::Logical<8 * KIND>;
 };
@@ -318,7 +320,7 @@ public:
 // Type functions
 
 // Given a specific type, find the type of the same kind in another category.
-template<TypeCategory CATEGORY, typename T>
+template <TypeCategory CATEGORY, typename T>
 using SameKind = Type<CATEGORY, std::decay_t<T>::kind>;
 
 // Many expressions, including subscripts, CHARACTER lengths, array bounds,
@@ -329,16 +331,16 @@ using IndirectSubscriptIntegerExpr =
 // For each intrinsic type category CAT, CategoryTypes<CAT> is an instantiation
 // of std::tuple<Type<CAT, K>> that comprises every kind value K in that
 // category that could possibly be supported on any target.
-template<TypeCategory CATEGORY, int KIND>
+template <TypeCategory CATEGORY, int KIND>
 using CategoryKindTuple =
     std::conditional_t<IsValidKindOfIntrinsicType(CATEGORY, KIND),
         std::tuple<Type<CATEGORY, KIND>>, std::tuple<>>;
 
-template<TypeCategory CATEGORY, int... KINDS>
+template <TypeCategory CATEGORY, int... KINDS>
 using CategoryTypesHelper =
     common::CombineTuples<CategoryKindTuple<CATEGORY, KINDS>...>;
 
-template<TypeCategory CATEGORY>
+template <TypeCategory CATEGORY>
 using CategoryTypes = CategoryTypesHelper<CATEGORY, 1, 2, 3, 4, 8, 10, 16, 32>;
 
 using IntegerTypes = CategoryTypes<TypeCategory::Integer>;
@@ -355,18 +357,18 @@ using LengthlessIntrinsicTypes =
     common::CombineTuples<NumericTypes, LogicalTypes>;
 
 // Predicates: does a type represent a specific intrinsic type?
-template<typename T>
+template <typename T>
 constexpr bool IsSpecificIntrinsicType{common::HasMember<T, AllIntrinsicTypes>};
 
 // Predicate: is a type an intrinsic type that is completely characterized
 // by its category and kind parameter value, or might it have a derived type
 // &/or a length type parameter?
-template<typename T>
+template <typename T>
 constexpr bool IsLengthlessIntrinsicType{
     common::HasMember<T, LengthlessIntrinsicTypes>};
 
 // Represents a type of any supported kind within a particular category.
-template<TypeCategory CATEGORY> struct SomeKind {
+template <TypeCategory CATEGORY> struct SomeKind {
   static constexpr TypeCategory category{CATEGORY};
   constexpr bool operator==(const SomeKind &) const { return true; }
 };
@@ -384,16 +386,16 @@ struct SomeType {};
 class StructureConstructor;
 
 // Represents any derived type, polymorphic or not, as well as CLASS(*).
-template<> class SomeKind<TypeCategory::Derived> {
+template <> class SomeKind<TypeCategory::Derived> {
 public:
   static constexpr TypeCategory category{TypeCategory::Derived};
   using Scalar = StructureConstructor;
 
-  constexpr SomeKind() {}  // CLASS(*)
+  constexpr SomeKind() {} // CLASS(*)
   constexpr explicit SomeKind(const semantics::DerivedTypeSpec &dts)
-    : derivedTypeSpec_{&dts} {}
+      : derivedTypeSpec_{&dts} {}
   constexpr explicit SomeKind(const DynamicType &dt)
-    : SomeKind(dt.GetDerivedTypeSpec()) {}
+      : SomeKind(dt.GetDerivedTypeSpec()) {}
   CONSTEXPR_CONSTRUCTORS_AND_ASSIGNMENTS(SomeKind)
 
   bool IsUnlimitedPolymorphic() const { return !derivedTypeSpec_; }
@@ -427,13 +429,13 @@ using SomeCategory = std::tuple<SomeInteger, SomeReal, SomeComplex,
 using AllTypes =
     common::CombineTuples<AllIntrinsicTypes, std::tuple<SomeDerived>>;
 
-template<typename T> using Scalar = typename std::decay_t<T>::Scalar;
+template <typename T> using Scalar = typename std::decay_t<T>::Scalar;
 
 // When Scalar<T> is S, then TypeOf<S> is T.
 // TypeOf is implemented by scanning all supported types for a match
 // with Type<T>::Scalar.
-template<typename CONST> struct TypeOfHelper {
-  template<typename T> struct Predicate {
+template <typename CONST> struct TypeOfHelper {
+  template <typename T> struct Predicate {
     static constexpr bool value() {
       return std::is_same_v<std::decay_t<CONST>,
           std::decay_t<typename T::Scalar>>;
@@ -445,7 +447,7 @@ template<typename CONST> struct TypeOfHelper {
       std::tuple_element_t<index, AllIntrinsicTypes>, void>;
 };
 
-template<typename CONST> using TypeOf = typename TypeOfHelper<CONST>::type;
+template <typename CONST> using TypeOf = typename TypeOfHelper<CONST>::type;
 
 int SelectedCharKind(const std::string &, int defaultKind);
 int SelectedIntKind(std::int64_t precision = 0);
@@ -511,5 +513,5 @@ bool IsKindTypeParameter(const semantics::Symbol &);
 #define FOR_EACH_TYPE_AND_KIND(PREFIX, SUFFIX) \
   FOR_EACH_INTRINSIC_KIND(PREFIX, SUFFIX) \
   FOR_EACH_CATEGORY_TYPE(PREFIX, SUFFIX)
-}
-#endif  // FORTRAN_EVALUATE_TYPE_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_TYPE_H_
diff --git a/flang/include/flang/Evaluate/variable.h b/flang/include/flang/Evaluate/variable.h
index 0004b0a9c636..d9345fbb9111 100644
--- a/flang/include/flang/Evaluate/variable.h
+++ b/flang/include/flang/Evaluate/variable.h
@@ -44,7 +44,7 @@ using SymbolVector = std::vector<SymbolRef>;
 
 // Forward declarations
 struct DataRef;
-template<typename T> struct Variable;
+template <typename T> struct Variable;
 
 // Reference a base object in memory.  This can be a Fortran symbol,
 // static data (e.g., CHARACTER literal), or compiler-created temporary.
@@ -76,7 +76,7 @@ public:
   Component(const DataRef &b, const Symbol &c) : base_{b}, symbol_{c} {}
   Component(DataRef &&b, const Symbol &c) : base_{std::move(b)}, symbol_{c} {}
   Component(common::CopyableIndirection<DataRef> &&b, const Symbol &c)
-    : base_{std::move(b)}, symbol_{c} {}
+      : base_{std::move(b)}, symbol_{c} {}
 
   const DataRef &base() const { return base_.value(); }
   DataRef &base() { return base_.value(); }
@@ -107,7 +107,7 @@ public:
   const Symbol &GetLastSymbol() const;
   const Component &GetComponent() const { return std::get<Component>(u_); }
   Component &GetComponent() { return std::get<Component>(u_); }
-  const Component *UnwrapComponent() const;  // null if just a Symbol
+  const Component *UnwrapComponent() const; // null if just a Symbol
   Component *UnwrapComponent();
 
   int Rank() const;
@@ -128,20 +128,20 @@ private:
 // KIND(x), which is then folded to a constant value.
 // "Bare" type parameter references within a derived type definition do
 // not have base objects.
-template<int KIND> class TypeParamInquiry {
+template <int KIND> class TypeParamInquiry {
 public:
   using Result = Type<TypeCategory::Integer, KIND>;
   CLASS_BOILERPLATE(TypeParamInquiry)
   TypeParamInquiry(NamedEntity &&x, const Symbol &param)
-    : base_{std::move(x)}, parameter_{param} {}
+      : base_{std::move(x)}, parameter_{param} {}
   TypeParamInquiry(std::optional<NamedEntity> &&x, const Symbol &param)
-    : base_{std::move(x)}, parameter_{param} {}
+      : base_{std::move(x)}, parameter_{param} {}
 
   const std::optional<NamedEntity> &base() const { return base_; }
   std::optional<NamedEntity> &base() { return base_; }
   const Symbol &parameter() const { return parameter_; }
 
-  static constexpr int Rank() { return 0; }  // always scalar
+  static constexpr int Rank() { return 0; } // always scalar
   bool operator==(const TypeParamInquiry &) const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
@@ -166,7 +166,7 @@ public:
   Triplet &set_lower(Expr<SubscriptInteger> &&);
   std::optional<Expr<SubscriptInteger>> upper() const;
   Triplet &set_upper(Expr<SubscriptInteger> &&);
-  Expr<SubscriptInteger> stride() const;  // N.B. result is not optional<>
+  Expr<SubscriptInteger> stride() const; // N.B. result is not optional<>
   Triplet &set_stride(Expr<SubscriptInteger> &&);
 
   bool operator==(const Triplet &) const;
@@ -182,7 +182,7 @@ private:
 struct Subscript {
   EVALUATE_UNION_CLASS_BOILERPLATE(Subscript)
   explicit Subscript(Expr<SubscriptInteger> &&s)
-    : u{IndirectSubscriptIntegerExpr::Make(std::move(s))} {}
+      : u{IndirectSubscriptIntegerExpr::Make(std::move(s))} {}
   int Rank() const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   std::variant<IndirectSubscriptIntegerExpr, Triplet> u;
@@ -197,11 +197,11 @@ class ArrayRef {
 public:
   CLASS_BOILERPLATE(ArrayRef)
   ArrayRef(const Symbol &symbol, std::vector<Subscript> &&ss)
-    : base_{symbol}, subscript_(std::move(ss)) {}
+      : base_{symbol}, subscript_(std::move(ss)) {}
   ArrayRef(Component &&c, std::vector<Subscript> &&ss)
-    : base_{std::move(c)}, subscript_(std::move(ss)) {}
+      : base_{std::move(c)}, subscript_(std::move(ss)) {}
   ArrayRef(NamedEntity &&base, std::vector<Subscript> &&ss)
-    : base_{std::move(base)}, subscript_(std::move(ss)) {}
+      : base_{std::move(base)}, subscript_(std::move(ss)) {}
 
   NamedEntity &base() { return base_; }
   const NamedEntity &base() const { return base_; }
@@ -211,7 +211,7 @@ public:
   int size() const { return static_cast<int>(subscript_.size()); }
   Subscript &at(int n) { return subscript_.at(n); }
   const Subscript &at(int n) const { return subscript_.at(n); }
-  template<typename A> common::IfNoLvalue<Subscript &, A> emplace_back(A &&x) {
+  template <typename A> common::IfNoLvalue<Subscript &, A> emplace_back(A &&x) {
     return subscript_.emplace_back(std::move(x));
   }
 
@@ -275,7 +275,7 @@ private:
   std::vector<Subscript> subscript_;
   std::vector<Expr<SubscriptInteger>> cosubscript_;
   std::optional<common::CopyableIndirection<Expr<SomeInteger>>> stat_, team_;
-  bool teamIsTeamNumber_{false};  // false: TEAM=, true: TEAM_NUMBER=
+  bool teamIsTeamNumber_{false}; // false: TEAM=, true: TEAM_NUMBER=
 };
 
 // R911 data-ref is defined syntactically as a series of part-refs, which
@@ -305,13 +305,13 @@ public:
   CLASS_BOILERPLATE(Substring)
   Substring(DataRef &&parent, std::optional<Expr<SubscriptInteger>> &&lower,
       std::optional<Expr<SubscriptInteger>> &&upper)
-    : parent_{std::move(parent)} {
+      : parent_{std::move(parent)} {
     SetBounds(lower, upper);
   }
   Substring(StaticDataObject::Pointer &&parent,
       std::optional<Expr<SubscriptInteger>> &&lower,
       std::optional<Expr<SubscriptInteger>> &&upper)
-    : parent_{std::move(parent)} {
+      : parent_{std::move(parent)} {
     SetBounds(lower, upper);
   }
 
@@ -323,7 +323,7 @@ public:
   Parent &parent() { return parent_; }
 
   int Rank() const;
-  template<typename A> const A *GetParentIf() const {
+  template <typename A> const A *GetParentIf() const {
     return std::get_if<A>(&parent_);
   }
   BaseObject GetBaseObject() const;
@@ -366,7 +366,7 @@ private:
 // calls to pointer-valued functions.  Its variant holds everything that
 // a DataRef can, and possibly also a substring reference or a
 // complex component (%RE/%IM) reference.
-template<typename T> class Designator {
+template <typename T> class Designator {
   using DataRefs = std::decay_t<decltype(DataRef::u)>;
   using MaybeSubstring =
       std::conditional_t<T::category == TypeCategory::Character,
@@ -383,7 +383,7 @@ public:
   EVALUATE_UNION_CLASS_BOILERPLATE(Designator)
   Designator(const DataRef &that) : u{common::CopyVariant<Variant>(that.u)} {}
   Designator(DataRef &&that)
-    : u{common::MoveVariant<Variant>(std::move(that.u))} {}
+      : u{common::MoveVariant<Variant>(std::move(that.u))} {}
 
   std::optional<DynamicType> GetType() const;
   int Rank() const;
@@ -397,7 +397,7 @@ public:
 
 FOR_EACH_CHARACTER_KIND(extern template class Designator, )
 
-template<typename T> struct Variable {
+template <typename T> struct Variable {
   using Result = T;
   static_assert(IsSpecificIntrinsicType<Result> ||
       std::is_same_v<Result, SomeKind<TypeCategory::Derived>>);
@@ -429,19 +429,19 @@ public:
   Field field() const { return field_; }
   int dimension() const { return dimension_; }
 
-  static constexpr int Rank() { return 0; }  // always scalar
+  static constexpr int Rank() { return 0; } // always scalar
   bool operator==(const DescriptorInquiry &) const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   NamedEntity base_;
   Field field_;
-  int dimension_{0};  // zero-based
+  int dimension_{0}; // zero-based
 };
 
 #define INSTANTIATE_VARIABLE_TEMPLATES \
   EXPAND_FOR_EACH_INTEGER_KIND( \
       TEMPLATE_INSTANTIATION, template class TypeParamInquiry, ) \
   FOR_EACH_SPECIFIC_TYPE(template class Designator, )
-}
-#endif  // FORTRAN_EVALUATE_VARIABLE_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_VARIABLE_H_
diff --git a/flang/include/flang/ISO_Fortran_binding.h b/flang/include/flang/ISO_Fortran_binding.h
index b54f778fdec8..dca063fe5cf5 100644
--- a/flang/include/flang/ISO_Fortran_binding.h
+++ b/flang/include/flang/ISO_Fortran_binding.h
@@ -80,7 +80,7 @@ typedef signed char CFI_type_t;
 #define CFI_type_char 32
 #define CFI_type_cptr 33
 #define CFI_type_struct 34
-#define CFI_type_other (-1)  // must be negative
+#define CFI_type_other (-1) // must be negative
 
 /* Error code macros */
 #define CFI_SUCCESS 0 /* must be zero */
@@ -108,13 +108,13 @@ namespace cfi_internal {
 // The below structure emulates a flexible array. This structure does not take
 // care of getting the memory storage. Note that it already contains one element
 // because a struct cannot be empty.
-template<typename T> struct FlexibleArray : T {
+template <typename T> struct FlexibleArray : T {
   T &operator[](int index) { return *(this + index); }
   const T &operator[](int index) const { return *(this + index); }
   operator T *() { return this; }
   operator const T *() const { return this; }
 };
-}
+} // namespace cfi_internal
 #endif
 
 /* 18.5.3 generic data descriptor */
@@ -139,13 +139,13 @@ typedef struct CFI_cdesc_t {
 // The struct below take care of getting the memory storage for C++ CFI_cdesc_t
 // that contain an emulated flexible array.
 namespace cfi_internal {
-template<int r> struct CdescStorage : public CFI_cdesc_t {
+template <int r> struct CdescStorage : public CFI_cdesc_t {
   static_assert((r > 1 && r <= CFI_MAX_RANK), "CFI_INVALID_RANK");
   CFI_dim_t dim[r - 1];
 };
-template<> struct CdescStorage<1> : public CFI_cdesc_t {};
-template<> struct CdescStorage<0> : public CFI_cdesc_t {};
-}
+template <> struct CdescStorage<1> : public CFI_cdesc_t {};
+template <> struct CdescStorage<0> : public CFI_cdesc_t {};
+} // namespace cfi_internal
 #define CFI_CDESC_T(rank) cfi_internal::CdescStorage<rank>
 #else
 #define CFI_CDESC_T(rank) \
@@ -174,8 +174,8 @@ int CFI_select_part(CFI_cdesc_t *, const CFI_cdesc_t *source,
 int CFI_setpointer(
     CFI_cdesc_t *, const CFI_cdesc_t *source, const CFI_index_t lower_bounds[]);
 #ifdef __cplusplus
-}  // extern "C"
-}  // inline namespace Fortran_2018
+} // extern "C"
+} // inline namespace Fortran_2018
 }
 }
 #endif
diff --git a/flang/include/flang/Parser/char-block.h b/flang/include/flang/Parser/char-block.h
index fd41e14821ce..7c29c9aa41a0 100644
--- a/flang/include/flang/Parser/char-block.h
+++ b/flang/include/flang/Parser/char-block.h
@@ -30,7 +30,7 @@ public:
   constexpr CharBlock() {}
   constexpr CharBlock(const char *x, std::size_t n = 1) : interval_{x, n} {}
   constexpr CharBlock(const char *b, const char *ep1)
-    : interval_{b, static_cast<std::size_t>(ep1 - b)} {}
+      : interval_{b, static_cast<std::size_t>(ep1 - b)} {}
   CharBlock(const std::string &s) : interval_{s.data(), s.size()} {}
   constexpr CharBlock(const CharBlock &) = default;
   constexpr CharBlock(CharBlock &&) = default;
@@ -61,7 +61,7 @@ public:
         return ch;
       }
     }
-    return ' ';  // non no-blank character
+    return ' '; // non no-blank character
   }
 
   bool IsBlank() const { return FirstNonBlank() == ' '; }
@@ -140,10 +140,10 @@ inline bool operator>(const char *left, const CharBlock &right) {
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharBlock &x);
 
-}
+} // namespace Fortran::parser
 
 // Specializations to enable std::unordered_map<CharBlock, ...> &c.
-template<> struct std::hash<Fortran::parser::CharBlock> {
+template <> struct std::hash<Fortran::parser::CharBlock> {
   std::size_t operator()(const Fortran::parser::CharBlock &x) const {
     std::size_t hash{0}, bytes{x.size()};
     for (std::size_t j{0}; j < bytes; ++j) {
@@ -152,4 +152,4 @@ template<> struct std::hash<Fortran::parser::CharBlock> {
     return hash;
   }
 };
-#endif  // FORTRAN_PARSER_CHAR_BLOCK_H_
+#endif // FORTRAN_PARSER_CHAR_BLOCK_H_
diff --git a/flang/include/flang/Parser/char-buffer.h b/flang/include/flang/Parser/char-buffer.h
index 0df690af3aa7..e61a3fe3427e 100644
--- a/flang/include/flang/Parser/char-buffer.h
+++ b/flang/include/flang/Parser/char-buffer.h
@@ -24,8 +24,8 @@ class CharBuffer {
 public:
   CharBuffer() {}
   CharBuffer(CharBuffer &&that)
-    : blocks_(std::move(that.blocks_)), last_{that.last_}, bytes_{that.bytes_},
-      lastBlockEmpty_{that.lastBlockEmpty_} {
+      : blocks_(std::move(that.blocks_)), last_{that.last_},
+        bytes_{that.bytes_}, lastBlockEmpty_{that.lastBlockEmpty_} {
     that.clear();
   }
   CharBuffer &operator=(CharBuffer &&that) {
@@ -73,5 +73,5 @@ private:
   std::size_t bytes_{0};
   bool lastBlockEmpty_{false};
 };
-}
-#endif  // FORTRAN_PARSER_CHAR_BUFFER_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_CHAR_BUFFER_H_
diff --git a/flang/include/flang/Parser/char-set.h b/flang/include/flang/Parser/char-set.h
index 64ff6692b1d1..8fa7be5f2c07 100644
--- a/flang/include/flang/Parser/char-set.h
+++ b/flang/include/flang/Parser/char-set.h
@@ -75,5 +75,5 @@ private:
   constexpr SetOfChars(std::uint64_t b) : bits_{b} {}
   std::uint64_t bits_{0};
 };
-}
-#endif  // FORTRAN_PARSER_CHAR_SET_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_CHAR_SET_H_
diff --git a/flang/include/flang/Parser/characters.h b/flang/include/flang/Parser/characters.h
index 02b92ba6f047..c18140780956 100644
--- a/flang/include/flang/Parser/characters.h
+++ b/flang/include/flang/Parser/characters.h
@@ -103,33 +103,51 @@ inline constexpr char HexadecimalDigitValue(char ch) {
 
 inline constexpr std::optional<char> BackslashEscapeValue(char ch) {
   switch (ch) {
-  case 'a': return std::nullopt;  // '\a';  PGF90 doesn't know \a
-  case 'b': return '\b';
-  case 'f': return '\f';
-  case 'n': return '\n';
-  case 'r': return '\r';
-  case 't': return '\t';
-  case 'v': return '\v';
+  case 'a':
+    return std::nullopt; // '\a';  PGF90 doesn't know \a
+  case 'b':
+    return '\b';
+  case 'f':
+    return '\f';
+  case 'n':
+    return '\n';
+  case 'r':
+    return '\r';
+  case 't':
+    return '\t';
+  case 'v':
+    return '\v';
   case '"':
   case '\'':
-  case '\\': return ch;
-  default: return std::nullopt;
+  case '\\':
+    return ch;
+  default:
+    return std::nullopt;
   }
 }
 
 inline constexpr std::optional<char> BackslashEscapeChar(char ch) {
   switch (ch) {
-  case '\a': return std::nullopt;  // 'a';  PGF90 doesn't know \a
-  case '\b': return 'b';
-  case '\f': return 'f';
-  case '\n': return 'n';
-  case '\r': return 'r';
-  case '\t': return 't';
-  case '\v': return 'v';
+  case '\a':
+    return std::nullopt; // 'a';  PGF90 doesn't know \a
+  case '\b':
+    return 'b';
+  case '\f':
+    return 'f';
+  case '\n':
+    return 'n';
+  case '\r':
+    return 'r';
+  case '\t':
+    return 't';
+  case '\v':
+    return 'v';
   case '"':
   case '\'':
-  case '\\': return ch;
-  default: return std::nullopt;
+  case '\\':
+    return ch;
+  default:
+    return std::nullopt;
   }
 }
 
@@ -139,13 +157,13 @@ struct EncodedCharacter {
   int bytes{0};
 };
 
-template<Encoding ENCODING> EncodedCharacter EncodeCharacter(char32_t ucs);
-template<> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t);
-template<> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t);
+template <Encoding ENCODING> EncodedCharacter EncodeCharacter(char32_t ucs);
+template <> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t);
+template <> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t);
 
 EncodedCharacter EncodeCharacter(Encoding, char32_t ucs);
 
-template<Encoding ENCODING, typename STRING>
+template <Encoding ENCODING, typename STRING>
 std::string EncodeString(const STRING &);
 extern template std::string EncodeString<Encoding::LATIN_1, std::string>(
     const std::string &);
@@ -154,7 +172,7 @@ extern template std::string EncodeString<Encoding::UTF_8, std::u32string>(
 
 // EmitQuotedChar drives callbacks "emit" and "insert" to output the
 // bytes of an encoding for a codepoint.
-template<typename NORMAL, typename INSERTED>
+template <typename NORMAL, typename INSERTED>
 void EmitQuotedChar(char32_t ch, const NORMAL &emit, const INSERTED &insert,
     bool backslashEscapes = true, Encoding encoding = Encoding::UTF_8) {
   auto emitOneByte{[&](std::uint8_t ch) {
@@ -175,7 +193,7 @@ void EmitQuotedChar(char32_t ch, const NORMAL &emit, const INSERTED &insert,
         insert('0' + ((ch >> 3) & 7));
         insert('0' + (ch & 7));
       }
-    } else if (ch == '\n') {  // always escape newlines
+    } else if (ch == '\n') { // always escape newlines
       insert('\\');
       insert('n');
     } else {
@@ -203,20 +221,20 @@ int UTF_8CharacterBytes(const char *);
 
 struct DecodedCharacter {
   char32_t codepoint{0};
-  int bytes{0};  // signifying failure
+  int bytes{0}; // signifying failure
 };
 
-template<Encoding ENCODING>
+template <Encoding ENCODING>
 DecodedCharacter DecodeRawCharacter(const char *, std::size_t);
-template<>
+template <>
 DecodedCharacter DecodeRawCharacter<Encoding::LATIN_1>(
     const char *, std::size_t);
 
-template<>
+template <>
 DecodedCharacter DecodeRawCharacter<Encoding::UTF_8>(const char *, std::size_t);
 
 // DecodeCharacter optionally handles backslash escape sequences, too.
-template<Encoding ENCODING>
+template <Encoding ENCODING>
 DecodedCharacter DecodeCharacter(
     const char *, std::size_t, bool backslashEscapes);
 extern template DecodedCharacter DecodeCharacter<Encoding::LATIN_1>(
@@ -227,7 +245,7 @@ extern template DecodedCharacter DecodeCharacter<Encoding::UTF_8>(
 DecodedCharacter DecodeCharacter(
     Encoding, const char *, std::size_t, bool backslashEscapes);
 
-template<typename RESULT, Encoding ENCODING>
+template <typename RESULT, Encoding ENCODING>
 RESULT DecodeString(const std::string &, bool backslashEscapes);
 extern template std::string DecodeString<std::string, Encoding::LATIN_1>(
     const std::string &, bool);
@@ -235,5 +253,5 @@ extern template std::u16string DecodeString<std::u16string, Encoding::UTF_8>(
     const std::string &, bool);
 extern template std::u32string DecodeString<std::u32string, Encoding::UTF_8>(
     const std::string &, bool);
-}
-#endif  // FORTRAN_PARSER_CHARACTERS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_CHARACTERS_H_
diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h
index ab678e76af76..774af899de6d 100644
--- a/flang/include/flang/Parser/dump-parse-tree.h
+++ b/flang/include/flang/Parser/dump-parse-tree.h
@@ -23,9 +23,9 @@ namespace Fortran::parser {
 
 // When SHOW_ALL_SOURCE_MEMBERS is defined, HasSource<T>::value is true if T has
 // a member named source
-template<typename T, typename = int> struct HasSource : std::false_type {};
+template <typename T, typename = int> struct HasSource : std::false_type {};
 #ifdef SHOW_ALL_SOURCE_MEMBERS
-template<typename T>
+template <typename T>
 struct HasSource<T, decltype((void)T::source, 0)> : std::true_type {};
 #endif
 
@@ -35,9 +35,9 @@ struct HasSource<T, decltype((void)T::source, 0)> : std::true_type {};
 
 class ParseTreeDumper {
 public:
-  explicit ParseTreeDumper(
-      llvm::raw_ostream &out, const AnalyzedObjectsAsFortran *asFortran = nullptr)
-    : out_(out), asFortran_{asFortran} {}
+  explicit ParseTreeDumper(llvm::raw_ostream &out,
+      const AnalyzedObjectsAsFortran *asFortran = nullptr)
+      : out_(out), asFortran_{asFortran} {}
 
   static constexpr const char *GetNodeName(const char *) { return "char *"; }
 #define NODE_NAME(T, N) \
@@ -682,7 +682,7 @@ public:
 #undef NODE
 #undef NODE_NAME
 
-  template<typename T> bool Pre(const T &x) {
+  template <typename T> bool Pre(const T &x) {
     std::string fortran{AsFortran<T>(x)};
     if (fortran.empty() && (UnionTrait<T> || WrapperTrait<T>)) {
       Prefix(GetNodeName(x));
@@ -698,7 +698,7 @@ public:
     return true;
   }
 
-  template<typename T> void Post(const T &x) {
+  template <typename T> void Post(const T &x) {
     if (AsFortran<T>(x).empty() && (UnionTrait<T> || WrapperTrait<T>)) {
       EndLineIfNonempty();
     } else {
@@ -711,55 +711,57 @@ public:
   bool Pre(const CharBlock &) { return true; }
   void Post(const CharBlock &) {}
 
-  template<typename T> bool Pre(const Statement<T> &) { return true; }
-  template<typename T> void Post(const Statement<T> &) {}
-  template<typename T> bool Pre(const UnlabeledStatement<T> &) { return true; }
-  template<typename T> void Post(const UnlabeledStatement<T> &) {}
+  template <typename T> bool Pre(const Statement<T> &) { return true; }
+  template <typename T> void Post(const Statement<T> &) {}
+  template <typename T> bool Pre(const UnlabeledStatement<T> &) { return true; }
+  template <typename T> void Post(const UnlabeledStatement<T> &) {}
 
-  template<typename T> bool Pre(const common::Indirection<T> &) { return true; }
-  template<typename T> void Post(const common::Indirection<T> &) {}
+  template <typename T> bool Pre(const common::Indirection<T> &) {
+    return true;
+  }
+  template <typename T> void Post(const common::Indirection<T> &) {}
 
-  template<typename A> bool Pre(const Scalar<A> &) {
+  template <typename A> bool Pre(const Scalar<A> &) {
     Prefix("Scalar");
     return true;
   }
-  template<typename A> void Post(const Scalar<A> &) { EndLineIfNonempty(); }
+  template <typename A> void Post(const Scalar<A> &) { EndLineIfNonempty(); }
 
-  template<typename A> bool Pre(const Constant<A> &) {
+  template <typename A> bool Pre(const Constant<A> &) {
     Prefix("Constant");
     return true;
   }
-  template<typename A> void Post(const Constant<A> &) { EndLineIfNonempty(); }
+  template <typename A> void Post(const Constant<A> &) { EndLineIfNonempty(); }
 
-  template<typename A> bool Pre(const Integer<A> &) {
+  template <typename A> bool Pre(const Integer<A> &) {
     Prefix("Integer");
     return true;
   }
-  template<typename A> void Post(const Integer<A> &) { EndLineIfNonempty(); }
+  template <typename A> void Post(const Integer<A> &) { EndLineIfNonempty(); }
 
-  template<typename A> bool Pre(const Logical<A> &) {
+  template <typename A> bool Pre(const Logical<A> &) {
     Prefix("Logical");
     return true;
   }
-  template<typename A> void Post(const Logical<A> &) { EndLineIfNonempty(); }
+  template <typename A> void Post(const Logical<A> &) { EndLineIfNonempty(); }
 
-  template<typename A> bool Pre(const DefaultChar<A> &) {
+  template <typename A> bool Pre(const DefaultChar<A> &) {
     Prefix("DefaultChar");
     return true;
   }
-  template<typename A> void Post(const DefaultChar<A> &) {
+  template <typename A> void Post(const DefaultChar<A> &) {
     EndLineIfNonempty();
   }
 
-  template<typename... A> bool Pre(const std::tuple<A...> &) { return true; }
-  template<typename... A> void Post(const std::tuple<A...> &) {}
+  template <typename... A> bool Pre(const std::tuple<A...> &) { return true; }
+  template <typename... A> void Post(const std::tuple<A...> &) {}
 
-  template<typename... A> bool Pre(const std::variant<A...> &) { return true; }
-  template<typename... A> void Post(const std::variant<A...> &) {}
+  template <typename... A> bool Pre(const std::variant<A...> &) { return true; }
+  template <typename... A> void Post(const std::variant<A...> &) {}
 
 protected:
   // Return a Fortran representation of this node to include in the dump
-  template<typename T> std::string AsFortran(const T &x) {
+  template <typename T> std::string AsFortran(const T &x) {
     std::string buf;
     llvm::raw_string_ostream ss{buf};
     if constexpr (std::is_same_v<T, Expr>) {
@@ -835,12 +837,12 @@ private:
   bool emptyline_{false};
 };
 
-template<typename T>
+template <typename T>
 void DumpTree(llvm::raw_ostream &out, const T &x,
     const AnalyzedObjectsAsFortran *asFortran = nullptr) {
   ParseTreeDumper dumper{out, asFortran};
   Walk(x, dumper);
 }
 
-}
-#endif  // FORTRAN_PARSER_DUMP_PARSE_TREE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_DUMP_PARSE_TREE_H_
diff --git a/flang/include/flang/Parser/format-specification.h b/flang/include/flang/Parser/format-specification.h
index 872d025b5e61..a34e68af2832 100644
--- a/flang/include/flang/Parser/format-specification.h
+++ b/flang/include/flang/Parser/format-specification.h
@@ -41,12 +41,12 @@ struct IntrinsicTypeDataEditDesc {
   IntrinsicTypeDataEditDesc &operator=(IntrinsicTypeDataEditDesc &&) = default;
   IntrinsicTypeDataEditDesc(Kind &&k, std::optional<int> &&w,
       std::optional<int> &&d, std::optional<int> &&e)
-    : kind{k}, width{std::move(w)}, digits{std::move(d)}, exponentWidth{
-                                                              std::move(e)} {}
+      : kind{k}, width{std::move(w)}, digits{std::move(d)}, exponentWidth{
+                                                                std::move(e)} {}
   Kind kind;
-  std::optional<int> width;  // w
-  std::optional<int> digits;  // m or d
-  std::optional<int> exponentWidth;  // e
+  std::optional<int> width; // w
+  std::optional<int> digits; // m or d
+  std::optional<int> exponentWidth; // e
 };
 
 // R1307 data-edit-desc (part 2 of 2) ->
@@ -57,7 +57,7 @@ struct DerivedTypeDataEditDesc {
   DerivedTypeDataEditDesc(DerivedTypeDataEditDesc &&) = default;
   DerivedTypeDataEditDesc &operator=(DerivedTypeDataEditDesc &&) = default;
   DerivedTypeDataEditDesc(std::string &&t, std::list<std::int64_t> &&p)
-    : type{std::move(t)}, parameters{std::move(p)} {}
+      : type{std::move(t)}, parameters{std::move(p)} {}
   std::string type;
   std::list<std::int64_t> parameters;
 };
@@ -94,8 +94,8 @@ struct ControlEditDesc {
     RP,
     DC,
     DP,
-    Dollar,  // extension: inhibit newline on output
-    Backslash,  // ditto, but only on terminals
+    Dollar, // extension: inhibit newline on output
+    Backslash, // ditto, but only on terminals
   };
   ControlEditDesc() = delete;
   ControlEditDesc(ControlEditDesc &&) = default;
@@ -104,7 +104,7 @@ struct ControlEditDesc {
   ControlEditDesc(Kind k, std::int64_t ct) : kind{k}, count{ct} {}
   ControlEditDesc(std::int64_t ct, Kind k) : kind{k}, count{ct} {}
   Kind kind;
-  std::int64_t count{1};  // r, k, or n
+  std::int64_t count{1}; // r, k, or n
 };
 
 // R1304 format-item ->
@@ -116,10 +116,10 @@ struct FormatItem {
   FormatItem() = delete;
   FormatItem(FormatItem &&) = default;
   FormatItem &operator=(FormatItem &&) = default;
-  template<typename A, typename = common::NoLvalue<A>>
+  template <typename A, typename = common::NoLvalue<A>>
   FormatItem(std::optional<std::uint64_t> &&r, A &&x)
-    : repeatCount{std::move(r)}, u{std::move(x)} {}
-  template<typename A, typename = common::NoLvalue<A>>
+      : repeatCount{std::move(r)}, u{std::move(x)} {}
+  template <typename A, typename = common::NoLvalue<A>>
   explicit FormatItem(A &&x) : u{std::move(x)} {}
   std::optional<std::uint64_t> repeatCount;
   std::variant<IntrinsicTypeDataEditDesc, DerivedTypeDataEditDesc,
@@ -136,10 +136,10 @@ struct FormatSpecification {
   FormatSpecification(FormatSpecification &&) = default;
   FormatSpecification &operator=(FormatSpecification &&) = default;
   explicit FormatSpecification(std::list<FormatItem> &&is)
-    : items(std::move(is)) {}
+      : items(std::move(is)) {}
   FormatSpecification(std::list<FormatItem> &&is, std::list<FormatItem> &&us)
-    : items(std::move(is)), unlimitedItems(std::move(us)) {}
+      : items(std::move(is)), unlimitedItems(std::move(us)) {}
   std::list<FormatItem> items, unlimitedItems;
 };
-}
-#endif  // FORTRAN_PARSER_FORMAT_SPECIFICATION_H_
+} // namespace Fortran::format
+#endif // FORTRAN_PARSER_FORMAT_SPECIFICATION_H_
diff --git a/flang/include/flang/Parser/instrumented-parser.h b/flang/include/flang/Parser/instrumented-parser.h
index 007edbf56d4e..51dbd5f03c17 100644
--- a/flang/include/flang/Parser/instrumented-parser.h
+++ b/flang/include/flang/Parser/instrumented-parser.h
@@ -47,12 +47,12 @@ private:
   std::map<std::size_t, LogForPosition> perPos_;
 };
 
-template<typename PA> class InstrumentedParser {
+template <typename PA> class InstrumentedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr InstrumentedParser(const InstrumentedParser &) = default;
   constexpr InstrumentedParser(const MessageFixedText &tag, const PA &parser)
-    : tag_{tag}, parser_{parser} {}
+      : tag_{tag}, parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
     if (UserState * ustate{state.userState()}) {
       if (ParsingLog * log{ustate->log()}) {
@@ -75,10 +75,10 @@ private:
   const PA parser_;
 };
 
-template<typename PA>
+template <typename PA>
 inline constexpr auto instrumented(
     const MessageFixedText &tag, const PA &parser) {
   return InstrumentedParser{tag, parser};
 }
-}
-#endif  // FORTRAN_PARSER_INSTRUMENTED_PARSER_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_INSTRUMENTED_PARSER_H_
diff --git a/flang/include/flang/Parser/message.h b/flang/include/flang/Parser/message.h
index e38145a7b04b..bc2eed0dedc7 100644
--- a/flang/include/flang/Parser/message.h
+++ b/flang/include/flang/Parser/message.h
@@ -34,7 +34,7 @@ class MessageFixedText {
 public:
   constexpr MessageFixedText(
       const char str[], std::size_t n, bool isFatal = false)
-    : text_{str, n}, isFatal_{isFatal} {}
+      : text_{str, n}, isFatal_{isFatal} {}
   constexpr MessageFixedText(const MessageFixedText &) = default;
   constexpr MessageFixedText(MessageFixedText &&) = default;
   constexpr MessageFixedText &operator=(const MessageFixedText &) = default;
@@ -57,7 +57,7 @@ constexpr MessageFixedText operator""_err_en_US(
     const char str[], std::size_t n) {
   return MessageFixedText{str, n, true /* fatal */};
 }
-}
+} // namespace literals
 
 // The construction of a MessageFormattedText uses a MessageFixedText
 // as a vsnprintf() formatting string that is applied to the
@@ -66,9 +66,9 @@ constexpr MessageFixedText operator""_err_en_US(
 // char pointers that are suitable for '%s' formatting.
 class MessageFormattedText {
 public:
-  template<typename... A>
+  template <typename... A>
   MessageFormattedText(const MessageFixedText &text, A &&... x)
-    : isFatal_{text.isFatal()} {
+      : isFatal_{text.isFatal()} {
     Format(&text, Convert(std::forward<A>(x))...);
   }
   MessageFormattedText(const MessageFormattedText &) = default;
@@ -82,15 +82,15 @@ public:
 private:
   void Format(const MessageFixedText *, ...);
 
-  template<typename A> A Convert(const A &x) {
+  template <typename A> A Convert(const A &x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return x;
   }
-  template<typename A> A Convert(A &x) {
+  template <typename A> A Convert(A &x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return x;
   }
-  template<typename A> common::IfNoLvalue<A, A> Convert(A &&x) {
+  template <typename A> common::IfNoLvalue<A, A> Convert(A &&x) {
     static_assert(!std::is_class_v<std::decay_t<A>>);
     return std::move(x);
   }
@@ -103,7 +103,7 @@ private:
 
   bool isFatal_{false};
   std::string string_;
-  std::forward_list<std::string> conversions_;  // preserves created strings
+  std::forward_list<std::string> conversions_; // preserves created strings
 };
 
 // Represents a formatted rendition of "expected '%s'"_err_en_US
@@ -146,27 +146,27 @@ public:
   Message &operator=(Message &&) = default;
 
   Message(ProvenanceRange pr, const MessageFixedText &t)
-    : location_{pr}, text_{t} {}
+      : location_{pr}, text_{t} {}
   Message(ProvenanceRange pr, const MessageFormattedText &s)
-    : location_{pr}, text_{s} {}
+      : location_{pr}, text_{s} {}
   Message(ProvenanceRange pr, MessageFormattedText &&s)
-    : location_{pr}, text_{std::move(s)} {}
+      : location_{pr}, text_{std::move(s)} {}
   Message(ProvenanceRange pr, const MessageExpectedText &t)
-    : location_{pr}, text_{t} {}
+      : location_{pr}, text_{t} {}
 
   Message(CharBlock csr, const MessageFixedText &t)
-    : location_{csr}, text_{t} {}
+      : location_{csr}, text_{t} {}
   Message(CharBlock csr, const MessageFormattedText &s)
-    : location_{csr}, text_{s} {}
+      : location_{csr}, text_{s} {}
   Message(CharBlock csr, MessageFormattedText &&s)
-    : location_{csr}, text_{std::move(s)} {}
+      : location_{csr}, text_{std::move(s)} {}
   Message(CharBlock csr, const MessageExpectedText &t)
-    : location_{csr}, text_{t} {}
+      : location_{csr}, text_{t} {}
 
-  template<typename RANGE, typename A, typename... As>
+  template <typename RANGE, typename A, typename... As>
   Message(RANGE r, const MessageFixedText &t, A &&x, As &&... xs)
-    : location_{r}, text_{MessageFormattedText{
-                        t, std::forward<A>(x), std::forward<As>(xs)...}} {}
+      : location_{r}, text_{MessageFormattedText{
+                          t, std::forward<A>(x), std::forward<As>(xs)...}} {}
 
   bool attachmentIsContext() const { return attachmentIsContext_; }
   Reference attachment() const { return attachment_; }
@@ -177,16 +177,16 @@ public:
   }
   Message &Attach(Message *);
   Message &Attach(std::unique_ptr<Message> &&);
-  template<typename... A> Message &Attach(A &&... args) {
-    return Attach(new Message{std::forward<A>(args)...});  // reference-counted
+  template <typename... A> Message &Attach(A &&... args) {
+    return Attach(new Message{std::forward<A>(args)...}); // reference-counted
   }
 
   bool SortBefore(const Message &that) const;
   bool IsFatal() const;
   std::string ToString() const;
   std::optional<ProvenanceRange> GetProvenanceRange(const CookedSource &) const;
-  void Emit(
-      llvm::raw_ostream &, const CookedSource &, bool echoSourceLine = true) const;
+  void Emit(llvm::raw_ostream &, const CookedSource &,
+      bool echoSourceLine = true) const;
 
   // If this Message or any of its attachments locates itself via a CharBlock
   // within a particular CookedSource, replace its location with the
@@ -232,7 +232,7 @@ public:
   bool empty() const { return messages_.empty(); }
   void clear();
 
-  template<typename... A> Message &Say(A &&... args) {
+  template <typename... A> Message &Say(A &&... args) {
     last_ = messages_.emplace_after(last_, std::forward<A>(args)...);
     return *last_;
   }
@@ -272,7 +272,7 @@ public:
   ContextualMessages(CharBlock at, Messages *m) : at_{at}, messages_{m} {}
   explicit ContextualMessages(Messages *m) : messages_{m} {}
   ContextualMessages(const ContextualMessages &that)
-    : at_{that.at_}, messages_{that.messages_} {}
+      : at_{that.at_}, messages_{that.messages_} {}
 
   CharBlock at() const { return at_; }
   Messages *messages() const { return messages_; }
@@ -296,7 +296,7 @@ public:
     return common::ScopedSet(messages_, nullptr);
   }
 
-  template<typename... A> Message *Say(CharBlock at, A &&... args) {
+  template <typename... A> Message *Say(CharBlock at, A &&... args) {
     if (messages_ != nullptr) {
       return &messages_->Say(at, std::forward<A>(args)...);
     } else {
@@ -304,7 +304,7 @@ public:
     }
   }
 
-  template<typename... A> Message *Say(A &&... args) {
+  template <typename... A> Message *Say(A &&... args) {
     return Say(at_, std::forward<A>(args)...);
   }
 
@@ -312,5 +312,5 @@ private:
   CharBlock at_;
   Messages *messages_{nullptr};
 };
-}
-#endif  // FORTRAN_PARSER_MESSAGE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_MESSAGE_H_
diff --git a/flang/include/flang/Parser/parse-state.h b/flang/include/flang/Parser/parse-state.h
index d0b304f3c73b..c704d6a9ad1b 100644
--- a/flang/include/flang/Parser/parse-state.h
+++ b/flang/include/flang/Parser/parse-state.h
@@ -36,24 +36,24 @@ class ParseState {
 public:
   // TODO: Add a constructor for parsing a normalized module file.
   ParseState(const CookedSource &cooked)
-    : p_{&cooked.data().front()}, limit_{&cooked.data().back() + 1} {}
+      : p_{&cooked.data().front()}, limit_{&cooked.data().back() + 1} {}
   ParseState(const ParseState &that)
-    : p_{that.p_}, limit_{that.limit_}, context_{that.context_},
-      userState_{that.userState_}, inFixedForm_{that.inFixedForm_},
-      anyErrorRecovery_{that.anyErrorRecovery_},
-      anyConformanceViolation_{that.anyConformanceViolation_},
-      deferMessages_{that.deferMessages_},
-      anyDeferredMessages_{that.anyDeferredMessages_},
-      anyTokenMatched_{that.anyTokenMatched_} {}
+      : p_{that.p_}, limit_{that.limit_}, context_{that.context_},
+        userState_{that.userState_}, inFixedForm_{that.inFixedForm_},
+        anyErrorRecovery_{that.anyErrorRecovery_},
+        anyConformanceViolation_{that.anyConformanceViolation_},
+        deferMessages_{that.deferMessages_},
+        anyDeferredMessages_{that.anyDeferredMessages_},
+        anyTokenMatched_{that.anyTokenMatched_} {}
   ParseState(ParseState &&that)
-    : p_{that.p_}, limit_{that.limit_}, messages_{std::move(that.messages_)},
-      context_{std::move(that.context_)}, userState_{that.userState_},
-      inFixedForm_{that.inFixedForm_},
-      anyErrorRecovery_{that.anyErrorRecovery_},
-      anyConformanceViolation_{that.anyConformanceViolation_},
-      deferMessages_{that.deferMessages_},
-      anyDeferredMessages_{that.anyDeferredMessages_},
-      anyTokenMatched_{that.anyTokenMatched_} {}
+      : p_{that.p_}, limit_{that.limit_}, messages_{std::move(that.messages_)},
+        context_{std::move(that.context_)}, userState_{that.userState_},
+        inFixedForm_{that.inFixedForm_},
+        anyErrorRecovery_{that.anyErrorRecovery_},
+        anyConformanceViolation_{that.anyConformanceViolation_},
+        deferMessages_{that.deferMessages_},
+        anyDeferredMessages_{that.anyDeferredMessages_},
+        anyTokenMatched_{that.anyTokenMatched_} {}
   ParseState &operator=(const ParseState &that) {
     p_ = that.p_, limit_ = that.limit_, context_ = that.context_;
     userState_ = that.userState_, inFixedForm_ = that.inFixedForm_;
@@ -121,7 +121,7 @@ public:
   const char *GetLocation() const { return p_; }
 
   void PushContext(MessageFixedText text) {
-    auto m{new Message{p_, text}};  // reference-counted
+    auto m{new Message{p_, text}}; // reference-counted
     m->SetContext(context_.get());
     context_ = Message::Reference{m};
   }
@@ -131,17 +131,18 @@ public:
     context_ = context_->attachment();
   }
 
-  template<typename... A> void Say(CharBlock range, A &&... args) {
+  template <typename... A> void Say(CharBlock range, A &&... args) {
     if (deferMessages_) {
       anyDeferredMessages_ = true;
     } else {
       messages_.Say(range, std::forward<A>(args)...).SetContext(context_.get());
     }
   }
-  template<typename... A> void Say(const MessageFixedText &text, A &&... args) {
+  template <typename... A>
+  void Say(const MessageFixedText &text, A &&... args) {
     Say(p_, text, std::forward<A>(args)...);
   }
-  template<typename... A>
+  template <typename... A>
   void Say(const MessageExpectedText &text, A &&... args) {
     Say(p_, text, std::forward<A>(args)...);
   }
@@ -228,5 +229,5 @@ private:
   // reflected in the copy and move constructors defined at the top of this
   // class definition!
 };
-}
-#endif  // FORTRAN_PARSER_PARSE_STATE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PARSE_STATE_H_
diff --git a/flang/include/flang/Parser/parse-tree-visitor.h b/flang/include/flang/Parser/parse-tree-visitor.h
index de8e36ba7fd6..179d9c263378 100644
--- a/flang/include/flang/Parser/parse-tree-visitor.h
+++ b/flang/include/flang/Parser/parse-tree-visitor.h
@@ -29,7 +29,7 @@ namespace Fortran::parser {
 
 // Default case for visitation of non-class data members, strings, and
 // any other non-decomposable values.
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<!std::is_class_v<A> || std::is_same_v<std::string, A> ||
     std::is_same_v<CharBlock, A>>
 Walk(const A &x, V &visitor) {
@@ -37,7 +37,7 @@ Walk(const A &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<!std::is_class_v<A> || std::is_same_v<std::string, A> ||
     std::is_same_v<CharBlock, A>>
 Walk(A &x, M &mutator) {
@@ -46,25 +46,25 @@ Walk(A &x, M &mutator) {
   }
 }
 
-template<typename V> void Walk(const format::ControlEditDesc &, V &);
-template<typename M> void Walk(format::ControlEditDesc &, M &);
-template<typename V> void Walk(const format::DerivedTypeDataEditDesc &, V &);
-template<typename M> void Walk(format::DerivedTypeDataEditDesc &, M &);
-template<typename V> void Walk(const format::FormatItem &, V &);
-template<typename M> void Walk(format::FormatItem &, M &);
-template<typename V> void Walk(const format::FormatSpecification &, V &);
-template<typename M> void Walk(format::FormatSpecification &, M &);
-template<typename V> void Walk(const format::IntrinsicTypeDataEditDesc &, V &);
-template<typename M> void Walk(format::IntrinsicTypeDataEditDesc &, M &);
+template <typename V> void Walk(const format::ControlEditDesc &, V &);
+template <typename M> void Walk(format::ControlEditDesc &, M &);
+template <typename V> void Walk(const format::DerivedTypeDataEditDesc &, V &);
+template <typename M> void Walk(format::DerivedTypeDataEditDesc &, M &);
+template <typename V> void Walk(const format::FormatItem &, V &);
+template <typename M> void Walk(format::FormatItem &, M &);
+template <typename V> void Walk(const format::FormatSpecification &, V &);
+template <typename M> void Walk(format::FormatSpecification &, M &);
+template <typename V> void Walk(const format::IntrinsicTypeDataEditDesc &, V &);
+template <typename M> void Walk(format::IntrinsicTypeDataEditDesc &, M &);
 
 // Traversal of needed STL template classes (optional, list, tuple, variant)
-template<typename T, typename V>
+template <typename T, typename V>
 void Walk(const std::optional<T> &x, V &visitor) {
   if (x) {
     Walk(*x, visitor);
   }
 }
-template<typename T, typename M> void Walk(std::optional<T> &x, M &mutator) {
+template <typename T, typename M> void Walk(std::optional<T> &x, M &mutator) {
   if (x) {
     Walk(*x, mutator);
   }
@@ -72,17 +72,17 @@ template<typename T, typename M> void Walk(std::optional<T> &x, M &mutator) {
 // For most lists, just traverse the elements; but when a list constitutes
 // a Block (i.e., std::list<ExecutionPartConstruct>), also invoke the
 // visitor/mutator on the list itself.
-template<typename T, typename V> void Walk(const std::list<T> &x, V &visitor) {
+template <typename T, typename V> void Walk(const std::list<T> &x, V &visitor) {
   for (const auto &elem : x) {
     Walk(elem, visitor);
   }
 }
-template<typename T, typename M> void Walk(std::list<T> &x, M &mutator) {
+template <typename T, typename M> void Walk(std::list<T> &x, M &mutator) {
   for (auto &elem : x) {
     Walk(elem, mutator);
   }
 }
-template<typename V> void Walk(const Block &x, V &visitor) {
+template <typename V> void Walk(const Block &x, V &visitor) {
   if (visitor.Pre(x)) {
     for (const auto &elem : x) {
       Walk(elem, visitor);
@@ -90,7 +90,7 @@ template<typename V> void Walk(const Block &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Block &x, M &mutator) {
+template <typename M> void Walk(Block &x, M &mutator) {
   if (mutator.Pre(x)) {
     for (auto &elem : x) {
       Walk(elem, mutator);
@@ -98,14 +98,14 @@ template<typename M> void Walk(Block &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<std::size_t I = 0, typename Func, typename T>
+template <std::size_t I = 0, typename Func, typename T>
 void ForEachInTuple(const T &tuple, Func func) {
   func(std::get<I>(tuple));
   if constexpr (I + 1 < std::tuple_size_v<T>) {
     ForEachInTuple<I + 1>(tuple, func);
   }
 }
-template<typename V, typename... A>
+template <typename V, typename... A>
 void Walk(const std::tuple<A...> &x, V &visitor) {
   if (sizeof...(A) > 0) {
     if (visitor.Pre(x)) {
@@ -114,14 +114,15 @@ void Walk(const std::tuple<A...> &x, V &visitor) {
     }
   }
 }
-template<std::size_t I = 0, typename Func, typename T>
+template <std::size_t I = 0, typename Func, typename T>
 void ForEachInTuple(T &tuple, Func func) {
   func(std::get<I>(tuple));
   if constexpr (I + 1 < std::tuple_size_v<T>) {
     ForEachInTuple<I + 1>(tuple, func);
   }
 }
-template<typename M, typename... A> void Walk(std::tuple<A...> &x, M &mutator) {
+template <typename M, typename... A>
+void Walk(std::tuple<A...> &x, M &mutator) {
   if (sizeof...(A) > 0) {
     if (mutator.Pre(x)) {
       ForEachInTuple(x, [&](auto &y) { Walk(y, mutator); });
@@ -129,28 +130,28 @@ template<typename M, typename... A> void Walk(std::tuple<A...> &x, M &mutator) {
     }
   }
 }
-template<typename V, typename... A>
+template <typename V, typename... A>
 void Walk(const std::variant<A...> &x, V &visitor) {
   if (visitor.Pre(x)) {
     std::visit([&](const auto &y) { Walk(y, visitor); }, x);
     visitor.Post(x);
   }
 }
-template<typename M, typename... A>
+template <typename M, typename... A>
 void Walk(std::variant<A...> &x, M &mutator) {
   if (mutator.Pre(x)) {
     std::visit([&](auto &y) { Walk(y, mutator); }, x);
     mutator.Post(x);
   }
 }
-template<typename A, typename B, typename V>
+template <typename A, typename B, typename V>
 void Walk(const std::pair<A, B> &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.first, visitor);
     Walk(x.second, visitor);
   }
 }
-template<typename A, typename B, typename M>
+template <typename A, typename B, typename M>
 void Walk(std::pair<A, B> &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.first, mutator);
@@ -160,27 +161,27 @@ void Walk(std::pair<A, B> &x, M &mutator) {
 
 // Trait-determined traversal of empty, tuple, union, wrapper,
 // and constraint-checking classes.
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<EmptyTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<EmptyTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     mutator.Post(x);
   }
 }
 
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<TupleTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.t, visitor);
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<TupleTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.t, mutator);
@@ -188,14 +189,14 @@ std::enable_if_t<TupleTrait<A>> Walk(A &x, M &mutator) {
   }
 }
 
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<UnionTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<UnionTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.u, mutator);
@@ -203,14 +204,14 @@ std::enable_if_t<UnionTrait<A>> Walk(A &x, M &mutator) {
   }
 }
 
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<WrapperTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.v, visitor);
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<WrapperTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.v, mutator);
@@ -218,14 +219,14 @@ std::enable_if_t<WrapperTrait<A>> Walk(A &x, M &mutator) {
   }
 }
 
-template<typename A, typename V>
+template <typename A, typename V>
 std::enable_if_t<ConstraintTrait<A>> Walk(const A &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.thing, visitor);
     visitor.Post(x);
   }
 }
-template<typename A, typename M>
+template <typename A, typename M>
 std::enable_if_t<ConstraintTrait<A>> Walk(A &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.thing, mutator);
@@ -233,16 +234,16 @@ std::enable_if_t<ConstraintTrait<A>> Walk(A &x, M &mutator) {
   }
 }
 
-template<typename T, typename V>
+template <typename T, typename V>
 void Walk(const common::Indirection<T> &x, V &visitor) {
   Walk(x.value(), visitor);
 }
-template<typename T, typename M>
+template <typename T, typename M>
 void Walk(common::Indirection<T> &x, M &mutator) {
   Walk(x.value(), mutator);
 }
 
-template<typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
+template <typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
   if (visitor.Pre(x)) {
     // N.B. The label, if any, is not visited.
     Walk(x.source, visitor);
@@ -250,7 +251,7 @@ template<typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename T, typename M> void Walk(Statement<T> &x, M &mutator) {
+template <typename T, typename M> void Walk(Statement<T> &x, M &mutator) {
   if (mutator.Pre(x)) {
     // N.B. The label, if any, is not visited.
     Walk(x.source, mutator);
@@ -259,7 +260,7 @@ template<typename T, typename M> void Walk(Statement<T> &x, M &mutator) {
   }
 }
 
-template<typename T, typename V>
+template <typename T, typename V>
 void Walk(const UnlabeledStatement<T> &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
@@ -267,7 +268,7 @@ void Walk(const UnlabeledStatement<T> &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename T, typename M>
+template <typename T, typename M>
 void Walk(UnlabeledStatement<T> &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
@@ -276,48 +277,48 @@ void Walk(UnlabeledStatement<T> &x, M &mutator) {
   }
 }
 
-template<typename V> void Walk(const Name &x, V &visitor) {
+template <typename V> void Walk(const Name &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Name &x, M &mutator) {
+template <typename M> void Walk(Name &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     mutator.Post(x);
   }
 }
 
-template<typename V> void Walk(const AcSpec &x, V &visitor) {
+template <typename V> void Walk(const AcSpec &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.type, visitor);
     Walk(x.values, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(AcSpec &x, M &mutator) {
+template <typename M> void Walk(AcSpec &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.type, mutator);
     Walk(x.values, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const ArrayElement &x, V &visitor) {
+template <typename V> void Walk(const ArrayElement &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.base, visitor);
     Walk(x.subscripts, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(ArrayElement &x, M &mutator) {
+template <typename M> void Walk(ArrayElement &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.base, mutator);
     Walk(x.subscripts, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const CharSelector::LengthAndKind &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.length, visitor);
@@ -325,130 +326,131 @@ void Walk(const CharSelector::LengthAndKind &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CharSelector::LengthAndKind &x, M &mutator) {
+template <typename M> void Walk(CharSelector::LengthAndKind &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.length, mutator);
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const CaseValueRange::Range &x, V &visitor) {
+template <typename V> void Walk(const CaseValueRange::Range &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.lower, visitor);
     Walk(x.upper, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CaseValueRange::Range &x, M &mutator) {
+template <typename M> void Walk(CaseValueRange::Range &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.lower, mutator);
     Walk(x.upper, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const CoindexedNamedObject &x, V &visitor) {
+template <typename V> void Walk(const CoindexedNamedObject &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.base, visitor);
     Walk(x.imageSelector, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CoindexedNamedObject &x, M &mutator) {
+template <typename M> void Walk(CoindexedNamedObject &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.base, mutator);
     Walk(x.imageSelector, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const DeclarationTypeSpec::Class &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.derived, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(DeclarationTypeSpec::Class &x, M &mutator) {
+template <typename M> void Walk(DeclarationTypeSpec::Class &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.derived, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const DeclarationTypeSpec::Type &x, V &visitor) {
+template <typename V>
+void Walk(const DeclarationTypeSpec::Type &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.derived, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(DeclarationTypeSpec::Type &x, M &mutator) {
+template <typename M> void Walk(DeclarationTypeSpec::Type &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.derived, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const ImportStmt &x, V &visitor) {
+template <typename V> void Walk(const ImportStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.names, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(ImportStmt &x, M &mutator) {
+template <typename M> void Walk(ImportStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.names, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const IntrinsicTypeSpec::Character &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.selector, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(IntrinsicTypeSpec::Character &x, M &mutator) {
+template <typename M> void Walk(IntrinsicTypeSpec::Character &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.selector, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const IntrinsicTypeSpec::Complex &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(IntrinsicTypeSpec::Complex &x, M &mutator) {
+template <typename M> void Walk(IntrinsicTypeSpec::Complex &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const IntrinsicTypeSpec::Logical &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(IntrinsicTypeSpec::Logical &x, M &mutator) {
+template <typename M> void Walk(IntrinsicTypeSpec::Logical &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const IntrinsicTypeSpec::Real &x, V &visitor) {
+template <typename V> void Walk(const IntrinsicTypeSpec::Real &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(IntrinsicTypeSpec::Real &x, M &mutator) {
+template <typename M> void Walk(IntrinsicTypeSpec::Real &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename A, typename B, typename V>
+template <typename A, typename B, typename V>
 void Walk(const LoopBounds<A, B> &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.name, visitor);
@@ -458,7 +460,7 @@ void Walk(const LoopBounds<A, B> &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename A, typename B, typename M>
+template <typename A, typename B, typename M>
 void Walk(LoopBounds<A, B> &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.name, mutator);
@@ -468,61 +470,61 @@ void Walk(LoopBounds<A, B> &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const CommonStmt &x, V &visitor) {
+template <typename V> void Walk(const CommonStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.blocks, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CommonStmt &x, M &mutator) {
+template <typename M> void Walk(CommonStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.blocks, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const Expr &x, V &visitor) {
+template <typename V> void Walk(const Expr &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Expr &x, M &mutator) {
+template <typename M> void Walk(Expr &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.u, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const Designator &x, V &visitor) {
+template <typename V> void Walk(const Designator &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Designator &x, M &mutator) {
+template <typename M> void Walk(Designator &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.u, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const Call &x, V &visitor) {
+template <typename V> void Walk(const Call &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.t, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Call &x, M &mutator) {
+template <typename M> void Walk(Call &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.t, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const PartRef &x, V &visitor) {
+template <typename V> void Walk(const PartRef &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.name, visitor);
     Walk(x.subscripts, visitor);
@@ -530,7 +532,7 @@ template<typename V> void Walk(const PartRef &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(PartRef &x, M &mutator) {
+template <typename M> void Walk(PartRef &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.name, mutator);
     Walk(x.subscripts, mutator);
@@ -538,7 +540,7 @@ template<typename M> void Walk(PartRef &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const ReadStmt &x, V &visitor) {
+template <typename V> void Walk(const ReadStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.iounit, visitor);
     Walk(x.format, visitor);
@@ -547,7 +549,7 @@ template<typename V> void Walk(const ReadStmt &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(ReadStmt &x, M &mutator) {
+template <typename M> void Walk(ReadStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.iounit, mutator);
     Walk(x.format, mutator);
@@ -556,75 +558,76 @@ template<typename M> void Walk(ReadStmt &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const SignedIntLiteralConstant &x, V &visitor) {
+template <typename V> void Walk(const SignedIntLiteralConstant &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.t, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(SignedIntLiteralConstant &x, M &mutator) {
+template <typename M> void Walk(SignedIntLiteralConstant &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.t, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const RealLiteralConstant &x, V &visitor) {
+template <typename V> void Walk(const RealLiteralConstant &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.real, visitor);
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(RealLiteralConstant &x, M &mutator) {
+template <typename M> void Walk(RealLiteralConstant &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.real, mutator);
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const RealLiteralConstant::Real &x, V &visitor) {
+template <typename V>
+void Walk(const RealLiteralConstant::Real &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(RealLiteralConstant::Real &x, M &mutator) {
+template <typename M> void Walk(RealLiteralConstant::Real &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const StructureComponent &x, V &visitor) {
+template <typename V> void Walk(const StructureComponent &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.base, visitor);
     Walk(x.component, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(StructureComponent &x, M &mutator) {
+template <typename M> void Walk(StructureComponent &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.base, mutator);
     Walk(x.component, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const Suffix &x, V &visitor) {
+template <typename V> void Walk(const Suffix &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.binding, visitor);
     Walk(x.resultName, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(Suffix &x, M &mutator) {
+template <typename M> void Walk(Suffix &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.binding, mutator);
     Walk(x.resultName, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const TypeBoundProcedureStmt::WithInterface &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.interfaceName, visitor);
@@ -633,7 +636,7 @@ void Walk(const TypeBoundProcedureStmt::WithInterface &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M>
+template <typename M>
 void Walk(TypeBoundProcedureStmt::WithInterface &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.interfaceName, mutator);
@@ -642,7 +645,7 @@ void Walk(TypeBoundProcedureStmt::WithInterface &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const TypeBoundProcedureStmt::WithoutInterface &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.attributes, visitor);
@@ -650,7 +653,7 @@ void Walk(const TypeBoundProcedureStmt::WithoutInterface &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M>
+template <typename M>
 void Walk(TypeBoundProcedureStmt::WithoutInterface &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.attributes, mutator);
@@ -658,7 +661,7 @@ void Walk(TypeBoundProcedureStmt::WithoutInterface &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const UseStmt &x, V &visitor) {
+template <typename V> void Walk(const UseStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.nature, visitor);
     Walk(x.moduleName, visitor);
@@ -666,7 +669,7 @@ template<typename V> void Walk(const UseStmt &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(UseStmt &x, M &mutator) {
+template <typename M> void Walk(UseStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.nature, mutator);
     Walk(x.moduleName, mutator);
@@ -674,7 +677,7 @@ template<typename M> void Walk(UseStmt &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const WriteStmt &x, V &visitor) {
+template <typename V> void Walk(const WriteStmt &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.iounit, visitor);
     Walk(x.format, visitor);
@@ -683,7 +686,7 @@ template<typename V> void Walk(const WriteStmt &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(WriteStmt &x, M &mutator) {
+template <typename M> void Walk(WriteStmt &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.iounit, mutator);
     Walk(x.format, mutator);
@@ -692,19 +695,19 @@ template<typename M> void Walk(WriteStmt &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const format::ControlEditDesc &x, V &visitor) {
+template <typename V> void Walk(const format::ControlEditDesc &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(format::ControlEditDesc &x, M &mutator) {
+template <typename M> void Walk(format::ControlEditDesc &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const format::DerivedTypeDataEditDesc &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.type, visitor);
@@ -712,28 +715,29 @@ void Walk(const format::DerivedTypeDataEditDesc &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(format::DerivedTypeDataEditDesc &x, M &mutator) {
+template <typename M>
+void Walk(format::DerivedTypeDataEditDesc &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.type, mutator);
     Walk(x.parameters, mutator);
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const format::FormatItem &x, V &visitor) {
+template <typename V> void Walk(const format::FormatItem &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.repeatCount, visitor);
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(format::FormatItem &x, M &mutator) {
+template <typename M> void Walk(format::FormatItem &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.repeatCount, mutator);
     Walk(x.u, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const format::FormatSpecification &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.items, visitor);
@@ -741,14 +745,14 @@ void Walk(const format::FormatSpecification &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(format::FormatSpecification &x, M &mutator) {
+template <typename M> void Walk(format::FormatSpecification &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.items, mutator);
     Walk(x.unlimitedItems, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const format::IntrinsicTypeDataEditDesc &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.kind, visitor);
@@ -758,7 +762,7 @@ void Walk(const format::IntrinsicTypeDataEditDesc &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M>
+template <typename M>
 void Walk(format::IntrinsicTypeDataEditDesc &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.kind, mutator);
@@ -768,21 +772,21 @@ void Walk(format::IntrinsicTypeDataEditDesc &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V> void Walk(const CompilerDirective &x, V &visitor) {
+template <typename V> void Walk(const CompilerDirective &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.source, visitor);
     Walk(x.u, visitor);
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(CompilerDirective &x, M &mutator) {
+template <typename M> void Walk(CompilerDirective &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.source, mutator);
     Walk(x.u, mutator);
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const OmpLinearClause::WithModifier &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.modifier, visitor);
@@ -791,7 +795,7 @@ void Walk(const OmpLinearClause::WithModifier &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M> void Walk(OmpLinearClause::WithModifier &x, M &mutator) {
+template <typename M> void Walk(OmpLinearClause::WithModifier &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.modifier, mutator);
     Walk(x.names, mutator);
@@ -799,7 +803,7 @@ template<typename M> void Walk(OmpLinearClause::WithModifier &x, M &mutator) {
     mutator.Post(x);
   }
 }
-template<typename V>
+template <typename V>
 void Walk(const OmpLinearClause::WithoutModifier &x, V &visitor) {
   if (visitor.Pre(x)) {
     Walk(x.names, visitor);
@@ -807,7 +811,7 @@ void Walk(const OmpLinearClause::WithoutModifier &x, V &visitor) {
     visitor.Post(x);
   }
 }
-template<typename M>
+template <typename M>
 void Walk(OmpLinearClause::WithoutModifier &x, M &mutator) {
   if (mutator.Pre(x)) {
     Walk(x.names, mutator);
@@ -815,5 +819,5 @@ void Walk(OmpLinearClause::WithoutModifier &x, M &mutator) {
     mutator.Post(x);
   }
 }
-}
-#endif  // FORTRAN_PARSER_PARSE_TREE_VISITOR_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PARSE_TREE_VISITOR_H_
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
index 1d93c13cada6..f5f7a18652fc 100644
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -58,15 +58,15 @@ namespace Fortran::semantics {
 class Symbol;
 class DeclTypeSpec;
 class DerivedTypeSpec;
-}
+} // namespace Fortran::semantics
 
 // Expressions in the parse tree have owning pointers that can be set to
 // type-checked generic expression representations by semantic analysis.
 namespace Fortran::evaluate {
-struct GenericExprWrapper;  // forward definition, wraps Expr<SomeType>
-struct GenericAssignmentWrapper;  // forward definition, represent assignment
-class ProcedureRef;  // forward definition, represents a CALL statement
-}
+struct GenericExprWrapper; // forward definition, wraps Expr<SomeType>
+struct GenericAssignmentWrapper; // forward definition, represent assignment
+class ProcedureRef; // forward definition, represents a CALL statement
+} // namespace Fortran::evaluate
 
 // Most non-template classes in this file use these default definitions
 // for their move constructor and move assignment operator=, and disable
@@ -97,7 +97,7 @@ class ProcedureRef;  // forward definition, represents a CALL statement
 // Many classes below simply wrap a std::variant<> discriminated union,
 // which is conventionally named "u".
 #define UNION_CLASS_BOILERPLATE(classname) \
-  template<typename A, typename = common::NoLvalue<A>> \
+  template <typename A, typename = common::NoLvalue<A>> \
   classname(A &&x) : u(std::move(x)) {} \
   using UnionTrait = std::true_type; \
   BOILERPLATE(classname)
@@ -105,7 +105,7 @@ class ProcedureRef;  // forward definition, represents a CALL statement
 // Many other classes below simply wrap a std::tuple<> structure, which
 // is conventionally named "t".
 #define TUPLE_CLASS_BOILERPLATE(classname) \
-  template<typename... Ts, typename = common::NoLvalue<Ts...>> \
+  template <typename... Ts, typename = common::NoLvalue<Ts...>> \
   classname(Ts &&... args) : t(std::move(args)...) {} \
   using TupleTrait = std::true_type; \
   BOILERPLATE(classname)
@@ -129,123 +129,123 @@ namespace Fortran::parser {
 // Some references to the representations of their parses require
 // indirection.  The Indirect<> pointer wrapper class is used to
 // enforce ownership semantics and non-nullability.
-struct SpecificationPart;  // R504
-struct ExecutableConstruct;  // R514
-struct ActionStmt;  // R515
-struct AcImpliedDo;  // R774
-struct DataImpliedDo;  // R840
-struct Designator;  // R901
-struct Variable;  // R902
-struct Expr;  // R1001
-struct WhereConstruct;  // R1042
-struct ForallConstruct;  // R1050
-struct InputImpliedDo;  // R1218
-struct OutputImpliedDo;  // R1218
-struct FunctionReference;  // R1520
-struct FunctionSubprogram;  // R1529
-struct SubroutineSubprogram;  // R1534
+struct SpecificationPart; // R504
+struct ExecutableConstruct; // R514
+struct ActionStmt; // R515
+struct AcImpliedDo; // R774
+struct DataImpliedDo; // R840
+struct Designator; // R901
+struct Variable; // R902
+struct Expr; // R1001
+struct WhereConstruct; // R1042
+struct ForallConstruct; // R1050
+struct InputImpliedDo; // R1218
+struct OutputImpliedDo; // R1218
+struct FunctionReference; // R1520
+struct FunctionSubprogram; // R1529
+struct SubroutineSubprogram; // R1534
 
 // These additional forward references are declared so that the order of
 // class definitions in this header file can remain reasonably consistent
 // with order of the the requirement productions in the grammar.
-struct DerivedTypeDef;  // R726
-struct EnumDef;  // R759
-struct TypeDeclarationStmt;  // R801
-struct AccessStmt;  // R827
-struct AllocatableStmt;  // R829
-struct AsynchronousStmt;  // R831
-struct BindStmt;  // R832
-struct CodimensionStmt;  // R834
-struct ContiguousStmt;  // R836
-struct DataStmt;  // R837
-struct DataStmtValue;  // R843
-struct DimensionStmt;  // R848
-struct IntentStmt;  // R849
-struct OptionalStmt;  // R850
-struct ParameterStmt;  // R851
+struct DerivedTypeDef; // R726
+struct EnumDef; // R759
+struct TypeDeclarationStmt; // R801
+struct AccessStmt; // R827
+struct AllocatableStmt; // R829
+struct AsynchronousStmt; // R831
+struct BindStmt; // R832
+struct CodimensionStmt; // R834
+struct ContiguousStmt; // R836
+struct DataStmt; // R837
+struct DataStmtValue; // R843
+struct DimensionStmt; // R848
+struct IntentStmt; // R849
+struct OptionalStmt; // R850
+struct ParameterStmt; // R851
 struct OldParameterStmt;
-struct PointerStmt;  // R853
-struct ProtectedStmt;  // R855
-struct SaveStmt;  // R856
-struct TargetStmt;  // R859
-struct ValueStmt;  // R861
-struct VolatileStmt;  // R862
-struct ImplicitStmt;  // R863
-struct ImportStmt;  // R867
-struct NamelistStmt;  // R868
-struct EquivalenceStmt;  // R870
-struct CommonStmt;  // R873
-struct Substring;  // R908
+struct PointerStmt; // R853
+struct ProtectedStmt; // R855
+struct SaveStmt; // R856
+struct TargetStmt; // R859
+struct ValueStmt; // R861
+struct VolatileStmt; // R862
+struct ImplicitStmt; // R863
+struct ImportStmt; // R867
+struct NamelistStmt; // R868
+struct EquivalenceStmt; // R870
+struct CommonStmt; // R873
+struct Substring; // R908
 struct CharLiteralConstantSubstring;
-struct DataRef;  // R911
-struct StructureComponent;  // R913
-struct CoindexedNamedObject;  // R914
-struct ArrayElement;  // R917
-struct AllocateStmt;  // R927
-struct NullifyStmt;  // R939
-struct DeallocateStmt;  // R941
-struct AssignmentStmt;  // R1032
-struct PointerAssignmentStmt;  // R1033
-struct WhereStmt;  // R1041, R1045, R1046
-struct ForallStmt;  // R1055
-struct AssociateConstruct;  // R1102
-struct BlockConstruct;  // R1107
-struct ChangeTeamConstruct;  // R1111
-struct CriticalConstruct;  // R1116
-struct DoConstruct;  // R1119
-struct LabelDoStmt;  // R1121
-struct ConcurrentHeader;  // R1125
-struct EndDoStmt;  // R1132
-struct CycleStmt;  // R1133
-struct IfConstruct;  // R1134
-struct IfStmt;  // R1139
-struct CaseConstruct;  // R1140
-struct SelectRankConstruct;  // R1148
-struct SelectTypeConstruct;  // R1152
-struct ExitStmt;  // R1156
-struct GotoStmt;  // R1157
-struct ComputedGotoStmt;  // R1158
-struct StopStmt;  // R1160, R1161
-struct SyncAllStmt;  // R1164
-struct SyncImagesStmt;  // R1166
-struct SyncMemoryStmt;  // R1168
-struct SyncTeamStmt;  // R1169
-struct EventPostStmt;  // R1170, R1171
-struct EventWaitStmt;  // R1172, R1173, R1174
-struct FormTeamStmt;  // R1175, R1176, R1177
-struct LockStmt;  // R1178
-struct UnlockStmt;  // R1180
-struct OpenStmt;  // R1204
-struct CloseStmt;  // R1208
-struct ReadStmt;  // R1210
-struct WriteStmt;  // R1211
-struct PrintStmt;  // R1212
-struct WaitStmt;  // R1222
-struct BackspaceStmt;  // R1224
-struct EndfileStmt;  // R1225
-struct RewindStmt;  // R1226
-struct FlushStmt;  // R1228
-struct InquireStmt;  // R1230
-struct FormatStmt;  // R1301
-struct MainProgram;  // R1401
-struct Module;  // R1404
-struct UseStmt;  // R1409
-struct Submodule;  // R1416
-struct BlockData;  // R1420
-struct InterfaceBlock;  // R1501
-struct GenericSpec;  // R1508
-struct GenericStmt;  // R1510
-struct ExternalStmt;  // R1511
-struct ProcedureDeclarationStmt;  // R1512
-struct IntrinsicStmt;  // R1519
-struct Call;  // R1520 & R1521
-struct CallStmt;  // R1521
-struct ProcedureDesignator;  // R1522
-struct ActualArg;  // R1524
-struct SeparateModuleSubprogram;  // R1538
-struct EntryStmt;  // R1541
-struct ReturnStmt;  // R1542
-struct StmtFunctionStmt;  // R1544
+struct DataRef; // R911
+struct StructureComponent; // R913
+struct CoindexedNamedObject; // R914
+struct ArrayElement; // R917
+struct AllocateStmt; // R927
+struct NullifyStmt; // R939
+struct DeallocateStmt; // R941
+struct AssignmentStmt; // R1032
+struct PointerAssignmentStmt; // R1033
+struct WhereStmt; // R1041, R1045, R1046
+struct ForallStmt; // R1055
+struct AssociateConstruct; // R1102
+struct BlockConstruct; // R1107
+struct ChangeTeamConstruct; // R1111
+struct CriticalConstruct; // R1116
+struct DoConstruct; // R1119
+struct LabelDoStmt; // R1121
+struct ConcurrentHeader; // R1125
+struct EndDoStmt; // R1132
+struct CycleStmt; // R1133
+struct IfConstruct; // R1134
+struct IfStmt; // R1139
+struct CaseConstruct; // R1140
+struct SelectRankConstruct; // R1148
+struct SelectTypeConstruct; // R1152
+struct ExitStmt; // R1156
+struct GotoStmt; // R1157
+struct ComputedGotoStmt; // R1158
+struct StopStmt; // R1160, R1161
+struct SyncAllStmt; // R1164
+struct SyncImagesStmt; // R1166
+struct SyncMemoryStmt; // R1168
+struct SyncTeamStmt; // R1169
+struct EventPostStmt; // R1170, R1171
+struct EventWaitStmt; // R1172, R1173, R1174
+struct FormTeamStmt; // R1175, R1176, R1177
+struct LockStmt; // R1178
+struct UnlockStmt; // R1180
+struct OpenStmt; // R1204
+struct CloseStmt; // R1208
+struct ReadStmt; // R1210
+struct WriteStmt; // R1211
+struct PrintStmt; // R1212
+struct WaitStmt; // R1222
+struct BackspaceStmt; // R1224
+struct EndfileStmt; // R1225
+struct RewindStmt; // R1226
+struct FlushStmt; // R1228
+struct InquireStmt; // R1230
+struct FormatStmt; // R1301
+struct MainProgram; // R1401
+struct Module; // R1404
+struct UseStmt; // R1409
+struct Submodule; // R1416
+struct BlockData; // R1420
+struct InterfaceBlock; // R1501
+struct GenericSpec; // R1508
+struct GenericStmt; // R1510
+struct ExternalStmt; // R1511
+struct ProcedureDeclarationStmt; // R1512
+struct IntrinsicStmt; // R1519
+struct Call; // R1520 & R1521
+struct CallStmt; // R1521
+struct ProcedureDesignator; // R1522
+struct ActualArg; // R1524
+struct SeparateModuleSubprogram; // R1538
+struct EntryStmt; // R1541
+struct ReturnStmt; // R1542
+struct StmtFunctionStmt; // R1544
 
 // Directives, extensions, and deprecated statements
 struct CompilerDirective;
@@ -274,7 +274,7 @@ struct Verbatim {
 // R403 scalar-xyz -> xyz
 // These template class wrappers correspond to the Standard's modifiers
 // scalar-xyz, constant-xzy, int-xzy, default-char-xyz, & logical-xyz.
-template<typename A> struct Scalar {
+template <typename A> struct Scalar {
   using ConstraintTrait = std::true_type;
   Scalar(Scalar &&that) = default;
   Scalar(A &&that) : thing(std::move(that)) {}
@@ -282,7 +282,7 @@ template<typename A> struct Scalar {
   A thing;
 };
 
-template<typename A> struct Constant {
+template <typename A> struct Constant {
   using ConstraintTrait = std::true_type;
   Constant(Constant &&that) = default;
   Constant(A &&that) : thing(std::move(that)) {}
@@ -290,7 +290,7 @@ template<typename A> struct Constant {
   A thing;
 };
 
-template<typename A> struct Integer {
+template <typename A> struct Integer {
   using ConstraintTrait = std::true_type;
   Integer(Integer &&that) = default;
   Integer(A &&that) : thing(std::move(that)) {}
@@ -298,7 +298,7 @@ template<typename A> struct Integer {
   A thing;
 };
 
-template<typename A> struct Logical {
+template <typename A> struct Logical {
   using ConstraintTrait = std::true_type;
   Logical(Logical &&that) = default;
   Logical(A &&that) : thing(std::move(that)) {}
@@ -306,7 +306,7 @@ template<typename A> struct Logical {
   A thing;
 };
 
-template<typename A> struct DefaultChar {
+template <typename A> struct DefaultChar {
   using ConstraintTrait = std::true_type;
   DefaultChar(DefaultChar &&that) = default;
   DefaultChar(A &&that) : thing(std::move(that)) {}
@@ -314,11 +314,11 @@ template<typename A> struct DefaultChar {
   A thing;
 };
 
-using LogicalExpr = Logical<common::Indirection<Expr>>;  // R1024
-using DefaultCharExpr = DefaultChar<common::Indirection<Expr>>;  // R1025
-using IntExpr = Integer<common::Indirection<Expr>>;  // R1026
-using ConstantExpr = Constant<common::Indirection<Expr>>;  // R1029
-using IntConstantExpr = Integer<ConstantExpr>;  // R1031
+using LogicalExpr = Logical<common::Indirection<Expr>>; // R1024
+using DefaultCharExpr = DefaultChar<common::Indirection<Expr>>; // R1025
+using IntExpr = Integer<common::Indirection<Expr>>; // R1026
+using ConstantExpr = Constant<common::Indirection<Expr>>; // R1029
+using IntConstantExpr = Integer<ConstantExpr>; // R1031
 using ScalarLogicalExpr = Scalar<LogicalExpr>;
 using ScalarIntExpr = Scalar<IntExpr>;
 using ScalarIntConstantExpr = Scalar<IntConstantExpr>;
@@ -328,18 +328,18 @@ using ScalarDefaultCharExpr = Scalar<DefaultCharExpr>;
 using ScalarDefaultCharConstantExpr = Scalar<DefaultChar<ConstantExpr>>;
 
 // R611 label -> digit [digit]...
-using Label = std::uint64_t;  // validated later, must be in [1..99999]
+using Label = std::uint64_t; // validated later, must be in [1..99999]
 
 // A wrapper for xzy-stmt productions that are statements, so that
 // source provenances and labels have a uniform representation.
-template<typename A> struct UnlabeledStatement {
+template <typename A> struct UnlabeledStatement {
   explicit UnlabeledStatement(A &&s) : statement(std::move(s)) {}
   CharBlock source;
   A statement;
 };
-template<typename A> struct Statement : public UnlabeledStatement<A> {
+template <typename A> struct Statement : public UnlabeledStatement<A> {
   Statement(std::optional<long> &&lab, A &&s)
-    : UnlabeledStatement<A>{std::move(s)}, label(std::move(lab)) {}
+      : UnlabeledStatement<A>{std::move(s)}, label(std::move(lab)) {}
   std::optional<Label> label;
 };
 
@@ -548,7 +548,7 @@ WRAPPER_CLASS(Program, std::list<ProgramUnit>);
 struct Name {
   std::string ToString() const { return source.ToString(); }
   CharBlock source;
-  mutable semantics::Symbol *symbol{nullptr};  // filled in during semantics
+  mutable semantics::Symbol *symbol{nullptr}; // filled in during semantics
 };
 
 // R516 keyword -> name
@@ -609,7 +609,7 @@ EMPTY_CLASS(Star);
 
 struct TypeParamValue {
   UNION_CLASS_BOILERPLATE(TypeParamValue);
-  EMPTY_CLASS(Deferred);  // :
+  EMPTY_CLASS(Deferred); // :
   std::variant<ScalarIntExpr, Star, Deferred> u;
 };
 
@@ -647,14 +647,14 @@ struct CharSelector {
   struct LengthAndKind {
     BOILERPLATE(LengthAndKind);
     LengthAndKind(std::optional<TypeParamValue> &&l, ScalarIntConstantExpr &&k)
-      : length(std::move(l)), kind(std::move(k)) {}
+        : length(std::move(l)), kind(std::move(k)) {}
     std::optional<TypeParamValue> length;
     ScalarIntConstantExpr kind;
   };
   CharSelector(TypeParamValue &&l, ScalarIntConstantExpr &&k)
-    : u{LengthAndKind{std::make_optional(std::move(l)), std::move(k)}} {}
+      : u{LengthAndKind{std::make_optional(std::move(l)), std::move(k)}} {}
   CharSelector(ScalarIntConstantExpr &&k, std::optional<TypeParamValue> &&l)
-    : u{LengthAndKind{std::move(l), std::move(k)}} {}
+      : u{LengthAndKind{std::move(l), std::move(k)}} {}
   std::variant<LengthSelector, LengthAndKind> u;
 };
 
@@ -770,7 +770,7 @@ struct RealLiteralConstant {
     CharBlock source;
   };
   RealLiteralConstant(Real &&r, std::optional<KindParam> &&k)
-    : real{std::move(r)}, kind{std::move(k)} {}
+      : real{std::move(r)}, kind{std::move(k)} {}
   Real real;
   std::optional<KindParam> kind;
 };
@@ -797,7 +797,7 @@ struct ComplexPart {
 // R718 complex-literal-constant -> ( real-part , imag-part )
 struct ComplexLiteralConstant {
   TUPLE_CLASS_BOILERPLATE(ComplexLiteralConstant);
-  std::tuple<ComplexPart, ComplexPart> t;  // real, imaginary
+  std::tuple<ComplexPart, ComplexPart> t; // real, imaginary
 };
 
 // Extension: signed COMPLEX constant
@@ -1077,15 +1077,15 @@ struct TypeBoundProcedureStmt {
     BOILERPLATE(WithoutInterface);
     WithoutInterface(
         std::list<BindAttr> &&as, std::list<TypeBoundProcDecl> &&ds)
-      : attributes(std::move(as)), declarations(std::move(ds)) {}
+        : attributes(std::move(as)), declarations(std::move(ds)) {}
     std::list<BindAttr> attributes;
     std::list<TypeBoundProcDecl> declarations;
   };
   struct WithInterface {
     BOILERPLATE(WithInterface);
     WithInterface(Name &&n, std::list<BindAttr> &&as, std::list<Name> &&bs)
-      : interfaceName(std::move(n)), attributes(std::move(as)),
-        bindingNames(std::move(bs)) {}
+        : interfaceName(std::move(n)), attributes(std::move(as)),
+          bindingNames(std::move(bs)) {}
     Name interfaceName;
     std::list<BindAttr> attributes;
     std::list<Name> bindingNames;
@@ -1184,7 +1184,7 @@ struct EnumDef {
 
 // R773 ac-value -> expr | ac-implied-do
 struct AcValue {
-  struct Triplet {  // PGI/Intel extension
+  struct Triplet { // PGI/Intel extension
     TUPLE_CLASS_BOILERPLATE(Triplet);
     std::tuple<ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>> t;
   };
@@ -1198,7 +1198,7 @@ struct AcValue {
 struct AcSpec {
   BOILERPLATE(AcSpec);
   AcSpec(std::optional<TypeSpec> &&ts, std::list<AcValue> &&xs)
-    : type(std::move(ts)), values(std::move(xs)) {}
+      : type(std::move(ts)), values(std::move(xs)) {}
   explicit AcSpec(TypeSpec &&ts) : type{std::move(ts)} {}
   std::optional<TypeSpec> type;
   std::list<AcValue> values;
@@ -1210,12 +1210,12 @@ WRAPPER_CLASS(ArrayConstructor, AcSpec);
 // R1124 do-variable -> scalar-int-variable-name
 using DoVariable = Scalar<Integer<Name>>;
 
-template<typename VAR, typename BOUND> struct LoopBounds {
+template <typename VAR, typename BOUND> struct LoopBounds {
   LoopBounds(LoopBounds &&that) = default;
   LoopBounds(
       VAR &&name, BOUND &&lower, BOUND &&upper, std::optional<BOUND> &&step)
-    : name{std::move(name)}, lower{std::move(lower)}, upper{std::move(upper)},
-      step{std::move(step)} {}
+      : name{std::move(name)}, lower{std::move(lower)}, upper{std::move(upper)},
+        step{std::move(step)} {}
   LoopBounds &operator=(LoopBounds &&) = default;
   VAR name;
   BOUND lower, upper;
@@ -1528,7 +1528,7 @@ struct ImplicitSpec {
 // R866 implicit-name-spec -> EXTERNAL | TYPE
 struct ImplicitStmt {
   UNION_CLASS_BOILERPLATE(ImplicitStmt);
-  ENUM_CLASS(ImplicitNoneNameSpec, External, Type)  // R866
+  ENUM_CLASS(ImplicitNoneNameSpec, External, Type) // R866
   std::variant<std::list<ImplicitSpec>, std::list<ImplicitNoneNameSpec>> u;
 };
 
@@ -1624,8 +1624,7 @@ struct Expr {
     using IntrinsicUnary::IntrinsicUnary;
   };
 
-  WRAPPER_CLASS(
-      PercentLoc, common::Indirection<Variable>);  // %LOC(v) extension
+  WRAPPER_CLASS(PercentLoc, common::Indirection<Variable>); // %LOC(v) extension
 
   struct DefinedUnary {
     TUPLE_CLASS_BOILERPLATE(DefinedUnary);
@@ -1721,8 +1720,8 @@ struct PartRef {
   BOILERPLATE(PartRef);
   PartRef(Name &&n, std::list<SectionSubscript> &&ss,
       std::optional<ImageSelector> &&is)
-    : name{std::move(n)},
-      subscripts(std::move(ss)), imageSelector{std::move(is)} {}
+      : name{std::move(n)},
+        subscripts(std::move(ss)), imageSelector{std::move(is)} {}
   Name name;
   std::list<SectionSubscript> subscripts;
   std::optional<ImageSelector> imageSelector;
@@ -1792,7 +1791,7 @@ using ScalarIntVariable = Scalar<Integer<Variable>>;
 struct StructureComponent {
   BOILERPLATE(StructureComponent);
   StructureComponent(DataRef &&dr, Name &&n)
-    : base{std::move(dr)}, component(std::move(n)) {}
+      : base{std::move(dr)}, component(std::move(n)) {}
   DataRef base;
   Name component;
 };
@@ -1807,7 +1806,7 @@ struct ProcComponentRef {
 struct CoindexedNamedObject {
   BOILERPLATE(CoindexedNamedObject);
   CoindexedNamedObject(DataRef &&dr, ImageSelector &&is)
-    : base{std::move(dr)}, imageSelector{std::move(is)} {}
+      : base{std::move(dr)}, imageSelector{std::move(is)} {}
   DataRef base;
   ImageSelector imageSelector;
 };
@@ -1816,7 +1815,7 @@ struct CoindexedNamedObject {
 struct ArrayElement {
   BOILERPLATE(ArrayElement);
   ArrayElement(DataRef &&dr, std::list<SectionSubscript> &&ss)
-    : base{std::move(dr)}, subscripts(std::move(ss)) {}
+      : base{std::move(dr)}, subscripts(std::move(ss)) {}
   Substring ConvertToSubstring();
   StructureConstructor ConvertToStructureConstructor(
       const semantics::DerivedTypeSpec &);
@@ -2287,8 +2286,8 @@ struct CaseValueRange {
   struct Range {
     BOILERPLATE(Range);
     Range(std::optional<CaseValue> &&l, std::optional<CaseValue> &&u)
-      : lower{std::move(l)}, upper{std::move(u)} {}
-    std::optional<CaseValue> lower, upper;  // not both missing
+        : lower{std::move(l)}, upper{std::move(u)} {}
+    std::optional<CaseValue> lower, upper; // not both missing
   };
   std::variant<CaseValue, Range> u;
 };
@@ -2625,13 +2624,13 @@ struct ReadStmt {
   BOILERPLATE(ReadStmt);
   ReadStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
       std::list<IoControlSpec> &&cs, std::list<InputItem> &&its)
-    : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
-      items(std::move(its)) {}
-  std::optional<IoUnit> iounit;  // if first in controls without UNIT= &/or
-                                 // followed by untagged format/namelist
-  std::optional<Format> format;  // if second in controls without FMT=/NML=, or
-                                 // no (io-control-spec-list); might be
-                                 // an untagged namelist group name
+      : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
+        items(std::move(its)) {}
+  std::optional<IoUnit> iounit; // if first in controls without UNIT= &/or
+                                // followed by untagged format/namelist
+  std::optional<Format> format; // if second in controls without FMT=/NML=, or
+                                // no (io-control-spec-list); might be
+                                // an untagged namelist group name
   std::list<IoControlSpec> controls;
   std::list<InputItem> items;
 };
@@ -2647,12 +2646,12 @@ struct WriteStmt {
   BOILERPLATE(WriteStmt);
   WriteStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
       std::list<IoControlSpec> &&cs, std::list<OutputItem> &&its)
-    : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
-      items(std::move(its)) {}
-  std::optional<IoUnit> iounit;  // if first in controls without UNIT= &/or
-                                 // followed by untagged format/namelist
-  std::optional<Format> format;  // if second in controls without FMT=/NML=;
-                                 // might be an untagged namelist group, too
+      : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
+        items(std::move(its)) {}
+  std::optional<IoUnit> iounit; // if first in controls without UNIT= &/or
+                                // followed by untagged format/namelist
+  std::optional<Format> format; // if second in controls without FMT=/NML=;
+                                // might be an untagged namelist group, too
   std::list<IoControlSpec> controls;
   std::list<OutputItem> items;
 };
@@ -2947,10 +2946,10 @@ struct Only {
 // R1410 module-nature -> INTRINSIC | NON_INTRINSIC
 struct UseStmt {
   BOILERPLATE(UseStmt);
-  ENUM_CLASS(ModuleNature, Intrinsic, Non_Intrinsic)  // R1410
-  template<typename A>
+  ENUM_CLASS(ModuleNature, Intrinsic, Non_Intrinsic) // R1410
+  template <typename A>
   UseStmt(std::optional<ModuleNature> &&nat, Name &&n, std::list<A> &&x)
-    : nature(std::move(nat)), moduleName(std::move(n)), u(std::move(x)) {}
+      : nature(std::move(nat)), moduleName(std::move(n)), u(std::move(x)) {}
   std::optional<ModuleNature> nature;
   Name moduleName;
   std::variant<std::list<Rename>, std::list<Only>> u;
@@ -2998,9 +2997,9 @@ struct PrefixSpec {
 struct Suffix {
   BOILERPLATE(Suffix);
   Suffix(LanguageBindingSpec &&lbs, std::optional<Name> &&rn)
-    : binding(std::move(lbs)), resultName(std::move(rn)) {}
+      : binding(std::move(lbs)), resultName(std::move(rn)) {}
   Suffix(Name &&rn, std::optional<LanguageBindingSpec> &&lbs)
-    : binding(std::move(lbs)), resultName(std::move(rn)) {}
+      : binding(std::move(lbs)), resultName(std::move(rn)) {}
   std::optional<LanguageBindingSpec> binding;
   std::optional<Name> resultName;
 };
@@ -3103,8 +3102,8 @@ WRAPPER_CLASS(AltReturnSpec, Label);
 //         expr | variable | procedure-name | proc-component-ref |
 //         alt-return-spec
 struct ActualArg {
-  WRAPPER_CLASS(PercentRef, Variable);  // %REF(v) extension
-  WRAPPER_CLASS(PercentVal, Expr);  // %VAL(x) extension
+  WRAPPER_CLASS(PercentRef, Variable); // %REF(v) extension
+  WRAPPER_CLASS(PercentVal, Expr); // %VAL(x) extension
   UNION_CLASS_BOILERPLATE(ActualArg);
   ActualArg(Expr &&x) : u{common::Indirection<Expr>(std::move(x))} {}
   std::variant<common::Indirection<Expr>, AltReturnSpec, PercentRef, PercentVal>
@@ -3136,7 +3135,7 @@ struct CallStmt {
   WRAPPER_CLASS_BOILERPLATE(CallStmt, Call);
   mutable std::unique_ptr<evaluate::ProcedureRef,
       common::Deleter<evaluate::ProcedureRef>>
-      typedCall;  // filled by semantics
+      typedCall; // filled by semantics
 };
 
 // R1529 function-subprogram ->
@@ -3371,7 +3370,7 @@ struct OmpLinearClause {
     BOILERPLATE(WithModifier);
     WithModifier(OmpLinearModifier &&m, std::list<Name> &&n,
         std::optional<ScalarIntConstantExpr> &&s)
-      : modifier(std::move(m)), names(std::move(n)), step(std::move(s)) {}
+        : modifier(std::move(m)), names(std::move(n)), step(std::move(s)) {}
     OmpLinearModifier modifier;
     std::list<Name> names;
     std::optional<ScalarIntConstantExpr> step;
@@ -3380,7 +3379,7 @@ struct OmpLinearClause {
     BOILERPLATE(WithoutModifier);
     WithoutModifier(
         std::list<Name> &&n, std::optional<ScalarIntConstantExpr> &&s)
-      : names(std::move(n)), step(std::move(s)) {}
+        : names(std::move(n)), step(std::move(s)) {}
     std::list<Name> names;
     std::optional<ScalarIntConstantExpr> step;
   };
@@ -3774,7 +3773,7 @@ struct OpenMPBlockConstruct {
 struct OpenMPLoopConstruct {
   TUPLE_CLASS_BOILERPLATE(OpenMPLoopConstruct);
   OpenMPLoopConstruct(OmpBeginLoopDirective &&a)
-    : t({std::move(a), std::nullopt, std::nullopt}) {}
+      : t({std::move(a), std::nullopt, std::nullopt}) {}
   std::tuple<OmpBeginLoopDirective, std::optional<DoConstruct>,
       std::optional<OmpEndLoopDirective>>
       t;
@@ -3787,5 +3786,5 @@ struct OpenMPConstruct {
       OpenMPCriticalConstruct>
       u;
 };
-}
-#endif  // FORTRAN_PARSER_PARSE_TREE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PARSE_TREE_H_
diff --git a/flang/include/flang/Parser/parsing.h b/flang/include/flang/Parser/parsing.h
index 0d32afee38c2..9b84705d8151 100644
--- a/flang/include/flang/Parser/parsing.h
+++ b/flang/include/flang/Parser/parsing.h
@@ -56,8 +56,8 @@ public:
   void Parse(llvm::raw_ostream &debugOutput);
   void ClearLog();
 
-  void EmitMessage(llvm::raw_ostream &o, const char *at, const std::string &message,
-      bool echoSourceLine = false) const {
+  void EmitMessage(llvm::raw_ostream &o, const char *at,
+      const std::string &message, bool echoSourceLine = false) const {
     cooked_.allSources().EmitMessage(
         o, cooked_.GetProvenanceRange(CharBlock(at)), message, echoSourceLine);
   }
@@ -73,5 +73,5 @@ private:
   std::optional<Program> parseTree_;
   ParsingLog log_;
 };
-}
-#endif  // FORTRAN_PARSER_PARSING_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PARSING_H_
diff --git a/flang/include/flang/Parser/provenance.h b/flang/include/flang/Parser/provenance.h
index 2ed00d416b64..b543cd7d7b4e 100644
--- a/flang/include/flang/Parser/provenance.h
+++ b/flang/include/flang/Parser/provenance.h
@@ -168,8 +168,8 @@ public:
       Provenance, std::size_t *offset = nullptr) const;
   std::optional<SourcePosition> GetSourcePosition(Provenance) const;
   std::optional<ProvenanceRange> GetFirstFileProvenance() const;
-  std::string GetPath(Provenance) const;  // __FILE__
-  int GetLineNumber(Provenance) const;  // __LINE__
+  std::string GetPath(Provenance) const; // __FILE__
+  int GetLineNumber(Provenance) const; // __LINE__
   Provenance CompilerInsertionProvenance(char ch);
   Provenance CompilerInsertionProvenance(const char *, std::size_t);
   ProvenanceRange IntersectionWithSourceFiles(ProvenanceRange) const;
@@ -256,17 +256,17 @@ public:
   }
 
   std::size_t BufferedBytes() const;
-  void Marshal();  // marshals text into one contiguous block
+  void Marshal(); // marshals text into one contiguous block
   void CompileProvenanceRangeToOffsetMappings();
   std::string AcquireData() { return std::move(data_); }
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   AllSources &allSources_;
-  CharBuffer buffer_;  // before Marshal()
-  std::string data_;  // all of it, prescanned and preprocessed
+  CharBuffer buffer_; // before Marshal()
+  std::string data_; // all of it, prescanned and preprocessed
   OffsetToProvenanceMappings provenanceMap_;
   ProvenanceRangeToOffsetMappings invertedMap_;
 };
-}
-#endif  // FORTRAN_PARSER_PROVENANCE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PROVENANCE_H_
diff --git a/flang/include/flang/Parser/source.h b/flang/include/flang/Parser/source.h
index 4c5be0f62c0c..e0d1a5308fdf 100644
--- a/flang/include/flang/Parser/source.h
+++ b/flang/include/flang/Parser/source.h
@@ -15,11 +15,11 @@
 //  - A Unicode byte order mark is recognized if present.
 
 #include "characters.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include <cstddef>
 #include <string>
 #include <utility>
 #include <vector>
-#include "llvm/Support/MemoryBuffer.h"
 
 namespace llvm {
 class raw_ostream;
@@ -43,7 +43,9 @@ public:
   explicit SourceFile(Encoding e) : encoding_{e} {}
   ~SourceFile();
   std::string path() const { return path_; }
-  llvm::ArrayRef<char> content() const { return buf_->getBuffer().slice(bom_end_, buf_end_ - bom_end_); }
+  llvm::ArrayRef<char> content() const {
+    return buf_->getBuffer().slice(bom_end_, buf_end_ - bom_end_);
+  }
   std::size_t bytes() const { return content().size(); }
   std::size_t lines() const { return lineStart_.size(); }
   Encoding encoding() const { return encoding_; }
@@ -64,9 +66,9 @@ private:
   std::string path_;
   std::unique_ptr<llvm::WritableMemoryBuffer> buf_;
   std::vector<std::size_t> lineStart_;
-  std::size_t bom_end_ {0};
+  std::size_t bom_end_{0};
   std::size_t buf_end_;
   Encoding encoding_;
 };
-}
-#endif  // FORTRAN_PARSER_SOURCE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_SOURCE_H_
diff --git a/flang/include/flang/Parser/tools.h b/flang/include/flang/Parser/tools.h
index 9112cc4a4886..426222b7f7dc 100644
--- a/flang/include/flang/Parser/tools.h
+++ b/flang/include/flang/Parser/tools.h
@@ -34,7 +34,7 @@ const Name &GetLastName(const AllocateObject &);
 // wrapped in a struct to avoid prototypes.
 struct UnwrapperHelper {
 
-  template<typename A, typename B> static const A *Unwrap(B *p) {
+  template <typename A, typename B> static const A *Unwrap(B *p) {
     if (p) {
       return Unwrap<A>(*p);
     } else {
@@ -42,17 +42,17 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B, bool COPY>
+  template <typename A, typename B, bool COPY>
   static const A *Unwrap(const common::Indirection<B, COPY> &x) {
     return Unwrap<A>(x.value());
   }
 
-  template<typename A, typename... Bs>
+  template <typename A, typename... Bs>
   static const A *Unwrap(const std::variant<Bs...> &x) {
     return std::visit([](const auto &y) { return Unwrap<A>(y); }, x);
   }
 
-  template<typename A, typename B>
+  template <typename A, typename B>
   static const A *Unwrap(const std::optional<B> &o) {
     if (o) {
       return Unwrap<A>(*o);
@@ -61,7 +61,7 @@ struct UnwrapperHelper {
     }
   }
 
-  template<typename A, typename B> static const A *Unwrap(B &x) {
+  template <typename A, typename B> static const A *Unwrap(B &x) {
     if constexpr (std::is_same_v<std::decay_t<A>, std::decay_t<B>>) {
       return &x;
     } else if constexpr (ConstraintTrait<B>) {
@@ -76,10 +76,10 @@ struct UnwrapperHelper {
   }
 };
 
-template<typename A, typename B> const A *Unwrap(const B &x) {
+template <typename A, typename B> const A *Unwrap(const B &x) {
   return UnwrapperHelper::Unwrap<A>(x);
 }
-template<typename A, typename B> A *Unwrap(B &x) {
+template <typename A, typename B> A *Unwrap(B &x) {
   return const_cast<A *>(Unwrap<A, B>(const_cast<const B &>(x)));
 }
 
@@ -87,5 +87,5 @@ template<typename A, typename B> A *Unwrap(B &x) {
 const CoindexedNamedObject *GetCoindexedNamedObject(const AllocateObject &);
 const CoindexedNamedObject *GetCoindexedNamedObject(const DataRef &);
 
-}
-#endif  // FORTRAN_PARSER_TOOLS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_TOOLS_H_
diff --git a/flang/include/flang/Parser/unparse.h b/flang/include/flang/Parser/unparse.h
index 0c7745809f39..cc79294b909d 100644
--- a/flang/include/flang/Parser/unparse.h
+++ b/flang/include/flang/Parser/unparse.h
@@ -22,7 +22,7 @@ namespace Fortran::evaluate {
 struct GenericExprWrapper;
 struct GenericAssignmentWrapper;
 class ProcedureRef;
-}
+} // namespace Fortran::evaluate
 
 namespace Fortran::parser {
 
@@ -48,6 +48,6 @@ void Unparse(llvm::raw_ostream &out, const Program &program,
     Encoding encoding = Encoding::UTF_8, bool capitalizeKeywords = true,
     bool backslashEscapes = true, preStatementType *preStatement = nullptr,
     AnalyzedObjectsAsFortran * = nullptr);
-}
+} // namespace Fortran::parser
 
 #endif
diff --git a/flang/include/flang/Parser/user-state.h b/flang/include/flang/Parser/user-state.h
index cc5466568ecb..75757d2f305a 100644
--- a/flang/include/flang/Parser/user-state.h
+++ b/flang/include/flang/Parser/user-state.h
@@ -30,12 +30,12 @@ class CookedSource;
 class ParsingLog;
 class ParseState;
 
-class Success {};  // for when one must return something that's present
+class Success {}; // for when one must return something that's present
 
 class UserState {
 public:
   UserState(const CookedSource &cooked, common::LanguageFeatureControl features)
-    : cooked_{cooked}, features_{features} {}
+      : cooked_{cooked}, features_{features} {}
 
   const CookedSource &cooked() const { return cooked_; }
   const common::LanguageFeatureControl &features() const { return features_; }
@@ -139,5 +139,5 @@ struct StructureComponents {
   using resultType = DataComponentDefStmt;
   static std::optional<DataComponentDefStmt> Parse(ParseState &);
 };
-}
-#endif  // FORTRAN_PARSER_USER_STATE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_USER_STATE_H_
diff --git a/flang/include/flang/Semantics/attr.h b/flang/include/flang/Semantics/attr.h
index b8a8fec69aff..76fab5e0c904 100644
--- a/flang/include/flang/Semantics/attr.h
+++ b/flang/include/flang/Semantics/attr.h
@@ -50,5 +50,5 @@ std::string AttrToString(Attr attr);
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &o, Attr attr);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const Attrs &attrs);
-}
-#endif  // FORTRAN_SEMANTICS_ATTR_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_ATTR_H_
diff --git a/flang/include/flang/Semantics/expression.h b/flang/include/flang/Semantics/expression.h
index 77ead117f345..3e5c053756b8 100644
--- a/flang/include/flang/Semantics/expression.h
+++ b/flang/include/flang/Semantics/expression.h
@@ -29,8 +29,8 @@ using namespace Fortran::parser::literals;
 
 namespace Fortran::parser {
 struct SourceLocationFindingVisitor {
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {}
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
   bool Pre(const Expr &x) {
     source = x.source;
     return false;
@@ -51,7 +51,7 @@ struct SourceLocationFindingVisitor {
     source = x.source;
     return false;
   }
-  template<typename A> bool Pre(const UnlabeledStatement<A> &stmt) {
+  template <typename A> bool Pre(const UnlabeledStatement<A> &stmt) {
     source = stmt.source;
     return false;
   }
@@ -60,12 +60,12 @@ struct SourceLocationFindingVisitor {
   CharBlock source;
 };
 
-template<typename A> CharBlock FindSourceLocation(const A &x) {
+template <typename A> CharBlock FindSourceLocation(const A &x) {
   SourceLocationFindingVisitor visitor;
   Walk(x, visitor);
   return visitor.source;
 }
-}
+} // namespace Fortran::parser
 
 using namespace Fortran::parser::literals;
 
@@ -89,10 +89,10 @@ struct SetExprHelper {
   }
   void Set(const parser::Expr &x) { Set(x.typedExpr); }
   void Set(const parser::Variable &x) { Set(x.typedExpr); }
-  template<typename T> void Set(const common::Indirection<T> &x) {
+  template <typename T> void Set(const common::Indirection<T> &x) {
     Set(x.value());
   }
-  template<typename T> void Set(const T &x) {
+  template <typename T> void Set(const T &x) {
     if constexpr (ConstraintTrait<T>) {
       Set(x.thing);
     } else if constexpr (WrapperTrait<T>) {
@@ -103,11 +103,11 @@ struct SetExprHelper {
   GenericExprWrapper expr_;
 };
 
-template<typename T> void ResetExpr(const T &x) {
+template <typename T> void ResetExpr(const T &x) {
   SetExprHelper{GenericExprWrapper{/* error indicator */}}.Set(x);
 }
 
-template<typename T> void SetExpr(const T &x, Expr<SomeType> &&expr) {
+template <typename T> void SetExpr(const T &x, Expr<SomeType> &&expr) {
   SetExprHelper{GenericExprWrapper{std::move(expr)}}.Set(x);
 }
 
@@ -117,7 +117,7 @@ public:
 
   explicit ExpressionAnalyzer(semantics::SemanticsContext &sc) : context_{sc} {}
   ExpressionAnalyzer(semantics::SemanticsContext &sc, FoldingContext &fc)
-    : context_{sc}, foldingContext_{fc} {}
+      : context_{sc}, foldingContext_{fc} {}
   ExpressionAnalyzer(ExpressionAnalyzer &) = default;
 
   semantics::SemanticsContext &context() const { return context_; }
@@ -128,11 +128,11 @@ public:
     return foldingContext_.messages();
   }
 
-  template<typename... A> parser::Message *Say(A &&... args) {
+  template <typename... A> parser::Message *Say(A &&... args) {
     return GetContextualMessages().Say(std::forward<A>(args)...);
   }
 
-  template<typename T, typename... A>
+  template <typename T, typename... A>
   parser::Message *SayAt(const T &parsed, A &&... args) {
     return Say(parser::FindSourceLocation(parsed), std::forward<A>(args)...);
   }
@@ -156,10 +156,10 @@ public:
   MaybeExpr Analyze(const parser::Variable &);
   MaybeExpr Analyze(const parser::Designator &);
 
-  template<typename A> MaybeExpr Analyze(const common::Indirection<A> &x) {
+  template <typename A> MaybeExpr Analyze(const common::Indirection<A> &x) {
     return Analyze(x.value());
   }
-  template<typename A> MaybeExpr Analyze(const std::optional<A> &x) {
+  template <typename A> MaybeExpr Analyze(const std::optional<A> &x) {
     if (x) {
       return Analyze(*x);
     } else {
@@ -168,7 +168,7 @@ public:
   }
 
   // Implement constraint-checking wrappers from the Fortran grammar.
-  template<typename A> MaybeExpr Analyze(const parser::Scalar<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::Scalar<A> &x) {
     auto result{Analyze(x.thing)};
     if (result) {
       if (int rank{result->Rank()}; rank != 0) {
@@ -180,13 +180,13 @@ public:
     }
     return result;
   }
-  template<typename A> MaybeExpr Analyze(const parser::Constant<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::Constant<A> &x) {
     auto restorer{
         GetFoldingContext().messages().SetLocation(FindSourceLocation(x))};
     auto result{Analyze(x.thing)};
     if (result) {
       *result = Fold(std::move(*result));
-      if (!IsConstantExpr(*result)) {  //  C886, C887, C713
+      if (!IsConstantExpr(*result)) { //  C886, C887, C713
         SayAt(x, "Must be a constant value"_err_en_US);
         ResetExpr(x);
         return std::nullopt;
@@ -197,7 +197,7 @@ public:
     }
     return result;
   }
-  template<typename A> MaybeExpr Analyze(const parser::Integer<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::Integer<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(
             parser::FindSourceLocation(x), result, TypeCategory::Integer)) {
@@ -206,7 +206,7 @@ public:
     }
     return result;
   }
-  template<typename A> MaybeExpr Analyze(const parser::Logical<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::Logical<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(
             parser::FindSourceLocation(x), result, TypeCategory::Logical)) {
@@ -215,7 +215,7 @@ public:
     }
     return result;
   }
-  template<typename A> MaybeExpr Analyze(const parser::DefaultChar<A> &x) {
+  template <typename A> MaybeExpr Analyze(const parser::DefaultChar<A> &x) {
     auto result{Analyze(x.thing)};
     if (!EnforceTypeConstraint(parser::FindSourceLocation(x), result,
             TypeCategory::Character, true /* default kind */)) {
@@ -283,10 +283,10 @@ private:
   MaybeExpr Analyze(const parser::Expr::EQV &);
   MaybeExpr Analyze(const parser::Expr::NEQV &);
   MaybeExpr Analyze(const parser::Expr::DefinedBinary &);
-  template<typename A> MaybeExpr Analyze(const A &x) {
-    return Analyze(x.u);  // default case
+  template <typename A> MaybeExpr Analyze(const A &x) {
+    return Analyze(x.u); // default case
   }
-  template<typename... As> MaybeExpr Analyze(const std::variant<As...> &u) {
+  template <typename... As> MaybeExpr Analyze(const std::variant<As...> &u) {
     return std::visit(
         [&](const auto &x) {
           using Ty = std::decay_t<decltype(x)>;
@@ -321,8 +321,8 @@ private:
   // Analysis subroutines
   int AnalyzeKindParam(
       const std::optional<parser::KindParam> &, int defaultKind);
-  template<typename PARSED> MaybeExpr ExprOrVariable(const PARSED &);
-  template<typename PARSED> MaybeExpr IntLiteralConstant(const PARSED &);
+  template <typename PARSED> MaybeExpr ExprOrVariable(const PARSED &);
+  template <typename PARSED> MaybeExpr IntLiteralConstant(const PARSED &);
   MaybeExpr AnalyzeString(std::string &&, int kind);
   std::optional<Expr<SubscriptInteger>> AsSubscript(MaybeExpr &&);
   std::optional<Expr<SubscriptInteger>> TripletPart(
@@ -370,13 +370,13 @@ private:
   MaybeExpr MakeFunctionRef(
       parser::CharBlock, ProcedureDesignator &&, ActualArguments &&);
   MaybeExpr MakeFunctionRef(parser::CharBlock intrinsic, ActualArguments &&);
-  template<typename T> T Fold(T &&expr) {
+  template <typename T> T Fold(T &&expr) {
     return evaluate::Fold(foldingContext_, std::move(expr));
   }
 
   semantics::SemanticsContext &context_;
   FoldingContext &foldingContext_{context_.foldingContext()};
-  std::map<parser::CharBlock, int> acImpliedDos_;  // values are INTEGER kinds
+  std::map<parser::CharBlock, int> acImpliedDos_; // values are INTEGER kinds
   bool fatalErrors_{false};
   friend class ArgumentAnalyzer;
 };
@@ -385,12 +385,12 @@ inline bool AreConformable(int leftRank, int rightRank) {
   return leftRank == 0 || rightRank == 0 || leftRank == rightRank;
 }
 
-template<typename L, typename R>
+template <typename L, typename R>
 bool AreConformable(const L &left, const R &right) {
   return AreConformable(left.Rank(), right.Rank());
 }
 
-template<typename L, typename R>
+template <typename L, typename R>
 void ConformabilityCheck(
     parser::ContextualMessages &context, const L &left, const R &right) {
   if (!AreConformable(left, right)) {
@@ -398,12 +398,12 @@ void ConformabilityCheck(
         left.Rank(), right.Rank());
   }
 }
-}  // namespace Fortran::evaluate
+} // namespace Fortran::evaluate
 
 namespace Fortran::semantics {
 
 // Semantic analysis of one expression, variable, or designator.
-template<typename A>
+template <typename A>
 std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
     SemanticsContext &context, const A &expr) {
   return evaluate::ExpressionAnalyzer{context}.Analyze(expr);
@@ -426,8 +426,8 @@ class ExprChecker {
 public:
   explicit ExprChecker(SemanticsContext &);
 
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {}
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
   bool Walk(const parser::Program &);
 
   bool Pre(const parser::Expr &x) {
@@ -452,23 +452,23 @@ public:
   }
   bool Pre(const parser::DataStmtConstant &);
 
-  template<typename A> bool Pre(const parser::Scalar<A> &x) {
+  template <typename A> bool Pre(const parser::Scalar<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
-  template<typename A> bool Pre(const parser::Constant<A> &x) {
+  template <typename A> bool Pre(const parser::Constant<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
-  template<typename A> bool Pre(const parser::Integer<A> &x) {
+  template <typename A> bool Pre(const parser::Integer<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
-  template<typename A> bool Pre(const parser::Logical<A> &x) {
+  template <typename A> bool Pre(const parser::Logical<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
-  template<typename A> bool Pre(const parser::DefaultChar<A> &x) {
+  template <typename A> bool Pre(const parser::DefaultChar<A> &x) {
     AnalyzeExpr(context_, x);
     return false;
   }
@@ -476,5 +476,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}  // namespace Fortran::semantics
-#endif  // FORTRAN_SEMANTICS_EXPRESSION_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_EXPRESSION_H_
diff --git a/flang/include/flang/Semantics/scope.h b/flang/include/flang/Semantics/scope.h
index f7cef58bdcd5..b55cf509c78d 100644
--- a/flang/include/flang/Semantics/scope.h
+++ b/flang/include/flang/Semantics/scope.h
@@ -39,13 +39,14 @@ class SemanticsContext;
 struct EquivalenceObject {
   EquivalenceObject(Symbol &symbol, std::vector<ConstantSubscript> subscripts,
       std::optional<ConstantSubscript> substringStart)
-    : symbol{symbol}, subscripts{subscripts}, substringStart{substringStart} {}
+      : symbol{symbol}, subscripts{subscripts}, substringStart{substringStart} {
+  }
   bool operator==(const EquivalenceObject &) const;
   bool operator<(const EquivalenceObject &) const;
   std::string AsFortran() const;
 
   Symbol &symbol;
-  std::vector<ConstantSubscript> subscripts;  // for array elem
+  std::vector<ConstantSubscript> subscripts; // for array elem
   std::optional<ConstantSubscript> substringStart;
 };
 using EquivalenceSet = std::vector<EquivalenceObject>;
@@ -61,7 +62,7 @@ public:
   // Create the Global scope -- the root of the scope tree
   Scope() : Scope{*this, Kind::Global, nullptr} {}
   Scope(Scope &parent, Kind kind, Symbol *symbol)
-    : parent_{parent}, kind_{kind}, symbol_{symbol} {
+      : parent_{parent}, kind_{kind}, symbol_{symbol} {
     if (symbol) {
       symbol->set_scope(this);
     }
@@ -81,7 +82,7 @@ public:
   }
   Kind kind() const { return kind_; }
   bool IsGlobal() const { return kind_ == Kind::Global; }
-  bool IsModule() const;  // only module, not submodule
+  bool IsModule() const; // only module, not submodule
   bool IsSubmodule() const;
   bool IsDerivedType() const { return kind_ == Kind::DerivedType; }
   bool IsParameterizedDerivedType() const;
@@ -127,13 +128,13 @@ public:
     return try_emplace(name, attrs, UnknownDetails());
   }
   /// Make a Symbol with provided details.
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<std::pair<iterator, bool>, D> try_emplace(
       const SourceName &name, D &&details) {
     return try_emplace(name, Attrs(), std::move(details));
   }
   /// Make a Symbol with attrs and details
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<std::pair<iterator, bool>, D> try_emplace(
       const SourceName &name, Attrs attrs, D &&details) {
     Symbol &symbol{MakeSymbol(name, attrs, std::move(details))};
@@ -153,7 +154,7 @@ public:
   Symbol *FindCommonBlock(const SourceName &);
 
   /// Make a Symbol but don't add it to the scope.
-  template<typename D>
+  template <typename D>
   common::IfNoLvalue<Symbol &, D> MakeSymbol(
       const SourceName &name, Attrs attrs, D &&details) {
     return allSymbols.Make(*this, name, attrs, std::move(details));
@@ -213,10 +214,10 @@ public:
   void InstantiateDerivedTypes(SemanticsContext &);
 
 private:
-  Scope &parent_;  // this is enclosing scope, not extended derived type base
+  Scope &parent_; // this is enclosing scope, not extended derived type base
   const Kind kind_;
   parser::CharBlock sourceRange_;
-  Symbol *const symbol_;  // if not null, symbol_->scope() == this
+  Symbol *const symbol_; // if not null, symbol_->scope() == this
   std::list<Scope> children_;
   mapType symbols_;
   mapType commonBlocks_;
@@ -227,7 +228,7 @@ private:
   std::string chars_;
   std::optional<ImportKind> importKind_;
   std::set<SourceName> importNames_;
-  DerivedTypeSpec *derivedTypeSpec_{nullptr};  // dTS->scope() == this
+  DerivedTypeSpec *derivedTypeSpec_{nullptr}; // dTS->scope() == this
   // When additional data members are added to Scope, remember to
   // copy them, if appropriate, in InstantiateDerivedType().
 
@@ -240,5 +241,5 @@ private:
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Scope &);
 };
-}
-#endif  // FORTRAN_SEMANTICS_SCOPE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_SCOPE_H_
diff --git a/flang/include/flang/Semantics/semantics.h b/flang/include/flang/Semantics/semantics.h
index 8f789e977c1d..0c60a98cd562 100644
--- a/flang/include/flang/Semantics/semantics.h
+++ b/flang/include/flang/Semantics/semantics.h
@@ -43,7 +43,7 @@ struct SelectRankConstruct;
 struct SelectTypeConstruct;
 struct Variable;
 struct WhereConstruct;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -133,18 +133,18 @@ public:
   bool HasError(const parser::Name &);
   void SetError(Symbol &, bool = true);
 
-  template<typename... A> parser::Message &Say(A &&... args) {
+  template <typename... A> parser::Message &Say(A &&... args) {
     CHECK(location_);
     return messages_.Say(*location_, std::forward<A>(args)...);
   }
-  template<typename... A>
+  template <typename... A>
   parser::Message &Say(parser::CharBlock at, A &&... args) {
     return messages_.Say(at, std::forward<A>(args)...);
   }
   parser::Message &Say(parser::Message &&msg) {
     return messages_.Say(std::move(msg));
   }
-  template<typename... A>
+  template <typename... A>
   void SayWithDecl(const Symbol &symbol, const parser::CharBlock &at,
       parser::MessageFixedText &&msg, A &&... args) {
     auto &message{Say(at, std::move(msg), args...)};
@@ -155,7 +155,7 @@ public:
   Scope &FindScope(parser::CharBlock);
 
   const ConstructStack &constructStack() const { return constructStack_; }
-  template<typename N> void PushConstruct(const N &node) {
+  template <typename N> void PushConstruct(const N &node) {
     constructStack_.emplace_back(&node);
   }
   void PopConstruct();
@@ -202,7 +202,7 @@ class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,
       parser::CookedSource &cooked, bool debugModuleWriter = false)
-    : context_{context}, program_{program}, cooked_{cooked} {
+      : context_{context}, program_{program}, cooked_{cooked} {
     context.set_debugModuleWriter(debugModuleWriter);
     context.globalScope().AddSourceRange(parser::CharBlock{cooked.data()});
   }
@@ -225,8 +225,8 @@ private:
 
 // Base class for semantics checkers.
 struct BaseChecker {
-  template<typename N> void Enter(const N &) {}
-  template<typename N> void Leave(const N &) {}
+  template <typename N> void Enter(const N &) {}
+  template <typename N> void Leave(const N &) {}
 };
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/flang/include/flang/Semantics/symbol.h b/flang/include/flang/Semantics/symbol.h
index 3eaa95f08e2a..947535c59a7e 100644
--- a/flang/include/flang/Semantics/symbol.h
+++ b/flang/include/flang/Semantics/symbol.h
@@ -42,8 +42,8 @@ public:
   ModuleDetails(bool isSubmodule = false) : isSubmodule_{isSubmodule} {}
   bool isSubmodule() const { return isSubmodule_; }
   const Scope *scope() const { return scope_; }
-  const Scope *ancestor() const;  // for submodule; nullptr for module
-  const Scope *parent() const;  // for submodule; nullptr for module
+  const Scope *ancestor() const; // for submodule; nullptr for module
+  const Scope *parent() const; // for submodule; nullptr for module
   void set_scope(const Scope *);
 
 private:
@@ -81,11 +81,11 @@ public:
   void set_stmtFunction(SomeExpr &&expr) { stmtFunction_ = std::move(expr); }
 
 private:
-  bool isInterface_{false};  // true if this represents an interface-body
+  bool isInterface_{false}; // true if this represents an interface-body
   MaybeExpr bindName_;
-  std::vector<Symbol *> dummyArgs_;  // nullptr -> alternate return indicator
+  std::vector<Symbol *> dummyArgs_; // nullptr -> alternate return indicator
   Symbol *result_{nullptr};
-  Scope *entryScope_{nullptr};  // if ENTRY, points to subprogram's scope
+  Scope *entryScope_{nullptr}; // if ENTRY, points to subprogram's scope
   MaybeExpr stmtFunction_;
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const SubprogramDetails &);
@@ -102,7 +102,7 @@ ENUM_CLASS(SubprogramKind, Module, Internal)
 class SubprogramNameDetails {
 public:
   SubprogramNameDetails(SubprogramKind kind, ProgramTree &node)
-    : kind_{kind}, node_{node} {}
+      : kind_{kind}, node_{node} {}
   SubprogramNameDetails() = delete;
   SubprogramKind kind() const { return kind_; }
   ProgramTree &node() const { return *node_; }
@@ -186,7 +186,7 @@ private:
   bool initWasValidated_{false};
   ArraySpec shape_;
   ArraySpec coshape_;
-  const Symbol *commonBlock_{nullptr};  // common block this object is in
+  const Symbol *commonBlock_{nullptr}; // common block this object is in
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const ObjectEntityDetails &);
 };
@@ -282,7 +282,7 @@ public:
   const Symbol &symbol() const { return symbol_; }
 
 private:
-  SymbolRef symbol_;  // procedure bound to; may be forward
+  SymbolRef symbol_; // procedure bound to; may be forward
 };
 
 class NamelistDetails {
@@ -309,7 +309,7 @@ private:
   MaybeExpr bindName_;
 };
 
-class FinalProcDetails {};  // TODO
+class FinalProcDetails {}; // TODO
 
 class MiscDetails {
 public:
@@ -346,7 +346,7 @@ private:
 class UseDetails {
 public:
   UseDetails(const SourceName &location, const Symbol &symbol)
-    : location_{location}, symbol_{symbol} {}
+      : location_{location}, symbol_{symbol} {}
   const SourceName &location() const { return location_; }
   const Symbol &symbol() const { return symbol_; }
   const Symbol &module() const;
@@ -383,10 +383,10 @@ private:
 // defined assignment, intrinsic operator, or defined I/O.
 struct GenericKind {
   ENUM_CLASS(OtherKind, Name, DefinedOp, Assignment, Concat)
-  ENUM_CLASS(DefinedIo,  // defined io
+  ENUM_CLASS(DefinedIo, // defined io
       ReadFormatted, ReadUnformatted, WriteFormatted, WriteUnformatted)
   GenericKind() : u{OtherKind::Name} {}
-  template<typename T> GenericKind(const T &x) { u = x; }
+  template <typename T> GenericKind(const T &x) { u = x; }
   bool IsName() const { return Is(OtherKind::Name); }
   bool IsAssignment() const { return Is(OtherKind::Assignment); }
   bool IsDefinedOperator() const { return Is(OtherKind::DefinedOp); }
@@ -398,7 +398,9 @@ struct GenericKind {
       u;
 
 private:
-  template<typename T> bool Has() const { return std::holds_alternative<T>(u); }
+  template <typename T> bool Has() const {
+    return std::holds_alternative<T>(u);
+  }
   bool Is(OtherKind) const;
 };
 
@@ -463,17 +465,17 @@ std::string DetailsToString(const Details &);
 class Symbol {
 public:
   ENUM_CLASS(Flag,
-      Error,  // an error has been reported on this symbol
-      Function,  // symbol is a function
-      Subroutine,  // symbol is a subroutine
-      Implicit,  // symbol is implicitly typed
-      ModFile,  // symbol came from .mod file
-      ParentComp,  // symbol is the "parent component" of an extended type
+      Error, // an error has been reported on this symbol
+      Function, // symbol is a function
+      Subroutine, // symbol is a subroutine
+      Implicit, // symbol is implicitly typed
+      ModFile, // symbol came from .mod file
+      ParentComp, // symbol is the "parent component" of an extended type
       CrayPointer, CrayPointee,
-      LocalityLocal,  // named in LOCAL locality-spec
-      LocalityLocalInit,  // named in LOCAL_INIT locality-spec
-      LocalityShared,  // named in SHARED locality-spec
-      InDataStmt,  // initialized in a DATA statement
+      LocalityLocal, // named in LOCAL locality-spec
+      LocalityLocalInit, // named in LOCAL_INIT locality-spec
+      LocalityShared, // named in SHARED locality-spec
+      InDataStmt, // initialized in a DATA statement
 
       // OpenMP data-sharing attribute
       OmpShared, OmpPrivate, OmpLinear, OmpFirstPrivate, OmpLastPrivate,
@@ -501,21 +503,21 @@ public:
   void ReplaceName(const SourceName &);
 
   // Does symbol have this type of details?
-  template<typename D> bool has() const {
+  template <typename D> bool has() const {
     return std::holds_alternative<D>(details_);
   }
 
   // Return a non-owning pointer to details if it is type D, else nullptr.
-  template<typename D> D *detailsIf() { return std::get_if<D>(&details_); }
-  template<typename D> const D *detailsIf() const {
+  template <typename D> D *detailsIf() { return std::get_if<D>(&details_); }
+  template <typename D> const D *detailsIf() const {
     return std::get_if<D>(&details_);
   }
 
   // Return a reference to the details which must be of type D.
-  template<typename D> D &get() {
+  template <typename D> D &get() {
     return const_cast<D &>(const_cast<const Symbol *>(this)->get<D>());
   }
-  template<typename D> const D &get() const {
+  template <typename D> const D &get() const {
     const auto *p{detailsIf<D>()};
     CHECK(p);
     return *p;
@@ -582,24 +584,24 @@ public:
   bool IsSubprogram() const;
   bool IsFromModFile() const;
   bool HasExplicitInterface() const {
-    return std::visit(
-        common::visitors{
-            [](const SubprogramDetails &) { return true; },
-            [](const SubprogramNameDetails &) { return true; },
-            [&](const ProcEntityDetails &x) {
-              return attrs_.test(Attr::INTRINSIC) || x.HasExplicitInterface();
-            },
-            [](const ProcBindingDetails &x) {
-              return x.symbol().HasExplicitInterface();
-            },
-            [](const UseDetails &x) {
-              return x.symbol().HasExplicitInterface();
-            },
-            [](const HostAssocDetails &x) {
-              return x.symbol().HasExplicitInterface();
-            },
-            [](const auto &) { return false; },
-        },
+    return std::visit(common::visitors{
+                          [](const SubprogramDetails &) { return true; },
+                          [](const SubprogramNameDetails &) { return true; },
+                          [&](const ProcEntityDetails &x) {
+                            return attrs_.test(Attr::INTRINSIC) ||
+                                x.HasExplicitInterface();
+                          },
+                          [](const ProcBindingDetails &x) {
+                            return x.symbol().HasExplicitInterface();
+                          },
+                          [](const UseDetails &x) {
+                            return x.symbol().HasExplicitInterface();
+                          },
+                          [](const HostAssocDetails &x) {
+                            return x.symbol().HasExplicitInterface();
+                          },
+                          [](const auto &) { return false; },
+                      },
         details_);
   }
 
@@ -668,7 +670,7 @@ private:
   Scope *scope_{nullptr};
   Details details_;
 
-  Symbol() {}  // only created in class Symbols
+  Symbol() {} // only created in class Symbols
   const std::string GetDetailsName() const;
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Symbol &);
   friend llvm::raw_ostream &DumpForUnparse(
@@ -679,8 +681,8 @@ private:
   // can be overridden.
   const Symbol *GetParentComponent(const Scope * = nullptr) const;
 
-  template<std::size_t> friend class Symbols;
-  template<class, std::size_t> friend struct std::array;
+  template <std::size_t> friend class Symbols;
+  template <class, std::size_t> friend struct std::array;
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, Symbol::Flag);
@@ -688,7 +690,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &, Symbol::Flag);
 // Manage memory for all symbols. BLOCK_SIZE symbols at a time are allocated.
 // Make() returns a reference to the next available one. They are never
 // deleted.
-template<std::size_t BLOCK_SIZE> class Symbols {
+template <std::size_t BLOCK_SIZE> class Symbols {
 public:
   Symbol &Make(const Scope &owner, const SourceName &name, const Attrs &attrs,
       Details &&details) {
@@ -713,7 +715,7 @@ private:
     }
     Symbol &result = (*currBlock_)[nextIndex_];
     if (++nextIndex_ >= BLOCK_SIZE) {
-      nextIndex_ = 0;  // allocate a new block next time
+      nextIndex_ = 0; // allocate a new block next time
     }
     return result;
   }
@@ -733,5 +735,5 @@ inline bool ProcEntityDetails::HasExplicitInterface() const {
 inline bool operator<(SymbolRef x, SymbolRef y) { return *x < *y; }
 using SymbolSet = std::set<SymbolRef>;
 
-}
-#endif  // FORTRAN_SEMANTICS_SYMBOL_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_SYMBOL_H_
diff --git a/flang/include/flang/Semantics/tools.h b/flang/include/flang/Semantics/tools.h
index da752d136024..e6a3a2eb53f1 100644
--- a/flang/include/flang/Semantics/tools.h
+++ b/flang/include/flang/Semantics/tools.h
@@ -90,8 +90,8 @@ bool IsPureProcedure(const Scope &);
 bool IsBindCProcedure(const Symbol &);
 bool IsBindCProcedure(const Scope &);
 bool IsProcedure(const Symbol &);
-bool IsProcName(const Symbol &symbol);  // proc-name
-bool IsVariableName(const Symbol &symbol);  // variable-name
+bool IsProcName(const Symbol &symbol); // proc-name
+bool IsVariableName(const Symbol &symbol); // variable-name
 bool IsProcedurePointer(const Symbol &);
 bool IsFunctionResult(const Symbol &);
 bool IsFunctionResultWithSameNameAsFunction(const Symbol &);
@@ -211,12 +211,12 @@ const Symbol *FindSeparateModuleSubprogramInterface(const Symbol *);
 // diagnostic purposes if so.
 const Symbol *FindExternallyVisibleObject(const Symbol &, const Scope &);
 
-template<typename A>
+template <typename A>
 const Symbol *FindExternallyVisibleObject(const A &, const Scope &) {
-  return nullptr;  // default base case
+  return nullptr; // default base case
 }
 
-template<typename T>
+template <typename T>
 const Symbol *FindExternallyVisibleObject(
     const evaluate::Designator<T> &designator, const Scope &scope) {
   if (const Symbol * symbol{designator.GetBaseObject().symbol()}) {
@@ -229,7 +229,7 @@ const Symbol *FindExternallyVisibleObject(
   }
 }
 
-template<typename T>
+template <typename T>
 const Symbol *FindExternallyVisibleObject(
     const evaluate::Expr<T> &expr, const Scope &scope) {
   return std::visit(
@@ -247,13 +247,13 @@ bool ExprTypeKindIsDefault(
 struct GetExprHelper {
   const SomeExpr *Get(const parser::Expr &);
   const SomeExpr *Get(const parser::Variable &);
-  template<typename T> const SomeExpr *Get(const common::Indirection<T> &x) {
+  template <typename T> const SomeExpr *Get(const common::Indirection<T> &x) {
     return Get(x.value());
   }
-  template<typename T> const SomeExpr *Get(const std::optional<T> &x) {
+  template <typename T> const SomeExpr *Get(const std::optional<T> &x) {
     return x ? Get(*x) : nullptr;
   }
-  template<typename T> const SomeExpr *Get(const T &x) {
+  template <typename T> const SomeExpr *Get(const T &x) {
     if constexpr (ConstraintTrait<T>) {
       return Get(x.thing);
     } else if constexpr (WrapperTrait<T>) {
@@ -264,7 +264,7 @@ struct GetExprHelper {
   }
 };
 
-template<typename T> const SomeExpr *GetExpr(const T &x) {
+template <typename T> const SomeExpr *GetExpr(const T &x) {
   return GetExprHelper{}.Get(x);
 }
 
@@ -272,7 +272,7 @@ const evaluate::Assignment *GetAssignment(const parser::AssignmentStmt &);
 const evaluate::Assignment *GetAssignment(
     const parser::PointerAssignmentStmt &);
 
-template<typename T> std::optional<std::int64_t> GetIntValue(const T &x) {
+template <typename T> std::optional<std::int64_t> GetIntValue(const T &x) {
   if (const auto *expr{GetExpr(x)}) {
     return evaluate::ToInt64(*expr);
   } else {
@@ -280,7 +280,7 @@ template<typename T> std::optional<std::int64_t> GetIntValue(const T &x) {
   }
 }
 
-template<typename T> bool IsZero(const T &expr) {
+template <typename T> bool IsZero(const T &expr) {
   auto value{GetIntValue(expr)};
   return value && *value == 0;
 }
@@ -347,7 +347,7 @@ template<typename T> bool IsZero(const T &expr) {
 
 ENUM_CLASS(ComponentKind, Ordered, Direct, Ultimate, Potential, Scope)
 
-template<ComponentKind componentKind> class ComponentIterator {
+template <ComponentKind componentKind> class ComponentIterator {
 public:
   ComponentIterator(const DerivedTypeSpec &derived) : derived_{derived} {}
   class const_iterator {
@@ -404,7 +404,7 @@ public:
     class ComponentPathNode {
     public:
       explicit ComponentPathNode(const DerivedTypeSpec &derived)
-        : derived_{derived} {
+          : derived_{derived} {
         if constexpr (componentKind == ComponentKind::Scope) {
           const Scope &scope{DEREF(derived.scope())};
           nameIterator_ = scope.cbegin();
@@ -436,7 +436,7 @@ public:
       common::Reference<const DerivedTypeSpec> derived_;
       name_iterator nameEnd_;
       name_iterator nameIterator_;
-      const Symbol *component_{nullptr};  // until Increment()
+      const Symbol *component_{nullptr}; // until Increment()
       bool visited_{false};
       bool descended_{false};
     };
@@ -495,16 +495,16 @@ class LabelEnforce {
 public:
   LabelEnforce(SemanticsContext &context, std::set<parser::Label> &&labels,
       parser::CharBlock constructSourcePosition, const char *construct)
-    : context_{context}, labels_{labels},
-      constructSourcePosition_{constructSourcePosition}, construct_{construct} {
-  }
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> bool Pre(const parser::Statement<T> &statement) {
+      : context_{context}, labels_{labels},
+        constructSourcePosition_{constructSourcePosition}, construct_{
+                                                               construct} {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> bool Pre(const parser::Statement<T> &statement) {
     currentStatementSourcePosition_ = statement.source;
     return true;
   }
 
-  template<typename T> void Post(const T &) {}
+  template <typename T> void Post(const T &) {}
 
   void Post(const parser::GotoStmt &gotoStmt);
   void Post(const parser::ComputedGotoStmt &computedGotoStmt);
@@ -529,5 +529,5 @@ private:
       parser::CharBlock stmtLocation, parser::MessageFormattedText &&message,
       parser::CharBlock constructLocation);
 };
-}
-#endif  // FORTRAN_SEMANTICS_TOOLS_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_TOOLS_H_
diff --git a/flang/include/flang/Semantics/type.h b/flang/include/flang/Semantics/type.h
index f18114b1f380..00f38e2157f4 100644
--- a/flang/include/flang/Semantics/type.h
+++ b/flang/include/flang/Semantics/type.h
@@ -72,7 +72,7 @@ private:
   enum class Category { Explicit, Deferred, Assumed };
   Bound(Category category) : category_{category} {}
   Bound(Category category, MaybeSubscriptIntExpr &&expr)
-    : category_{category}, expr_{std::move(expr)} {}
+      : category_{category}, expr_{std::move(expr)} {}
   Category category_{Category::Explicit};
   MaybeSubscriptIntExpr expr_;
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Bound &);
@@ -107,7 +107,7 @@ public:
 private:
   enum class Category { Explicit, Deferred, Assumed };
   ParamValue(Category category, common::TypeParamAttr attr)
-    : category_{category}, attr_{attr} {}
+      : category_{category}, attr_{attr} {}
   Category category_{Category::Explicit};
   common::TypeParamAttr attr_{common::TypeParamAttr::Kind};
   MaybeIntExpr expr_;
@@ -130,13 +130,14 @@ protected:
 private:
   TypeCategory category_;
   KindExpr kind_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const IntrinsicTypeSpec &x);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &os, const IntrinsicTypeSpec &x);
 };
 
 class NumericTypeSpec : public IntrinsicTypeSpec {
 public:
   NumericTypeSpec(TypeCategory category, KindExpr &&kind)
-    : IntrinsicTypeSpec(category, std::move(kind)) {
+      : IntrinsicTypeSpec(category, std::move(kind)) {
     CHECK(common::IsNumericTypeCategory(category));
   }
 };
@@ -144,20 +145,21 @@ public:
 class LogicalTypeSpec : public IntrinsicTypeSpec {
 public:
   explicit LogicalTypeSpec(KindExpr &&kind)
-    : IntrinsicTypeSpec(TypeCategory::Logical, std::move(kind)) {}
+      : IntrinsicTypeSpec(TypeCategory::Logical, std::move(kind)) {}
 };
 
 class CharacterTypeSpec : public IntrinsicTypeSpec {
 public:
   CharacterTypeSpec(ParamValue &&length, KindExpr &&kind)
-    : IntrinsicTypeSpec(TypeCategory::Character, std::move(kind)),
-      length_{std::move(length)} {}
+      : IntrinsicTypeSpec(TypeCategory::Character, std::move(kind)),
+        length_{std::move(length)} {}
   const ParamValue &length() const { return length_; }
   std::string AsFortran() const;
 
 private:
   ParamValue length_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharacterTypeSpec &x);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &os, const CharacterTypeSpec &x);
 };
 
 class ShapeSpec {
@@ -224,7 +226,7 @@ struct ArraySpec : public std::vector<ShapeSpec> {
 
 private:
   // Check non-empty and predicate is true for each element.
-  template<typename P> bool CheckAll(P predicate) const {
+  template <typename P> bool CheckAll(P predicate) const {
     return !empty() && std::all_of(begin(), end(), predicate);
   }
 };
@@ -287,13 +289,14 @@ public:
 private:
   SourceName name_;
   const Symbol &typeSymbol_;
-  const Scope *scope_{nullptr};  // same as typeSymbol_.scope() unless PDT
+  const Scope *scope_{nullptr}; // same as typeSymbol_.scope() unless PDT
   bool cooked_{false};
   bool evaluated_{false};
   bool instantiated_{false};
   RawParameters rawParameters_;
   ParameterMapType parameters_;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DerivedTypeSpec &);
+  friend llvm::raw_ostream &operator<<(
+      llvm::raw_ostream &, const DerivedTypeSpec &);
 };
 
 class DeclTypeSpec {
@@ -351,18 +354,24 @@ public:
   IntrinsicTypeSpec *AsIntrinsic();
   const IntrinsicTypeSpec *AsIntrinsic() const {
     switch (category_) {
-    case Numeric: return &std::get<NumericTypeSpec>(typeSpec_);
-    case Logical: return &std::get<LogicalTypeSpec>(typeSpec_);
-    case Character: return &std::get<CharacterTypeSpec>(typeSpec_);
-    default: return nullptr;
+    case Numeric:
+      return &std::get<NumericTypeSpec>(typeSpec_);
+    case Logical:
+      return &std::get<LogicalTypeSpec>(typeSpec_);
+    case Character:
+      return &std::get<CharacterTypeSpec>(typeSpec_);
+    default:
+      return nullptr;
     }
   }
 
   const DerivedTypeSpec *AsDerived() const {
     switch (category_) {
     case TypeDerived:
-    case ClassDerived: return &std::get<DerivedTypeSpec>(typeSpec_);
-    default: return nullptr;
+    case ClassDerived:
+      return &std::get<DerivedTypeSpec>(typeSpec_);
+    default:
+      return nullptr;
     }
   }
 
@@ -390,5 +399,5 @@ private:
   const Symbol *symbol_{nullptr};
   const DeclTypeSpec *type_{nullptr};
 };
-}
-#endif  // FORTRAN_SEMANTICS_TYPE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_TYPE_H_
diff --git a/flang/include/flang/Semantics/unparse-with-symbols.h b/flang/include/flang/Semantics/unparse-with-symbols.h
index 9bea94223e8a..d70110245e2b 100644
--- a/flang/include/flang/Semantics/unparse-with-symbols.h
+++ b/flang/include/flang/Semantics/unparse-with-symbols.h
@@ -25,4 +25,4 @@ void UnparseWithSymbols(llvm::raw_ostream &, const parser::Program &,
     parser::Encoding encoding = parser::Encoding::UTF_8);
 }
 
-#endif  // FORTRAN_SEMANTICS_UNPARSE_WITH_SYMBOLS_H_
+#endif // FORTRAN_SEMANTICS_UNPARSE_WITH_SYMBOLS_H_
diff --git a/flang/lib/Common/Fortran-features.cpp b/flang/lib/Common/Fortran-features.cpp
index a9e03395cab2..25a948818e65 100644
--- a/flang/lib/Common/Fortran-features.cpp
+++ b/flang/lib/Common/Fortran-features.cpp
@@ -22,15 +22,22 @@ std::vector<const char *> LanguageFeatureControl::GetNames(
   if (IsEnabled(LanguageFeature::LogicalAbbreviations)) {
     switch (opr) {
       SWITCH_COVERS_ALL_CASES
-    case LogicalOperator::And: result.push_back(".a."); break;
-    case LogicalOperator::Or: result.push_back(".o."); break;
-    case LogicalOperator::Not: result.push_back(".n."); break;
+    case LogicalOperator::And:
+      result.push_back(".a.");
+      break;
+    case LogicalOperator::Or:
+      result.push_back(".o.");
+      break;
+    case LogicalOperator::Not:
+      result.push_back(".n.");
+      break;
     case LogicalOperator::Neqv:
       if (IsEnabled(LanguageFeature::XOROperator)) {
         result.push_back(".x.");
       }
       break;
-    case LogicalOperator::Eqv: break;
+    case LogicalOperator::Eqv:
+      break;
     }
   }
   return result;
@@ -40,11 +47,16 @@ std::vector<const char *> LanguageFeatureControl::GetNames(
     RelationalOperator opr) const {
   switch (opr) {
     SWITCH_COVERS_ALL_CASES
-  case RelationalOperator::LT: return {".lt.", "<"};
-  case RelationalOperator::LE: return {".le.", "<="};
-  case RelationalOperator::EQ: return {".eq.", "=="};
-  case RelationalOperator::GE: return {".ge.", ">="};
-  case RelationalOperator::GT: return {".gt.", ">"};
+  case RelationalOperator::LT:
+    return {".lt.", "<"};
+  case RelationalOperator::LE:
+    return {".le.", "<="};
+  case RelationalOperator::EQ:
+    return {".eq.", "=="};
+  case RelationalOperator::GE:
+    return {".ge.", ">="};
+  case RelationalOperator::GT:
+    return {".gt.", ">"};
   case RelationalOperator::NE:
     if (IsEnabled(LanguageFeature::AlternativeNE)) {
       return {".ne.", "/=", "<>"};
@@ -54,4 +66,4 @@ std::vector<const char *> LanguageFeatureControl::GetNames(
   }
 }
 
-}
+} // namespace Fortran::common
diff --git a/flang/lib/Common/Fortran.cpp b/flang/lib/Common/Fortran.cpp
index d65a17e6a7b7..45a061451168 100644
--- a/flang/lib/Common/Fortran.cpp
+++ b/flang/lib/Common/Fortran.cpp
@@ -13,35 +13,51 @@ namespace Fortran::common {
 const char *AsFortran(NumericOperator opr) {
   switch (opr) {
     SWITCH_COVERS_ALL_CASES
-  case NumericOperator::Power: return "**";
-  case NumericOperator::Multiply: return "*";
-  case NumericOperator::Divide: return "/";
-  case NumericOperator::Add: return "+";
-  case NumericOperator::Subtract: return "-";
+  case NumericOperator::Power:
+    return "**";
+  case NumericOperator::Multiply:
+    return "*";
+  case NumericOperator::Divide:
+    return "/";
+  case NumericOperator::Add:
+    return "+";
+  case NumericOperator::Subtract:
+    return "-";
   }
 }
 
 const char *AsFortran(LogicalOperator opr) {
   switch (opr) {
     SWITCH_COVERS_ALL_CASES
-  case LogicalOperator::And: return ".and.";
-  case LogicalOperator::Or: return ".or.";
-  case LogicalOperator::Eqv: return ".eqv.";
-  case LogicalOperator::Neqv: return ".neqv.";
-  case LogicalOperator::Not: return ".not.";
+  case LogicalOperator::And:
+    return ".and.";
+  case LogicalOperator::Or:
+    return ".or.";
+  case LogicalOperator::Eqv:
+    return ".eqv.";
+  case LogicalOperator::Neqv:
+    return ".neqv.";
+  case LogicalOperator::Not:
+    return ".not.";
   }
 }
 
 const char *AsFortran(RelationalOperator opr) {
   switch (opr) {
     SWITCH_COVERS_ALL_CASES
-  case RelationalOperator::LT: return "<";
-  case RelationalOperator::LE: return "<=";
-  case RelationalOperator::EQ: return "==";
-  case RelationalOperator::NE: return "/=";
-  case RelationalOperator::GE: return ">=";
-  case RelationalOperator::GT: return ">";
+  case RelationalOperator::LT:
+    return "<";
+  case RelationalOperator::LE:
+    return "<=";
+  case RelationalOperator::EQ:
+    return "==";
+  case RelationalOperator::NE:
+    return "/=";
+  case RelationalOperator::GE:
+    return ">=";
+  case RelationalOperator::GT:
+    return ">";
   }
 }
 
-}
+} // namespace Fortran::common
diff --git a/flang/lib/Common/default-kinds.cpp b/flang/lib/Common/default-kinds.cpp
index 8470cfc6d137..0c708fcd6050 100644
--- a/flang/lib/Common/default-kinds.cpp
+++ b/flang/lib/Common/default-kinds.cpp
@@ -67,12 +67,18 @@ IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_defaultLogicalKind(
 
 int IntrinsicTypeDefaultKinds::GetDefaultKind(TypeCategory category) const {
   switch (category) {
-  case TypeCategory::Integer: return defaultIntegerKind_;
+  case TypeCategory::Integer:
+    return defaultIntegerKind_;
   case TypeCategory::Real:
-  case TypeCategory::Complex: return defaultRealKind_;
-  case TypeCategory::Character: return defaultCharacterKind_;
-  case TypeCategory::Logical: return defaultLogicalKind_;
-  default: CRASH_NO_CASE; return 0;
+  case TypeCategory::Complex:
+    return defaultRealKind_;
+  case TypeCategory::Character:
+    return defaultCharacterKind_;
+  case TypeCategory::Logical:
+    return defaultLogicalKind_;
+  default:
+    CRASH_NO_CASE;
+    return 0;
   }
 }
-}
+} // namespace Fortran::common
diff --git a/flang/lib/Common/idioms.cpp b/flang/lib/Common/idioms.cpp
index 229e1c062d8c..cf6ff87b1bb1 100644
--- a/flang/lib/Common/idioms.cpp
+++ b/flang/lib/Common/idioms.cpp
@@ -40,4 +40,4 @@ std::string EnumIndexToString(int index, const char *enumNames) {
   }
   return std::string(p, q - p);
 }
-}
+} // namespace Fortran::common
diff --git a/flang/lib/Decimal/big-radix-floating-point.h b/flang/lib/Decimal/big-radix-floating-point.h
index 4af217a52b42..9c940fe7d6d8 100644
--- a/flang/lib/Decimal/big-radix-floating-point.h
+++ b/flang/lib/Decimal/big-radix-floating-point.h
@@ -40,7 +40,7 @@ static constexpr std::uint64_t TenToThe(int power) {
 // 10**(LOG10RADIX + 3) must be < 2**wordbits, and LOG10RADIX must be
 // even, so that pairs of decimal digits do not straddle Digits.
 // So LOG10RADIX must be 16 or 6.
-template<int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
+template <int PREC, int LOG10RADIX = 16> class BigRadixFloatingPointNumber {
 public:
   using Real = BinaryFloatingPointNumber<PREC>;
   static constexpr int log10Radix{LOG10RADIX};
@@ -67,7 +67,7 @@ private:
 public:
   explicit BigRadixFloatingPointNumber(
       enum FortranRounding rounding = RoundDefault)
-    : rounding_{rounding} {}
+      : rounding_{rounding} {}
 
   // Converts a binary floating point value.
   explicit BigRadixFloatingPointNumber(
@@ -113,8 +113,8 @@ public:
 
 private:
   BigRadixFloatingPointNumber(const BigRadixFloatingPointNumber &that)
-    : digits_{that.digits_}, exponent_{that.exponent_},
-      isNegative_{that.isNegative_}, rounding_{that.rounding_} {
+      : digits_{that.digits_}, exponent_{that.exponent_},
+        isNegative_{that.isNegative_}, rounding_{that.rounding_} {
     for (int j{0}; j < digits_; ++j) {
       digit_[j] = that.digit_[j];
     }
@@ -140,7 +140,7 @@ private:
 
   // Sets *this to an unsigned integer value.
   // Returns any remainder.
-  template<typename UINT> UINT SetTo(UINT n) {
+  template <typename UINT> UINT SetTo(UINT n) {
     static_assert(
         std::is_same_v<UINT, common::uint128_t> || std::is_unsigned_v<UINT>);
     SetToZero();
@@ -198,12 +198,12 @@ private:
 
   // This limited divisibility test only works for even divisors of the radix,
   // which is fine since it's only ever used with 2 and 5.
-  template<int N> bool IsDivisibleBy() const {
+  template <int N> bool IsDivisibleBy() const {
     static_assert(N > 1 && radix % N == 0, "bad modulus");
     return digits_ == 0 || (digit_[0] % N) == 0;
   }
 
-  template<unsigned DIVISOR> int DivideBy() {
+  template <unsigned DIVISOR> int DivideBy() {
     Digit remainder{0};
     for (int j{digits_ - 1}; j >= 0; --j) {
       Digit q{common::DivideUnsignedBy<Digit, DIVISOR>(digit_[j])};
@@ -214,7 +214,7 @@ private:
     return remainder;
   }
 
-  int DivideByPowerOfTwo(int twoPow) {  // twoPow <= LOG10RADIX
+  int DivideByPowerOfTwo(int twoPow) { // twoPow <= LOG10RADIX
     int remainder{0};
     for (int j{digits_ - 1}; j >= 0; --j) {
       Digit q{digit_[j] >> twoPow};
@@ -253,16 +253,16 @@ private:
     }
   }
 
-  template<int N> int MultiplyByHelper(int carry = 0) {
+  template <int N> int MultiplyByHelper(int carry = 0) {
     for (int j{0}; j < digits_; ++j) {
       auto v{N * digit_[j] + carry};
       carry = common::DivideUnsignedBy<Digit, radix>(v);
-      digit_[j] = v - carry * radix;  // i.e., v % radix
+      digit_[j] = v - carry * radix; // i.e., v % radix
     }
     return carry;
   }
 
-  template<int N> int MultiplyBy(int carry = 0) {
+  template <int N> int MultiplyBy(int carry = 0) {
     if (int newCarry{MultiplyByHelper<N>(carry)}) {
       return AddCarry(digits_, newCarry);
     } else {
@@ -270,7 +270,7 @@ private:
     }
   }
 
-  template<int N> int MultiplyWithoutNormalization() {
+  template <int N> int MultiplyWithoutNormalization() {
     if (int carry{MultiplyByHelper<N>(0)}) {
       if (digits_ < digitLimit_) {
         digit_[digits_++] = carry;
@@ -283,7 +283,7 @@ private:
     }
   }
 
-  template<int N> void MultiplyByRounded() {
+  template <int N> void MultiplyByRounded() {
     if (int carry{MultiplyBy<N>()}) {
       LoseLeastSignificantDigit();
       digit_[digits_ - 1] += carry;
@@ -291,7 +291,7 @@ private:
     }
   }
 
-  void LoseLeastSignificantDigit();  // with rounding
+  void LoseLeastSignificantDigit(); // with rounding
 
   void PushCarry(int carry) {
     if (digits_ == maxDigits && RemoveLeastOrderZeroDigits() == 0) {
@@ -319,12 +319,12 @@ private:
         (Raw{1} << (Real::significandBits - 2));
   }
 
-  Digit digit_[maxDigits];  // in little-endian order: digit_[0] is LSD
-  int digits_{0};  // # of elements in digit_[] array; zero when zero
-  int digitLimit_{maxDigits};  // precision clamp
-  int exponent_{0};  // signed power of ten
+  Digit digit_[maxDigits]; // in little-endian order: digit_[0] is LSD
+  int digits_{0}; // # of elements in digit_[] array; zero when zero
+  int digitLimit_{maxDigits}; // precision clamp
+  int exponent_{0}; // signed power of ten
   bool isNegative_{false};
   enum FortranRounding rounding_ { RoundDefault };
 };
-}
+} // namespace Fortran::decimal
 #endif
diff --git a/flang/lib/Decimal/binary-to-decimal.cpp b/flang/lib/Decimal/binary-to-decimal.cpp
index f4e57681af95..a7af4036f0d6 100644
--- a/flang/lib/Decimal/binary-to-decimal.cpp
+++ b/flang/lib/Decimal/binary-to-decimal.cpp
@@ -11,10 +11,10 @@
 
 namespace Fortran::decimal {
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::BigRadixFloatingPointNumber(
     BinaryFloatingPointNumber<PREC> x, enum FortranRounding rounding)
-  : rounding_{rounding} {
+    : rounding_{rounding} {
   bool negative{x.IsNegative()};
   if (x.IsZero()) {
     isNegative_ = negative;
@@ -104,7 +104,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::BigRadixFloatingPointNumber(
   Normalize();
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 ConversionToDecimalResult
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
     std::size_t n, enum DecimalConversionFlags flags, int maxDigits) const {
@@ -176,10 +176,17 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
       incr = *end > '5' ||
           (*end == '5' && (p > end + 1 || ((end[-1] - '0') & 1) != 0));
       break;
-    case RoundUp: incr = !isNegative_; break;
-    case RoundDown: incr = isNegative_; break;
-    case RoundToZero: break;
-    case RoundCompatible: incr = *end >= '5'; break;
+    case RoundUp:
+      incr = !isNegative_;
+      break;
+    case RoundDown:
+      incr = isNegative_;
+      break;
+    case RoundToZero:
+      break;
+    case RoundCompatible:
+      incr = *end >= '5';
+      break;
     }
     p = end;
     if (incr) {
@@ -199,7 +206,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToDecimal(char *buffer,
   }
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Mean(
     const BigRadixFloatingPointNumber &that) {
   while (digits_ < that.digits_) {
@@ -222,7 +229,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Mean(
   return DivideBy<2>() != 0;
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 void BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Minimize(
     BigRadixFloatingPointNumber &&less, BigRadixFloatingPointNumber &&more) {
   int leastExponent{exponent_};
@@ -245,10 +252,10 @@ void BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Minimize(
     more.MultiplyBy<10>();
   }
   if (less.Mean(*this)) {
-    less.AddCarry();  // round up
+    less.AddCarry(); // round up
   }
   if (!more.Mean(*this)) {
-    more.Decrement();  // round down
+    more.Decrement(); // round down
   }
   while (less.digits_ < more.digits_) {
     less.digit_[less.digits_++] = 0;
@@ -292,7 +299,7 @@ void BigRadixFloatingPointNumber<PREC, LOG10RADIX>::Minimize(
   Normalize();
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 void BigRadixFloatingPointNumber<PREC,
     LOG10RADIX>::LoseLeastSignificantDigit() {
   Digit LSD{digit_[0]};
@@ -306,17 +313,24 @@ void BigRadixFloatingPointNumber<PREC,
   case RoundDefault:
     incr = LSD > radix / 2 || (LSD == radix / 2 && digit_[0] % 2 != 0);
     break;
-  case RoundUp: incr = LSD > 0 && !isNegative_; break;
-  case RoundDown: incr = LSD > 0 && isNegative_; break;
-  case RoundToZero: break;
-  case RoundCompatible: incr = LSD >= radix / 2; break;
+  case RoundUp:
+    incr = LSD > 0 && !isNegative_;
+    break;
+  case RoundDown:
+    incr = LSD > 0 && isNegative_;
+    break;
+  case RoundToZero:
+    break;
+  case RoundCompatible:
+    incr = LSD >= radix / 2;
+    break;
   }
   for (int j{0}; (digit_[j] += incr) == radix; ++j) {
     digit_[j] = 0;
   }
 }
 
-template<int PREC>
+template <int PREC>
 ConversionToDecimalResult ConvertToDecimal(char *buffer, std::size_t size,
     enum DecimalConversionFlags flags, int digits,
     enum FortranRounding rounding, BinaryFloatingPointNumber<PREC> x) {
@@ -398,4 +412,4 @@ ConversionToDecimalResult ConvertLongDoubleToDecimal(char *buffer,
 }
 #endif
 }
-}
+} // namespace Fortran::decimal
diff --git a/flang/lib/Decimal/decimal-to-binary.cpp b/flang/lib/Decimal/decimal-to-binary.cpp
index 586c7f869e80..f7efb230faf2 100644
--- a/flang/lib/Decimal/decimal-to-binary.cpp
+++ b/flang/lib/Decimal/decimal-to-binary.cpp
@@ -17,7 +17,7 @@
 
 namespace Fortran::decimal {
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
     const char *&p, bool &inexact) {
   SetToZero();
@@ -43,7 +43,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
     }
   }
   if (q == start || (q == start + 1 && *start == '.')) {
-    return false;  // require at least one digit
+    return false; // require at least one digit
   }
   // There's a valid number here; set the reference argument to point to
   // the first character afterward.
@@ -81,7 +81,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
     exponent_ -= static_cast<int>(q - point - 1);
   }
   if (q == first) {
-    exponent_ = 0;  // all zeros
+    exponent_ = 0; // all zeros
   }
   // Rack the decimal digits up into big Digits.
   for (auto times{radix}; q-- > first;) {
@@ -125,7 +125,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
         expo = 10 * Real::decimalRange;
         exponent_ = 0;
       }
-      p = q;  // exponent was valid
+      p = q; // exponent was valid
       if (negExpo) {
         exponent_ -= expo;
       } else {
@@ -133,7 +133,8 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
       }
     }
   } break;
-  default: break;
+  default:
+    break;
   }
   return true;
 }
@@ -142,7 +143,7 @@ bool BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ParseNumber(
 // binary floating-point value with an unbiased (i.e., signed)
 // binary exponent, an integer value (not a fraction) with an implied
 // binary point to its *right*, and some guard bits for rounding.
-template<int PREC> class IntermediateFloat {
+template <int PREC> class IntermediateFloat {
 public:
   static constexpr int precision{PREC};
   using IntType = common::HostUnsignedIntType<precision>;
@@ -154,7 +155,7 @@ public:
 
   // Assumes that exponent_ is valid on entry, and may increment it.
   // Returns the number of guard_ bits that have been determined.
-  template<typename UINT> bool SetTo(UINT n) {
+  template <typename UINT> bool SetTo(UINT n) {
     static constexpr int nBits{CHAR_BIT * sizeof n};
     if constexpr (precision >= nBits) {
       value_ = n;
@@ -187,7 +188,7 @@ public:
       bool isNegative, FortranRounding) const;
 
 private:
-  static constexpr int guardBits{3};  // guard, round, sticky
+  static constexpr int guardBits{3}; // guard, round, sticky
   using GuardType = int;
   static constexpr GuardType oneHalf{GuardType{1} << (guardBits - 1)};
 
@@ -196,7 +197,7 @@ private:
   int exponent_{0};
 };
 
-template<int PREC>
+template <int PREC>
 ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
     bool isNegative, FortranRounding rounding) const {
   using Binary = BinaryFloatingPointNumber<PREC>;
@@ -231,10 +232,17 @@ ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
   case RoundDefault:
     incr = guard > oneHalf || (guard == oneHalf && (fraction & 1));
     break;
-  case RoundUp: incr = guard != 0 && !isNegative; break;
-  case RoundDown: incr = guard != 0 && isNegative; break;
-  case RoundToZero: break;
-  case RoundCompatible: incr = guard >= oneHalf; break;
+  case RoundUp:
+    incr = guard != 0 && !isNegative;
+    break;
+  case RoundDown:
+    incr = guard != 0 && isNegative;
+    break;
+  case RoundToZero:
+    break;
+  case RoundCompatible:
+    incr = guard >= oneHalf;
+    break;
   }
   if (incr) {
     if (fraction == mask) {
@@ -246,10 +254,10 @@ ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
     }
   }
   if (expo == 1 && fraction < topBit) {
-    expo = 0;  // subnormal
+    expo = 0; // subnormal
   }
   if (expo >= Binary::maxExponent) {
-    expo = Binary::maxExponent;  // Inf
+    expo = Binary::maxExponent; // Inf
     flags |= Overflow;
     fraction = 0;
   }
@@ -263,14 +271,14 @@ ConversionToBinaryResult<PREC> IntermediateFloat<PREC>::ToBinary(
   return {Binary(raw), static_cast<enum ConversionResultFlags>(flags)};
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 ConversionToBinaryResult<PREC>
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary() {
   // On entry, *this holds a multi-precision integer value in a radix of a
   // large power of ten.  Its radix point is defined to be to the right of its
   // digits, and "exponent_" is the power of ten by which it is to be scaled.
   Normalize();
-  if (digits_ == 0) {  // zero value
+  if (digits_ == 0) { // zero value
     return {Real{SignBit()}};
   }
   // The value is not zero:  x = D. * 10.**E
@@ -279,9 +287,9 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary() {
   exponent_ += digits_ * log10Radix;
   // Sanity checks for ridiculous exponents
   static constexpr int crazy{2 * Real::decimalRange + log10Radix};
-  if (exponent_ < -crazy) {  // underflow to +/-0.
+  if (exponent_ < -crazy) { // underflow to +/-0.
     return {Real{SignBit()}, Inexact};
-  } else if (exponent_ > crazy) {  // overflow to +/-Inf.
+  } else if (exponent_ > crazy) { // overflow to +/-Inf.
     return {Real{Infinity()}, Overflow};
   }
   // Apply any negative decimal exponent by multiplication
@@ -346,7 +354,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary() {
   return f.ToBinary(isNegative_, rounding_);
 }
 
-template<int PREC, int LOG10RADIX>
+template <int PREC, int LOG10RADIX>
 ConversionToBinaryResult<PREC>
 BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary(const char *&p) {
   bool inexact{false};
@@ -383,7 +391,7 @@ BigRadixFloatingPointNumber<PREC, LOG10RADIX>::ConvertToBinary(const char *&p) {
   }
 }
 
-template<int PREC>
+template <int PREC>
 ConversionToBinaryResult<PREC> ConvertToBinary(
     const char *&p, enum FortranRounding rounding) {
   return BigRadixFloatingPointNumber<PREC>{rounding}.ConvertToBinary(p);
@@ -427,4 +435,4 @@ enum ConversionResultFlags ConvertDecimalToLongDouble(
 }
 #endif
 }
-}
+} // namespace Fortran::decimal
diff --git a/flang/lib/Evaluate/call.cpp b/flang/lib/Evaluate/call.cpp
index 31ee05b30873..ae1786c9290d 100644
--- a/flang/lib/Evaluate/call.cpp
+++ b/flang/lib/Evaluate/call.cpp
@@ -18,12 +18,12 @@ namespace Fortran::evaluate {
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(ActualArgument)
 ActualArgument::ActualArgument(Expr<SomeType> &&x) : u_{std::move(x)} {}
 ActualArgument::ActualArgument(common::CopyableIndirection<Expr<SomeType>> &&v)
-  : u_{std::move(v)} {}
+    : u_{std::move(v)} {}
 ActualArgument::ActualArgument(AssumedType x) : u_{x} {}
 ActualArgument::~ActualArgument() {}
 
 ActualArgument::AssumedType::AssumedType(const Symbol &symbol)
-  : symbol_{symbol} {
+    : symbol_{symbol} {
   const semantics::DeclTypeSpec *type{symbol.GetType()};
   CHECK(type && type->category() == semantics::DeclTypeSpec::TypeStar);
 }
@@ -65,8 +65,8 @@ void ActualArgument::Parenthesize() {
 
 SpecificIntrinsic::SpecificIntrinsic(
     IntrinsicProcedure n, characteristics::Procedure &&chars)
-  : name{n}, characteristics{new characteristics::Procedure{std::move(chars)}} {
-}
+    : name{n}, characteristics{
+                   new characteristics::Procedure{std::move(chars)}} {}
 
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(SpecificIntrinsic)
 
@@ -77,7 +77,7 @@ bool SpecificIntrinsic::operator==(const SpecificIntrinsic &that) const {
 }
 
 ProcedureDesignator::ProcedureDesignator(Component &&c)
-  : u{common::CopyableIndirection<Component>::Make(std::move(c))} {}
+    : u{common::CopyableIndirection<Component>::Make(std::move(c))} {}
 
 bool ProcedureDesignator::operator==(const ProcedureDesignator &that) const {
   return u == that.u;
@@ -150,14 +150,13 @@ const Component *ProcedureDesignator::GetComponent() const {
 }
 
 const Symbol *ProcedureDesignator::GetSymbol() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return &*symbol; },
-          [](const common::CopyableIndirection<Component> &c) {
-            return &c.value().GetLastSymbol();
-          },
-          [](const auto &) -> const Symbol * { return nullptr; },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return &*symbol; },
+                        [](const common::CopyableIndirection<Component> &c) {
+                          return &c.value().GetLastSymbol();
+                        },
+                        [](const auto &) -> const Symbol * { return nullptr; },
+                    },
       u);
 }
 
@@ -213,5 +212,5 @@ int ProcedureRef::Rank() const {
 ProcedureRef::~ProcedureRef() {}
 
 FOR_EACH_SPECIFIC_TYPE(template class FunctionRef, )
-}
+} // namespace Fortran::evaluate
 DEFINE_DELETER(Fortran::evaluate::ProcedureRef)
diff --git a/flang/lib/Evaluate/character.h b/flang/lib/Evaluate/character.h
index ef43a2b3afbb..f5464c733445 100644
--- a/flang/lib/Evaluate/character.h
+++ b/flang/lib/Evaluate/character.h
@@ -19,7 +19,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND> class CharacterUtils {
+template <int KIND> class CharacterUtils {
   using Character = Scalar<Type<TypeCategory::Character, KIND>>;
   using CharT = typename Character::value_type;
 
@@ -117,6 +117,6 @@ private:
   static constexpr CharT NewLine() { return 0x0a; }
 };
 
-}
+} // namespace Fortran::evaluate
 
-#endif  // FORTRAN_EVALUATE_CHARACTER_H_
+#endif // FORTRAN_EVALUATE_CHARACTER_H_
diff --git a/flang/lib/Evaluate/characteristics.cpp b/flang/lib/Evaluate/characteristics.cpp
index 867b8116702f..6c4ec1446774 100644
--- a/flang/lib/Evaluate/characteristics.cpp
+++ b/flang/lib/Evaluate/characteristics.cpp
@@ -24,7 +24,7 @@ using namespace Fortran::parser::literals;
 namespace Fortran::evaluate::characteristics {
 
 // Copy attributes from a symbol to dst based on the mapping in pairs.
-template<typename A, typename B>
+template <typename A, typename B>
 static void CopyAttrs(const semantics::Symbol &src, A &dst,
     const std::initializer_list<std::pair<semantics::Attr, B>> &pairs) {
   for (const auto &pair : pairs) {
@@ -245,17 +245,17 @@ bool DummyDataObject::CanBePassedViaImplicitInterface() const {
           Attrs{Attr::Allocatable, Attr::Asynchronous, Attr::Optional,
               Attr::Pointer, Attr::Target, Attr::Value, Attr::Volatile})
           .any()) {
-    return false;  // 15.4.2.2(3)(a)
+    return false; // 15.4.2.2(3)(a)
   } else if ((type.attrs() &
                  TypeAndShape::Attrs{TypeAndShape::Attr::AssumedShape,
                      TypeAndShape::Attr::AssumedRank,
                      TypeAndShape::Attr::Coarray})
                  .any()) {
-    return false;  // 15.4.2.2(3)(b-d)
+    return false; // 15.4.2.2(3)(b-d)
   } else if (type.type().IsPolymorphic()) {
-    return false;  // 15.4.2.2(3)(f)
+    return false; // 15.4.2.2(3)(f)
   } else if (const auto *derived{GetDerivedTypeSpec(type.type())}) {
-    return derived->parameters().empty();  // 15.4.2.2(3)(e)
+    return derived->parameters().empty(); // 15.4.2.2(3)(e)
   } else {
     return true;
   }
@@ -278,7 +278,7 @@ llvm::raw_ostream &DummyDataObject::Dump(llvm::raw_ostream &o) const {
 }
 
 DummyProcedure::DummyProcedure(Procedure &&p)
-  : procedure{new Procedure{std::move(p)}} {}
+    : procedure{new Procedure{std::move(p)}} {}
 
 bool DummyProcedure::operator==(const DummyProcedure &that) const {
   return attrs == that.attrs && intent == that.intent &&
@@ -322,7 +322,7 @@ llvm::raw_ostream &AlternateReturn::Dump(llvm::raw_ostream &o) const {
 DummyArgument::~DummyArgument() {}
 
 bool DummyArgument::operator==(const DummyArgument &that) const {
-  return u == that.u;  // name and passed-object usage are not characteristics
+  return u == that.u; // name and passed-object usage are not characteristics
 }
 
 std::optional<DummyArgument> DummyArgument::Characterize(
@@ -398,16 +398,15 @@ bool DummyArgument::IsOptional() const {
 }
 
 void DummyArgument::SetOptional(bool value) {
-  std::visit(
-      common::visitors{
-          [value](DummyDataObject &data) {
-            data.attrs.set(DummyDataObject::Attr::Optional, value);
-          },
-          [value](DummyProcedure &proc) {
-            proc.attrs.set(DummyProcedure::Attr::Optional, value);
-          },
-          [](AlternateReturn &) { DIE("cannot set optional"); },
-      },
+  std::visit(common::visitors{
+                 [value](DummyDataObject &data) {
+                   data.attrs.set(DummyDataObject::Attr::Optional, value);
+                 },
+                 [value](DummyProcedure &proc) {
+                   proc.attrs.set(DummyProcedure::Attr::Optional, value);
+                 },
+                 [](AlternateReturn &) { DIE("cannot set optional"); },
+             },
       u);
 }
 
@@ -470,17 +469,17 @@ bool FunctionResult::IsAssumedLengthCharacter() const {
 
 bool FunctionResult::CanBeReturnedViaImplicitInterface() const {
   if (attrs.test(Attr::Pointer) || attrs.test(Attr::Allocatable)) {
-    return false;  // 15.4.2.2(4)(b)
+    return false; // 15.4.2.2(4)(b)
   } else if (const auto *typeAndShape{GetTypeAndShape()}) {
     if (typeAndShape->Rank() > 0) {
-      return false;  // 15.4.2.2(4)(a)
+      return false; // 15.4.2.2(4)(a)
     } else {
       const DynamicType &type{typeAndShape->type()};
       switch (type.category()) {
       case TypeCategory::Character:
         if (const auto *param{type.charLength()}) {
           if (const auto &expr{param->GetExplicit()}) {
-            return IsConstantExpr(*expr);  // 15.4.2.2(4)(c)
+            return IsConstantExpr(*expr); // 15.4.2.2(4)(c)
           }
         }
         return false;
@@ -490,38 +489,39 @@ bool FunctionResult::CanBeReturnedViaImplicitInterface() const {
           for (const auto &pair : spec.parameters()) {
             if (const auto &expr{pair.second.GetExplicit()}) {
               if (!IsConstantExpr(*expr)) {
-                return false;  // 15.4.2.2(4)(c)
+                return false; // 15.4.2.2(4)(c)
               }
             }
           }
           return true;
         }
         return false;
-      default: return true;
+      default:
+        return true;
       }
     }
   } else {
-    return false;  // 15.4.2.2(4)(b) - procedure pointer
+    return false; // 15.4.2.2(4)(b) - procedure pointer
   }
 }
 
 llvm::raw_ostream &FunctionResult::Dump(llvm::raw_ostream &o) const {
   attrs.Dump(o, EnumToString);
-  std::visit(
-      common::visitors{
-          [&](const TypeAndShape &ts) { ts.Dump(o); },
-          [&](const CopyableIndirection<Procedure> &p) {
-            p.value().Dump(o << " procedure(") << ')';
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const TypeAndShape &ts) { ts.Dump(o); },
+                 [&](const CopyableIndirection<Procedure> &p) {
+                   p.value().Dump(o << " procedure(") << ')';
+                 },
+             },
       u);
   return o;
 }
 
 Procedure::Procedure(FunctionResult &&fr, DummyArguments &&args, Attrs a)
-  : functionResult{std::move(fr)}, dummyArguments{std::move(args)}, attrs{a} {}
+    : functionResult{std::move(fr)}, dummyArguments{std::move(args)}, attrs{a} {
+}
 Procedure::Procedure(DummyArguments &&args, Attrs a)
-  : dummyArguments{std::move(args)}, attrs{a} {}
+    : dummyArguments{std::move(args)}, attrs{a} {}
 Procedure::~Procedure() {}
 
 bool Procedure::operator==(const Procedure &that) const {
@@ -573,7 +573,7 @@ std::optional<Procedure> Procedure::Characterize(
       });
   if (result.attrs.test(Attr::Elemental) &&
       !symbol.attrs().test(semantics::Attr::IMPURE)) {
-    result.attrs.set(Attr::Pure);  // explicitly flag pure procedures
+    result.attrs.set(Attr::Pure); // explicitly flag pure procedures
   }
   return std::visit(
       common::visitors{
@@ -686,7 +686,7 @@ std::optional<Procedure> Procedure::Characterize(
 
 bool Procedure::CanBeCalledViaImplicitInterface() const {
   if (attrs.test(Attr::Elemental) || attrs.test(Attr::BindC)) {
-    return false;  // 15.4.2.2(5,6)
+    return false; // 15.4.2.2(5,6)
   } else if (IsFunction() &&
       !functionResult->CanBeReturnedViaImplicitInterface()) {
     return false;
@@ -765,11 +765,11 @@ bool DistinguishUtils::DistinguishableOpOrAssign(
   auto &args1{proc1.dummyArguments};
   auto &args2{proc2.dummyArguments};
   if (args1.size() != args2.size()) {
-    return true;  // C1511: distinguishable based on number of arguments
+    return true; // C1511: distinguishable based on number of arguments
   }
   for (std::size_t i{0}; i < args1.size(); ++i) {
     if (Distinguishable(args1[i], args2[i])) {
-      return true;  // C1511, C1512: distinguishable based on this arg
+      return true; // C1511, C1512: distinguishable based on this arg
     }
   }
   return false;
@@ -782,23 +782,23 @@ bool DistinguishUtils::Distinguishable(
   auto count1{CountDummyProcedures(args1)};
   auto count2{CountDummyProcedures(args2)};
   if (count1.notOptional > count2.total || count2.notOptional > count1.total) {
-    return true;  // distinguishable based on C1514 rule 2
+    return true; // distinguishable based on C1514 rule 2
   }
   if (Rule3Distinguishable(proc1, proc2)) {
-    return true;  // distinguishable based on C1514 rule 3
+    return true; // distinguishable based on C1514 rule 3
   }
   if (Rule1DistinguishingArg(args1, args2)) {
-    return true;  // distinguishable based on C1514 rule 1
+    return true; // distinguishable based on C1514 rule 1
   }
   int pos1{FindFirstToDistinguishByPosition(args1, args2)};
   int name1{FindLastToDistinguishByName(args1, args2)};
   if (pos1 >= 0 && pos1 <= name1) {
-    return true;  // distinguishable based on C1514 rule 4
+    return true; // distinguishable based on C1514 rule 4
   }
   int pos2{FindFirstToDistinguishByPosition(args2, args1)};
   int name2{FindLastToDistinguishByName(args2, args1)};
   if (pos2 >= 0 && pos2 <= name2) {
-    return true;  // distinguishable based on C1514 rule 4
+    return true; // distinguishable based on C1514 rule 4
   }
   return false;
 }
@@ -843,7 +843,7 @@ const DummyArgument *DistinguishUtils::Rule1DistinguishingArg(
 // - the dummy argument at that position is distinguishable from it
 int DistinguishUtils::FindFirstToDistinguishByPosition(
     const DummyArguments &args1, const DummyArguments &args2) {
-  int effective{0};  // position of arg1 in list, ignoring passed arg
+  int effective{0}; // position of arg1 in list, ignoring passed arg
   for (std::size_t i{0}; i < args1.size(); ++i) {
     const DummyArgument &arg1{args1.at(i)};
     if (!arg1.pass && !arg1.IsOptional()) {
@@ -901,7 +901,7 @@ int DistinguishUtils::CountNotDistinguishableFrom(
 bool DistinguishUtils::Distinguishable(
     const DummyArgument &x, const DummyArgument &y) {
   if (x.u.index() != y.u.index()) {
-    return true;  // different kind: data/proc/alt-return
+    return true; // different kind: data/proc/alt-return
   }
   return std::visit(
       common::visitors{
@@ -949,7 +949,7 @@ bool DistinguishUtils::Distinguishable(
 bool DistinguishUtils::Distinguishable(
     const FunctionResult &x, const FunctionResult &y) {
   if (x.u.index() != y.u.index()) {
-    return true;  // one is data object, one is procedure
+    return true; // one is data object, one is procedure
   }
   return std::visit(
       common::visitors{
@@ -1020,7 +1020,7 @@ DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(DummyArgument)
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(DummyProcedure)
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(FunctionResult)
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(Procedure)
-}
+} // namespace Fortran::evaluate::characteristics
 
 template class Fortran::common::Indirection<
     Fortran::evaluate::characteristics::Procedure, true>;
diff --git a/flang/lib/Evaluate/check-expression.cpp b/flang/lib/Evaluate/check-expression.cpp
index 07b9065dcb29..4ac73131f54a 100644
--- a/flang/lib/Evaluate/check-expression.cpp
+++ b/flang/lib/Evaluate/check-expression.cpp
@@ -26,7 +26,7 @@ public:
   IsConstantExprHelper() : Base{*this} {}
   using Base::operator();
 
-  template<int KIND> bool operator()(const TypeParamInquiry<KIND> &inq) const {
+  template <int KIND> bool operator()(const TypeParamInquiry<KIND> &inq) const {
     return IsKindTypeParameter(inq.parameter());
   }
   bool operator()(const semantics::Symbol &symbol) const {
@@ -36,7 +36,7 @@ public:
   bool operator()(const semantics::ParamValue &param) const {
     return param.isExplicit() && (*this)(param.GetExplicit());
   }
-  template<typename T> bool operator()(const FunctionRef<T> &call) const {
+  template <typename T> bool operator()(const FunctionRef<T> &call) const {
     if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&call.proc().u)}) {
       return intrinsic->name == "kind";
       // TODO: other inquiry intrinsics
@@ -46,7 +46,7 @@ public:
   }
 
   // Forbid integer division by zero in constants.
-  template<int KIND>
+  template <int KIND>
   bool operator()(
       const Divide<Type<TypeCategory::Integer, KIND>> &division) const {
     using T = Type<TypeCategory::Integer, KIND>;
@@ -58,7 +58,7 @@ public:
   }
 };
 
-template<typename A> bool IsConstantExpr(const A &x) {
+template <typename A> bool IsConstantExpr(const A &x) {
   return IsConstantExprHelper{}(x);
 }
 template bool IsConstantExpr(const Expr<SomeType> &);
@@ -69,15 +69,15 @@ template bool IsConstantExpr(const Expr<SubscriptInteger> &);
 // This code determines whether an expression is allowable as the static
 // data address used to initialize a pointer with "=> x".  See C765.
 struct IsInitialDataTargetHelper
-  : public AllTraverse<IsInitialDataTargetHelper, true> {
+    : public AllTraverse<IsInitialDataTargetHelper, true> {
   using Base = AllTraverse<IsInitialDataTargetHelper, true>;
   using Base::operator();
   explicit IsInitialDataTargetHelper(parser::ContextualMessages &m)
-    : Base{*this}, messages_{m} {}
+      : Base{*this}, messages_{m} {}
 
   bool operator()(const BOZLiteralConstant &) const { return false; }
   bool operator()(const NullPointer &) const { return true; }
-  template<typename T> bool operator()(const Constant<T> &) const {
+  template <typename T> bool operator()(const Constant<T> &) const {
     return false;
   }
   bool operator()(const semantics::Symbol &symbol) const {
@@ -102,7 +102,7 @@ struct IsInitialDataTargetHelper
     return true;
   }
   bool operator()(const StaticDataObject &) const { return false; }
-  template<int KIND> bool operator()(const TypeParamInquiry<KIND> &) const {
+  template <int KIND> bool operator()(const TypeParamInquiry<KIND> &) const {
     return false;
   }
   bool operator()(const Triplet &x) const {
@@ -110,13 +110,13 @@ struct IsInitialDataTargetHelper
         IsConstantExpr(x.stride());
   }
   bool operator()(const Subscript &x) const {
-    return std::visit(
-        common::visitors{
-            [&](const Triplet &t) { return (*this)(t); },
-            [&](const auto &y) {
-              return y.value().Rank() == 0 && IsConstantExpr(y.value());
-            },
-        },
+    return std::visit(common::visitors{
+                          [&](const Triplet &t) { return (*this)(t); },
+                          [&](const auto &y) {
+                            return y.value().Rank() == 0 &&
+                                IsConstantExpr(y.value());
+                          },
+                      },
         x.u);
   }
   bool operator()(const CoarrayRef &) const { return false; }
@@ -125,16 +125,18 @@ struct IsInitialDataTargetHelper
         (*this)(x.parent());
   }
   bool operator()(const DescriptorInquiry &) const { return false; }
-  template<typename T> bool operator()(const ArrayConstructor<T> &) const {
+  template <typename T> bool operator()(const ArrayConstructor<T> &) const {
     return false;
   }
   bool operator()(const StructureConstructor &) const { return false; }
-  template<typename T> bool operator()(const FunctionRef<T> &) { return false; }
-  template<typename D, typename R, typename... O>
+  template <typename T> bool operator()(const FunctionRef<T> &) {
+    return false;
+  }
+  template <typename D, typename R, typename... O>
   bool operator()(const Operation<D, R, O...> &) const {
     return false;
   }
-  template<typename T> bool operator()(const Parentheses<T> &x) const {
+  template <typename T> bool operator()(const Parentheses<T> &x) const {
     return (*this)(x.left());
   }
   bool operator()(const Relational<SomeType> &) const { return false; }
@@ -150,13 +152,13 @@ bool IsInitialDataTarget(
 
 // Specification expression validation (10.1.11(2), C1010)
 class CheckSpecificationExprHelper
-  : public AnyTraverse<CheckSpecificationExprHelper,
-        std::optional<std::string>> {
+    : public AnyTraverse<CheckSpecificationExprHelper,
+          std::optional<std::string>> {
 public:
   using Result = std::optional<std::string>;
   using Base = AnyTraverse<CheckSpecificationExprHelper, Result>;
   explicit CheckSpecificationExprHelper(const semantics::Scope &s)
-    : Base{*this}, scope_{s} {}
+      : Base{*this}, scope_{s} {}
   using Base::operator();
 
   Result operator()(const ProcedureDesignator &) const {
@@ -211,7 +213,7 @@ public:
     return std::nullopt;
   }
 
-  template<typename T> Result operator()(const FunctionRef<T> &x) const {
+  template <typename T> Result operator()(const FunctionRef<T> &x) const {
     if (const auto *symbol{x.proc().GetSymbol()}) {
       if (!semantics::IsPureProcedure(*symbol)) {
         return "reference to impure function '"s + symbol->name().ToString() +
@@ -221,7 +223,7 @@ public:
     } else {
       const SpecificIntrinsic &intrin{DEREF(x.proc().GetSpecificIntrinsic())};
       if (intrin.name == "present") {
-        return std::nullopt;  // no need to check argument(s)
+        return std::nullopt; // no need to check argument(s)
       }
       if (IsConstantExpr(x)) {
         // inquiry functions may not need to check argument(s)
@@ -235,7 +237,7 @@ private:
   const semantics::Scope &scope_;
 };
 
-template<typename A>
+template <typename A>
 void CheckSpecificationExpr(const A &x, parser::ContextualMessages &messages,
     const semantics::Scope &scope) {
   if (auto why{CheckSpecificationExprHelper{scope}(x)}) {
@@ -259,12 +261,12 @@ template void CheckSpecificationExpr(
 
 // IsSimplyContiguous() -- 9.5.4
 class IsSimplyContiguousHelper
-  : public AnyTraverse<IsSimplyContiguousHelper, std::optional<bool>> {
+    : public AnyTraverse<IsSimplyContiguousHelper, std::optional<bool>> {
 public:
-  using Result = std::optional<bool>;  // tri-state
+  using Result = std::optional<bool>; // tri-state
   using Base = AnyTraverse<IsSimplyContiguousHelper, Result>;
   explicit IsSimplyContiguousHelper(const IntrinsicProcTable &t)
-    : Base{*this}, table_{t} {}
+      : Base{*this}, table_{t} {}
   using Base::operator();
 
   Result operator()(const semantics::Symbol &symbol) const {
@@ -303,7 +305,7 @@ public:
   Result operator()(const ComplexPart &) const { return false; }
   Result operator()(const Substring &) const { return false; }
 
-  template<typename T> Result operator()(const FunctionRef<T> &x) const {
+  template <typename T> Result operator()(const FunctionRef<T> &x) const {
     if (auto chars{
             characteristics::Procedure::Characterize(x.proc(), table_)}) {
       if (chars->functionResult) {
@@ -347,17 +349,17 @@ private:
   const IntrinsicProcTable &table_;
 };
 
-template<typename A>
+template <typename A>
 bool IsSimplyContiguous(const A &x, const IntrinsicProcTable &table) {
   if (IsVariable(x)) {
     auto known{IsSimplyContiguousHelper{table}(x)};
     return known && *known;
   } else {
-    return true;  // not a variable
+    return true; // not a variable
   }
 }
 
 template bool IsSimplyContiguous(
     const Expr<SomeType> &, const IntrinsicProcTable &);
 
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/common.cpp b/flang/lib/Evaluate/common.cpp
index 92f7403918ee..cdfa9989ba76 100644
--- a/flang/lib/Evaluate/common.cpp
+++ b/flang/lib/Evaluate/common.cpp
@@ -51,4 +51,4 @@ void FoldingContext::EndImpliedDo(parser::CharBlock name) {
     impliedDos_.erase(iter);
   }
 }
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/complex.cpp b/flang/lib/Evaluate/complex.cpp
index 298c14a07540..73ed5b3ca950 100644
--- a/flang/lib/Evaluate/complex.cpp
+++ b/flang/lib/Evaluate/complex.cpp
@@ -11,7 +11,7 @@
 
 namespace Fortran::evaluate::value {
 
-template<typename R>
+template <typename R>
 ValueWithRealFlags<Complex<R>> Complex<R>::Add(
     const Complex &that, Rounding rounding) const {
   RealFlags flags;
@@ -20,7 +20,7 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Add(
   return {Complex{reSum, imSum}, flags};
 }
 
-template<typename R>
+template <typename R>
 ValueWithRealFlags<Complex<R>> Complex<R>::Subtract(
     const Complex &that, Rounding rounding) const {
   RealFlags flags;
@@ -29,7 +29,7 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Subtract(
   return {Complex{reDiff, imDiff}, flags};
 }
 
-template<typename R>
+template <typename R>
 ValueWithRealFlags<Complex<R>> Complex<R>::Multiply(
     const Complex &that, Rounding rounding) const {
   // (a + ib)*(c + id) -> ac - bd + i(ad + bc)
@@ -43,14 +43,14 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Multiply(
   return {Complex{acbd, adbc}, flags};
 }
 
-template<typename R>
+template <typename R>
 ValueWithRealFlags<Complex<R>> Complex<R>::Divide(
     const Complex &that, Rounding rounding) const {
   // (a + ib)/(c + id) -> [(a+ib)*(c-id)] / [(c+id)*(c-id)]
   //   -> [ac+bd+i(bc-ad)] / (cc+dd)
   //   -> ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
   // but to avoid overflows, scale by d/c if c>=d, else c/d
-  Part scale;  // <= 1.0
+  Part scale; // <= 1.0
   RealFlags flags;
   bool cGEd{that.re_.ABS().Compare(that.im_.ABS()) != Relation::Less};
   if (cGEd) {
@@ -81,7 +81,7 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Divide(
   return {Complex{re, im}, flags};
 }
 
-template<typename R> std::string Complex<R>::DumpHexadecimal() const {
+template <typename R> std::string Complex<R>::DumpHexadecimal() const {
   std::string result{'('};
   result += re_.DumpHexadecimal();
   result += ',';
@@ -90,7 +90,7 @@ template<typename R> std::string Complex<R>::DumpHexadecimal() const {
   return result;
 }
 
-template<typename R>
+template <typename R>
 llvm::raw_ostream &Complex<R>::AsFortran(llvm::raw_ostream &o, int kind) const {
   re_.AsFortran(o << '(', kind);
   im_.AsFortran(o << ',', kind);
@@ -103,4 +103,4 @@ template class Complex<Real<Integer<32>, 24>>;
 template class Complex<Real<Integer<64>, 53>>;
 template class Complex<Real<Integer<80>, 64>>;
 template class Complex<Real<Integer<128>, 113>>;
-}
+} // namespace Fortran::evaluate::value
diff --git a/flang/lib/Evaluate/constant.cpp b/flang/lib/Evaluate/constant.cpp
index 0d6a780b9879..ecdcc0ab8e3e 100644
--- a/flang/lib/Evaluate/constant.cpp
+++ b/flang/lib/Evaluate/constant.cpp
@@ -24,10 +24,10 @@ std::size_t TotalElementCount(const ConstantSubscripts &shape) {
 }
 
 ConstantBounds::ConstantBounds(const ConstantSubscripts &shape)
-  : shape_(shape), lbounds_(shape_.size(), 1) {}
+    : shape_(shape), lbounds_(shape_.size(), 1) {}
 
 ConstantBounds::ConstantBounds(ConstantSubscripts &&shape)
-  : shape_(std::move(shape)), lbounds_(shape_.size(), 1) {}
+    : shape_(std::move(shape)), lbounds_(shape_.size(), 1) {}
 
 ConstantBounds::~ConstantBounds() = default;
 
@@ -71,7 +71,7 @@ bool ConstantBounds::IncrementSubscripts(
       indices[k] = lb;
     }
   }
-  return false;  // all done
+  return false; // all done
 }
 
 std::optional<std::vector<int>> ValidateDimensionOrder(
@@ -102,22 +102,22 @@ bool IsValidShape(const ConstantSubscripts &shape) {
   return shape.size() <= common::maxRank;
 }
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 ConstantBase<RESULT, ELEMENT>::ConstantBase(
     std::vector<Element> &&x, ConstantSubscripts &&sh, Result res)
-  : ConstantBounds(std::move(sh)), result_{res}, values_(std::move(x)) {
+    : ConstantBounds(std::move(sh)), result_{res}, values_(std::move(x)) {
   CHECK(size() == TotalElementCount(shape()));
 }
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 ConstantBase<RESULT, ELEMENT>::~ConstantBase() {}
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 bool ConstantBase<RESULT, ELEMENT>::operator==(const ConstantBase &that) const {
   return shape() == that.shape() && values_ == that.values_;
 }
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 auto ConstantBase<RESULT, ELEMENT>::Reshape(
     const ConstantSubscripts &dims) const -> std::vector<Element> {
   std::size_t n{TotalElementCount(dims)};
@@ -133,7 +133,7 @@ auto ConstantBase<RESULT, ELEMENT>::Reshape(
   return elements;
 }
 
-template<typename RESULT, typename ELEMENT>
+template <typename RESULT, typename ELEMENT>
 std::size_t ConstantBase<RESULT, ELEMENT>::CopyFrom(
     const ConstantBase<RESULT, ELEMENT> &source, std::size_t count,
     ConstantSubscripts &resultSubscripts, const std::vector<int> *dimOrder) {
@@ -149,37 +149,37 @@ std::size_t ConstantBase<RESULT, ELEMENT>::CopyFrom(
   return copied;
 }
 
-template<typename T>
+template <typename T>
 auto Constant<T>::At(const ConstantSubscripts &index) const -> Element {
   return Base::values_.at(Base::SubscriptsToOffset(index));
 }
 
-template<typename T>
+template <typename T>
 auto Constant<T>::Reshape(ConstantSubscripts &&dims) const -> Constant {
   return {Base::Reshape(dims), std::move(dims)};
 }
 
-template<typename T>
+template <typename T>
 std::size_t Constant<T>::CopyFrom(const Constant<T> &source, std::size_t count,
     ConstantSubscripts &resultSubscripts, const std::vector<int> *dimOrder) {
   return Base::CopyFrom(source, count, resultSubscripts, dimOrder);
 }
 
 // Constant<Type<TypeCategory::Character, KIND> specializations
-template<int KIND>
+template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(
     const Scalar<Result> &str)
-  : values_{str}, length_{static_cast<ConstantSubscript>(values_.size())} {}
+    : values_{str}, length_{static_cast<ConstantSubscript>(values_.size())} {}
 
-template<int KIND>
+template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(Scalar<Result> &&str)
-  : values_{std::move(str)}, length_{static_cast<ConstantSubscript>(
-                                 values_.size())} {}
+    : values_{std::move(str)}, length_{static_cast<ConstantSubscript>(
+                                   values_.size())} {}
 
-template<int KIND>
+template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(ConstantSubscript len,
     std::vector<Scalar<Result>> &&strings, ConstantSubscripts &&sh)
-  : ConstantBounds(std::move(sh)), length_{len} {
+    : ConstantBounds(std::move(sh)), length_{len} {
   CHECK(strings.size() == TotalElementCount(shape()));
   values_.assign(strings.size() * length_,
       static_cast<typename Scalar<Result>::value_type>(' '));
@@ -196,14 +196,15 @@ Constant<Type<TypeCategory::Character, KIND>>::Constant(ConstantSubscript len,
   CHECK(at == static_cast<ConstantSubscript>(values_.size()));
 }
 
-template<int KIND> Constant<Type<TypeCategory::Character, KIND>>::~Constant() {}
+template <int KIND>
+Constant<Type<TypeCategory::Character, KIND>>::~Constant() {}
 
-template<int KIND>
+template <int KIND>
 bool Constant<Type<TypeCategory::Character, KIND>>::empty() const {
   return size() == 0;
 }
 
-template<int KIND>
+template <int KIND>
 std::size_t Constant<Type<TypeCategory::Character, KIND>>::size() const {
   if (length_ == 0) {
     return TotalElementCount(shape());
@@ -212,14 +213,14 @@ std::size_t Constant<Type<TypeCategory::Character, KIND>>::size() const {
   }
 }
 
-template<int KIND>
+template <int KIND>
 auto Constant<Type<TypeCategory::Character, KIND>>::At(
     const ConstantSubscripts &index) const -> Scalar<Result> {
   auto offset{SubscriptsToOffset(index)};
   return values_.substr(offset * length_, length_);
 }
 
-template<int KIND>
+template <int KIND>
 auto Constant<Type<TypeCategory::Character, KIND>>::Reshape(
     ConstantSubscripts &&dims) const -> Constant<Result> {
   std::size_t n{TotalElementCount(dims)};
@@ -230,14 +231,14 @@ auto Constant<Type<TypeCategory::Character, KIND>>::Reshape(
   while (n-- > 0) {
     elements.push_back(values_.substr(at, length_));
     at += length_;
-    if (at == limit) {  // subtle: at > limit somehow? substr() will catch it
+    if (at == limit) { // subtle: at > limit somehow? substr() will catch it
       at = 0;
     }
   }
   return {length_, std::move(elements), std::move(dims)};
 }
 
-template<int KIND>
+template <int KIND>
 std::size_t Constant<Type<TypeCategory::Character, KIND>>::CopyFrom(
     const Constant<Type<TypeCategory::Character, KIND>> &source,
     std::size_t count, ConstantSubscripts &resultSubscripts,
@@ -260,14 +261,14 @@ std::size_t Constant<Type<TypeCategory::Character, KIND>>::CopyFrom(
 
 // Constant<SomeDerived> specialization
 Constant<SomeDerived>::Constant(const StructureConstructor &x)
-  : Base{x.values(), Result{x.derivedTypeSpec()}} {}
+    : Base{x.values(), Result{x.derivedTypeSpec()}} {}
 
 Constant<SomeDerived>::Constant(StructureConstructor &&x)
-  : Base{std::move(x.values()), Result{x.derivedTypeSpec()}} {}
+    : Base{std::move(x.values()), Result{x.derivedTypeSpec()}} {}
 
 Constant<SomeDerived>::Constant(const semantics::DerivedTypeSpec &spec,
     std::vector<StructureConstructorValues> &&x, ConstantSubscripts &&s)
-  : Base{std::move(x), std::move(s), Result{spec}} {}
+    : Base{std::move(x), std::move(s), Result{spec}} {}
 
 static std::vector<StructureConstructorValues> AcquireValues(
     std::vector<StructureConstructor> &&x) {
@@ -280,7 +281,7 @@ static std::vector<StructureConstructorValues> AcquireValues(
 
 Constant<SomeDerived>::Constant(const semantics::DerivedTypeSpec &spec,
     std::vector<StructureConstructor> &&x, ConstantSubscripts &&shape)
-  : Base{AcquireValues(std::move(x)), std::move(shape), Result{spec}} {}
+    : Base{AcquireValues(std::move(x)), std::move(shape), Result{spec}} {}
 
 std::optional<StructureConstructor>
 Constant<SomeDerived>::GetScalarValue() const {
@@ -308,4 +309,4 @@ std::size_t Constant<SomeDerived>::CopyFrom(const Constant<SomeDerived> &source,
 }
 
 INSTANTIATE_CONSTANT_TEMPLATES
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/expression.cpp b/flang/lib/Evaluate/expression.cpp
index a3bb9280648f..604e4ff41ce2 100644
--- a/flang/lib/Evaluate/expression.cpp
+++ b/flang/lib/Evaluate/expression.cpp
@@ -21,7 +21,7 @@ using namespace Fortran::parser::literals;
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 std::optional<Expr<SubscriptInteger>>
 Expr<Type<TypeCategory::Character, KIND>>::LEN() const {
   using T = std::optional<Expr<SubscriptInteger>>;
@@ -63,18 +63,18 @@ Expr<Type<TypeCategory::Character, KIND>>::LEN() const {
 Expr<SomeType>::~Expr() = default;
 
 #if defined(__APPLE__) && defined(__GNUC__)
-template<typename A>
+template <typename A>
 typename ExpressionBase<A>::Derived &ExpressionBase<A>::derived() {
   return *static_cast<Derived *>(this);
 }
 
-template<typename A>
+template <typename A>
 const typename ExpressionBase<A>::Derived &ExpressionBase<A>::derived() const {
   return *static_cast<const Derived *>(this);
 }
 #endif
 
-template<typename A>
+template <typename A>
 std::optional<DynamicType> ExpressionBase<A>::GetType() const {
   if constexpr (IsLengthlessIntrinsicType<Result>) {
     return Result::GetType();
@@ -84,13 +84,13 @@ std::optional<DynamicType> ExpressionBase<A>::GetType() const {
           if constexpr (!common::HasMember<decltype(x), TypelessExpression>) {
             return x.GetType();
           }
-          return std::nullopt;  // w/o "else" to dodge bogus g++ 8.1 warning
+          return std::nullopt; // w/o "else" to dodge bogus g++ 8.1 warning
         },
         derived().u);
   }
 }
 
-template<typename A> int ExpressionBase<A>::Rank() const {
+template <typename A> int ExpressionBase<A>::Rank() const {
   return std::visit(
       [](const auto &x) {
         if constexpr (common::HasMember<decltype(x), TypelessExpression>) {
@@ -108,26 +108,26 @@ bool ImpliedDoIndex::operator==(const ImpliedDoIndex &that) const {
   return name == that.name;
 }
 
-template<typename T>
+template <typename T>
 bool ImpliedDo<T>::operator==(const ImpliedDo<T> &that) const {
   return name_ == that.name_ && lower_ == that.lower_ &&
       upper_ == that.upper_ && stride_ == that.stride_ &&
       values_ == that.values_;
 }
 
-template<typename T>
+template <typename T>
 bool ArrayConstructorValue<T>::operator==(
     const ArrayConstructorValue<T> &that) const {
   return u == that.u;
 }
 
-template<typename R>
+template <typename R>
 bool ArrayConstructorValues<R>::operator==(
     const ArrayConstructorValues<R> &that) const {
   return values_ == that.values_;
 }
 
-template<int KIND>
+template <int KIND>
 bool ArrayConstructor<Type<TypeCategory::Character, KIND>>::operator==(
     const ArrayConstructor &that) const {
   return length_ == that.length_ &&
@@ -144,10 +144,10 @@ bool ArrayConstructor<SomeDerived>::operator==(
 StructureConstructor::StructureConstructor(
     const semantics::DerivedTypeSpec &spec,
     const StructureConstructorValues &values)
-  : result_{spec}, values_{values} {}
+    : result_{spec}, values_{values} {}
 StructureConstructor::StructureConstructor(
     const semantics::DerivedTypeSpec &spec, StructureConstructorValues &&values)
-  : result_{spec}, values_{std::move(values)} {}
+    : result_{spec}, values_{std::move(values)} {}
 
 bool StructureConstructor::operator==(const StructureConstructor &that) const {
   return result_ == that.result_ && values_ == that.values_;
@@ -157,37 +157,37 @@ bool Relational<SomeType>::operator==(const Relational<SomeType> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Integer, KIND>>::operator==(
     const Expr<Type<TypeCategory::Integer, KIND>> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Real, KIND>>::operator==(
     const Expr<Type<TypeCategory::Real, KIND>> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Complex, KIND>>::operator==(
     const Expr<Type<TypeCategory::Complex, KIND>> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Logical, KIND>>::operator==(
     const Expr<Type<TypeCategory::Logical, KIND>> &that) const {
   return u == that.u;
 }
 
-template<int KIND>
+template <int KIND>
 bool Expr<Type<TypeCategory::Character, KIND>>::operator==(
     const Expr<Type<TypeCategory::Character, KIND>> &that) const {
   return u == that.u;
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 bool Expr<SomeKind<CAT>>::operator==(const Expr<SomeKind<CAT>> &that) const {
   return u == that.u;
 }
@@ -225,7 +225,7 @@ GenericExprWrapper::~GenericExprWrapper() {}
 
 GenericAssignmentWrapper::~GenericAssignmentWrapper() {}
 
-template<TypeCategory CAT> int Expr<SomeKind<CAT>>::GetKind() const {
+template <TypeCategory CAT> int Expr<SomeKind<CAT>>::GetKind() const {
   return std::visit(
       [](const auto &kx) { return std::decay_t<decltype(kx)>::Result::kind; },
       u);
@@ -242,6 +242,6 @@ std::optional<Expr<SubscriptInteger>> Expr<SomeCharacter>::LEN() const {
 }
 
 INSTANTIATE_EXPRESSION_TEMPLATES
-}
+} // namespace Fortran::evaluate
 DEFINE_DELETER(Fortran::evaluate::GenericExprWrapper)
 DEFINE_DELETER(Fortran::evaluate::GenericAssignmentWrapper)
diff --git a/flang/lib/Evaluate/fold-character.cpp b/flang/lib/Evaluate/fold-character.cpp
index 7398a1b56d0f..1eac58213f20 100644
--- a/flang/lib/Evaluate/fold-character.cpp
+++ b/flang/lib/Evaluate/fold-character.cpp
@@ -10,7 +10,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Character, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Character, KIND>> &&funcRef) {
@@ -38,14 +38,14 @@ Expr<Type<TypeCategory::Character, KIND>> FoldIntrinsicFunction(
     return FoldMINorMAX(context, std::move(funcRef), Ordering::Less);
   } else if (name == "new_line") {
     return Expr<T>{Constant<T>{CharacterUtils<KIND>::NEW_LINE()}};
-  } else if (name == "repeat") {  // not elemental
+  } else if (name == "repeat") { // not elemental
     if (auto scalars{GetScalarConstantArguments<T, SubscriptInteger>(
             context, funcRef.arguments())}) {
       return Expr<T>{Constant<T>{
           CharacterUtils<KIND>::REPEAT(std::get<Scalar<T>>(*scalars),
               std::get<Scalar<SubscriptInteger>>(*scalars).ToInt64())}};
     }
-  } else if (name == "trim") {  // not elemental
+  } else if (name == "trim") { // not elemental
     if (auto scalar{
             GetScalarConstantArguments<T>(context, funcRef.arguments())}) {
       return Expr<T>{Constant<T>{
@@ -57,7 +57,7 @@ Expr<Type<TypeCategory::Character, KIND>> FoldIntrinsicFunction(
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
     FoldingContext &context, Concat<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
@@ -70,7 +70,7 @@ Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
   return Expr<Result>{std::move(x)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
     FoldingContext &context, SetLength<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
@@ -93,4 +93,4 @@ Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
 
 FOR_EACH_CHARACTER_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeCharacter>;
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/fold-complex.cpp b/flang/lib/Evaluate/fold-complex.cpp
index f2006daf3b56..ea96f045aa3e 100644
--- a/flang/lib/Evaluate/fold-complex.cpp
+++ b/flang/lib/Evaluate/fold-complex.cpp
@@ -10,7 +10,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Complex, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Complex, KIND>> &&funcRef) {
@@ -61,7 +61,7 @@ Expr<Type<TypeCategory::Complex, KIND>> FoldIntrinsicFunction(
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Complex, KIND>> FoldOperation(
     FoldingContext &context, ComplexConstructor<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
@@ -77,4 +77,4 @@ Expr<Type<TypeCategory::Complex, KIND>> FoldOperation(
 
 FOR_EACH_COMPLEX_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeComplex>;
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/fold-implementation.h b/flang/lib/Evaluate/fold-implementation.h
index 67e541e1204a..44f0093a3bdb 100644
--- a/flang/lib/Evaluate/fold-implementation.h
+++ b/flang/lib/Evaluate/fold-implementation.h
@@ -45,7 +45,7 @@
 namespace Fortran::evaluate {
 
 // Utilities
-template<typename T> class Folder {
+template <typename T> class Folder {
 public:
   explicit Folder(FoldingContext &c) : context_{c} {}
   std::optional<Expr<T>> GetNamedConstantValue(const Symbol &);
@@ -76,7 +76,7 @@ std::optional<Constant<SubscriptInteger>> GetConstantSubscript(
 // specific type.
 
 // no-op base case
-template<typename A>
+template <typename A>
 common::IfNoLvalue<Expr<ResultType<A>>, A> FoldOperation(
     FoldingContext &, A &&x) {
   static_assert(!std::is_same_v<A, Expr<ResultType<A>>>,
@@ -94,36 +94,36 @@ DataRef FoldOperation(FoldingContext &, DataRef &&);
 Substring FoldOperation(FoldingContext &, Substring &&);
 ComplexPart FoldOperation(FoldingContext &, ComplexPart &&);
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, FunctionRef<T> &&);
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Integer, KIND>> &&);
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Real, KIND>> &&);
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Complex, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Complex, KIND>> &&);
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Logical, KIND>> &&);
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Designator<T> &&designator) {
   return Folder<T>{context}.Folding(std::move(designator));
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> FoldOperation(
     FoldingContext &, TypeParamInquiry<KIND> &&);
 Expr<ImpliedDoIndex::Result> FoldOperation(
     FoldingContext &context, ImpliedDoIndex &&);
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &, ArrayConstructor<T> &&);
 Expr<SomeDerived> FoldOperation(FoldingContext &, StructureConstructor &&);
 
-template<typename T>
+template <typename T>
 std::optional<Expr<T>> Folder<T>::GetNamedConstantValue(const Symbol &symbol0) {
   const Symbol &symbol{ResolveAssociations(symbol0)};
   if (IsNamedConstant(symbol)) {
@@ -200,7 +200,7 @@ std::optional<Expr<T>> Folder<T>::GetNamedConstantValue(const Symbol &symbol0) {
   return std::nullopt;
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::GetFoldedNamedConstantValue(
     const Symbol &symbol) {
   if (auto value{GetNamedConstantValue(symbol)}) {
@@ -212,7 +212,7 @@ std::optional<Constant<T>> Folder<T>::GetFoldedNamedConstantValue(
   return std::nullopt;
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::Folding(ArrayRef &aRef) {
   std::vector<Constant<SubscriptInteger>> subscripts;
   int dim{0};
@@ -233,7 +233,7 @@ std::optional<Constant<T>> Folder<T>::Folding(ArrayRef &aRef) {
   }
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::ApplySubscripts(const Constant<T> &array,
     const std::vector<Constant<SubscriptInteger>> &subscripts) {
   const auto &shape{array.shape()};
@@ -293,7 +293,7 @@ std::optional<Constant<T>> Folder<T>::ApplySubscripts(const Constant<T> &array,
   }
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::ApplyComponent(
     Constant<SomeDerived> &&structures, const Symbol &component,
     const std::vector<Constant<SubscriptInteger>> *subscripts) {
@@ -351,7 +351,7 @@ std::optional<Constant<T>> Folder<T>::ApplyComponent(
   return std::nullopt;
 }
 
-template<typename T>
+template <typename T>
 std::optional<Constant<T>> Folder<T>::GetConstantComponent(Component &component,
     const std::vector<Constant<SubscriptInteger>> *subscripts) {
   if (std::optional<Constant<SomeDerived>> structures{std::visit(
@@ -378,7 +378,7 @@ std::optional<Constant<T>> Folder<T>::GetConstantComponent(Component &component,
   }
 }
 
-template<typename T> Expr<T> Folder<T>::Folding(Designator<T> &&designator) {
+template <typename T> Expr<T> Folder<T>::Folding(Designator<T> &&designator) {
   if constexpr (T::category == TypeCategory::Character) {
     if (auto *substring{common::Unwrap<Substring>(designator.u)}) {
       if (std::optional<Expr<SomeCharacter>> folded{
@@ -428,7 +428,7 @@ template<typename T> Expr<T> Folder<T>::Folding(Designator<T> &&designator) {
 
 // Apply type conversion and re-folding if necessary.
 // This is where BOZ arguments are converted.
-template<typename T>
+template <typename T>
 Constant<T> *Folder<T>::Folding(std::optional<ActualArgument> &arg) {
   if (auto *expr{UnwrapExpr<Expr<SomeType>>(arg)}) {
     if (!UnwrapExpr<Expr<T>>(*expr)) {
@@ -441,12 +441,12 @@ Constant<T> *Folder<T>::Folding(std::optional<ActualArgument> &arg) {
   return nullptr;
 }
 
-template<typename... A, std::size_t... I>
+template <typename... A, std::size_t... I>
 std::optional<std::tuple<const Constant<A> *...>> GetConstantArgumentsHelper(
     FoldingContext &context, ActualArguments &arguments,
     std::index_sequence<I...>) {
   static_assert(
-      (... && IsSpecificIntrinsicType<A>));  // TODO derived types for MERGE?
+      (... && IsSpecificIntrinsicType<A>)); // TODO derived types for MERGE?
   static_assert(sizeof...(A) > 0);
   std::tuple<const Constant<A> *...> args{
       Folder<A>{context}.Folding(arguments.at(I))...};
@@ -457,14 +457,14 @@ std::optional<std::tuple<const Constant<A> *...>> GetConstantArgumentsHelper(
   }
 }
 
-template<typename... A>
+template <typename... A>
 std::optional<std::tuple<const Constant<A> *...>> GetConstantArguments(
     FoldingContext &context, ActualArguments &args) {
   return GetConstantArgumentsHelper<A...>(
       context, args, std::index_sequence_for<A...>{});
 }
 
-template<typename... A, std::size_t... I>
+template <typename... A, std::size_t... I>
 std::optional<std::tuple<Scalar<A>...>> GetScalarConstantArgumentsHelper(
     FoldingContext &context, ActualArguments &args, std::index_sequence<I...>) {
   if (auto constArgs{GetConstantArguments<A...>(context, args)}) {
@@ -475,7 +475,7 @@ std::optional<std::tuple<Scalar<A>...>> GetScalarConstantArgumentsHelper(
   }
 }
 
-template<typename... A>
+template <typename... A>
 std::optional<std::tuple<Scalar<A>...>> GetScalarConstantArguments(
     FoldingContext &context, ActualArguments &args) {
   return GetScalarConstantArgumentsHelper<A...>(
@@ -486,13 +486,13 @@ std::optional<std::tuple<Scalar<A>...>> GetScalarConstantArguments(
 // Define callable types used in a common utility that
 // takes care of array and cast/conversion aspects for elemental intrinsics
 
-template<typename TR, typename... TArgs>
+template <typename TR, typename... TArgs>
 using ScalarFunc = std::function<Scalar<TR>(const Scalar<TArgs> &...)>;
-template<typename TR, typename... TArgs>
+template <typename TR, typename... TArgs>
 using ScalarFuncWithContext =
     std::function<Scalar<TR>(FoldingContext &, const Scalar<TArgs> &...)>;
 
-template<template<typename, typename...> typename WrapperType, typename TR,
+template <template <typename, typename...> typename WrapperType, typename TR,
     typename... TA, std::size_t... I>
 Expr<TR> FoldElementalIntrinsicHelper(FoldingContext &context,
     FunctionRef<TR> &&funcRef, WrapperType<TR, TA...> func,
@@ -556,13 +556,13 @@ Expr<TR> FoldElementalIntrinsicHelper(FoldingContext &context,
   return Expr<TR>{std::move(funcRef)};
 }
 
-template<typename TR, typename... TA>
+template <typename TR, typename... TA>
 Expr<TR> FoldElementalIntrinsic(FoldingContext &context,
     FunctionRef<TR> &&funcRef, ScalarFunc<TR, TA...> func) {
   return FoldElementalIntrinsicHelper<ScalarFunc, TR, TA...>(
       context, std::move(funcRef), func, std::index_sequence_for<TA...>{});
 }
-template<typename TR, typename... TA>
+template <typename TR, typename... TA>
 Expr<TR> FoldElementalIntrinsic(FoldingContext &context,
     FunctionRef<TR> &&funcRef, ScalarFuncWithContext<TR, TA...> func) {
   return FoldElementalIntrinsicHelper<ScalarFuncWithContext, TR, TA...>(
@@ -573,7 +573,7 @@ std::optional<std::int64_t> GetInt64Arg(const std::optional<ActualArgument> &);
 std::optional<std::int64_t> GetInt64ArgOr(
     const std::optional<ActualArgument> &, std::int64_t defaultValue);
 
-template<typename A, typename B>
+template <typename A, typename B>
 std::optional<std::vector<A>> GetIntegerVector(const B &x) {
   static_assert(std::is_integral_v<A>);
   if (const auto *someInteger{UnwrapExpr<Expr<SomeInteger>>(x)}) {
@@ -600,14 +600,14 @@ std::optional<std::vector<A>> GetIntegerVector(const B &x) {
 // into an intrinsic with the same characteristic but the "invalid" name.
 // This to prevent generating warnings over and over if the expression
 // gets re-folded.
-template<typename T> Expr<T> MakeInvalidIntrinsic(FunctionRef<T> &&funcRef) {
+template <typename T> Expr<T> MakeInvalidIntrinsic(FunctionRef<T> &&funcRef) {
   SpecificIntrinsic invalid{std::get<SpecificIntrinsic>(funcRef.proc().u)};
   invalid.name = "(invalid intrinsic function call)";
   return Expr<T>{FunctionRef<T>{ProcedureDesignator{std::move(invalid)},
       ActualArguments{ActualArgument{AsGenericExpr(std::move(funcRef))}}}};
 }
 
-template<typename T> Expr<T> Folder<T>::Reshape(FunctionRef<T> &&funcRef) {
+template <typename T> Expr<T> Folder<T>::Reshape(FunctionRef<T> &&funcRef) {
   auto args{funcRef.arguments()};
   CHECK(args.size() == 4);
   const auto *source{UnwrapConstantValue<T>(args[0])};
@@ -616,7 +616,7 @@ template<typename T> Expr<T> Folder<T>::Reshape(FunctionRef<T> &&funcRef) {
       GetIntegerVector<ConstantSubscript>(args[1])};
   std::optional<std::vector<int>> order{GetIntegerVector<int>(args[3])};
   if (!source || !shape || (args[2] && !pad) || (args[3] && !order)) {
-    return Expr<T>{std::move(funcRef)};  // Non-constant arguments
+    return Expr<T>{std::move(funcRef)}; // Non-constant arguments
   } else if (!IsValidShape(shape.value())) {
     context_.messages().Say("Invalid SHAPE in RESHAPE"_en_US);
   } else {
@@ -652,7 +652,7 @@ template<typename T> Expr<T> Folder<T>::Reshape(FunctionRef<T> &&funcRef) {
   return MakeInvalidIntrinsic(std::move(funcRef));
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldMINorMAX(
     FoldingContext &context, FunctionRef<T> &&funcRef, Ordering order) {
   std::vector<Constant<T> *> constantArgs;
@@ -672,7 +672,7 @@ Expr<T> FoldMINorMAX(
   return result;
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, FunctionRef<T> &&funcRef) {
   ActualArguments &args{funcRef.arguments()};
   for (std::optional<ActualArgument> &arg : args) {
@@ -693,7 +693,7 @@ Expr<T> FoldOperation(FoldingContext &context, FunctionRef<T> &&funcRef) {
   return Expr<T>{std::move(funcRef)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldMerge(FoldingContext &context, FunctionRef<T> &&funcRef) {
   return FoldElementalIntrinsic<T, T, T, LogicalResult>(context,
       std::move(funcRef),
@@ -707,7 +707,7 @@ Expr<T> FoldMerge(FoldingContext &context, FunctionRef<T> &&funcRef) {
 Expr<ImpliedDoIndex::Result> FoldOperation(FoldingContext &, ImpliedDoIndex &&);
 
 // Array constructor folding
-template<typename T> class ArrayConstructorFolder {
+template <typename T> class ArrayConstructorFolder {
 public:
   explicit ArrayConstructorFolder(const FoldingContext &c) : context_{c} {}
 
@@ -797,7 +797,7 @@ private:
   std::vector<Scalar<T>> elements_;
 };
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, ArrayConstructor<T> &&array) {
   return ArrayConstructorFolder<T>{context}.FoldArray(std::move(array));
 }
@@ -810,7 +810,7 @@ Expr<T> FoldOperation(FoldingContext &context, ArrayConstructor<T> &&array) {
 
 // If possible, restructures an array expression into an array constructor
 // that comprises a "flat" ArrayConstructorValues with no implied DO loops.
-template<typename T>
+template <typename T>
 bool ArrayConstructorIsFlat(const ArrayConstructorValues<T> &values) {
   for (const ArrayConstructorValue<T> &x : values) {
     if (!std::holds_alternative<Expr<T>>(x.u)) {
@@ -820,7 +820,7 @@ bool ArrayConstructorIsFlat(const ArrayConstructorValues<T> &values) {
   return true;
 }
 
-template<typename T>
+template <typename T>
 std::optional<Expr<T>> AsFlatArrayConstructor(const Expr<T> &expr) {
   if (const auto *c{UnwrapConstantValue<T>(expr)}) {
     ArrayConstructor<T> result{expr};
@@ -841,7 +841,7 @@ std::optional<Expr<T>> AsFlatArrayConstructor(const Expr<T> &expr) {
   return std::nullopt;
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 std::enable_if_t<CAT != TypeCategory::Derived,
     std::optional<Expr<SomeKind<CAT>>>>
 AsFlatArrayConstructor(const Expr<SomeKind<CAT>> &expr) {
@@ -860,7 +860,7 @@ AsFlatArrayConstructor(const Expr<SomeKind<CAT>> &expr) {
 // Given a flat ArrayConstructor<T> and a shape, it wraps the array
 // into an Expr<T>, folds it, and returns the resulting wrapped
 // array constructor or constant array value.
-template<typename T>
+template <typename T>
 Expr<T> FromArrayConstructor(FoldingContext &context,
     ArrayConstructor<T> &&values, std::optional<ConstantSubscripts> &&shape) {
   Expr<T> result{Fold(context, Expr<T>{std::move(values)})};
@@ -880,7 +880,7 @@ Expr<T> FromArrayConstructor(FoldingContext &context,
 // Preserves shape.
 
 // Unary case
-template<typename RESULT, typename OPERAND>
+template <typename RESULT, typename OPERAND>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<OPERAND> &&)> &&f, const Shape &shape,
     Expr<OPERAND> &&values) {
@@ -908,7 +908,7 @@ Expr<RESULT> MapOperation(FoldingContext &context,
 }
 
 // array * array case
-template<typename RESULT, typename LEFT, typename RIGHT>
+template <typename RESULT, typename LEFT, typename RIGHT>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f,
     const Shape &shape, Expr<LEFT> &&leftValues, Expr<RIGHT> &&rightValues) {
@@ -948,7 +948,7 @@ Expr<RESULT> MapOperation(FoldingContext &context,
 }
 
 // array * scalar case
-template<typename RESULT, typename LEFT, typename RIGHT>
+template <typename RESULT, typename LEFT, typename RIGHT>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f,
     const Shape &shape, Expr<LEFT> &&leftValues,
@@ -965,7 +965,7 @@ Expr<RESULT> MapOperation(FoldingContext &context,
 }
 
 // scalar * array case
-template<typename RESULT, typename LEFT, typename RIGHT>
+template <typename RESULT, typename LEFT, typename RIGHT>
 Expr<RESULT> MapOperation(FoldingContext &context,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f,
     const Shape &shape, const Expr<LEFT> &leftScalar,
@@ -1000,7 +1000,7 @@ Expr<RESULT> MapOperation(FoldingContext &context,
 // operation, then attempts to apply the operation to the (corresponding)
 // scalar element(s) of those operands.  Returns std::nullopt for scalars
 // or unlinearizable operands.
-template<typename DERIVED, typename RESULT, typename OPERAND>
+template <typename DERIVED, typename RESULT, typename OPERAND>
 auto ApplyElementwise(FoldingContext &context,
     Operation<DERIVED, RESULT, OPERAND> &operation,
     std::function<Expr<RESULT>(Expr<OPERAND> &&)> &&f)
@@ -1017,7 +1017,7 @@ auto ApplyElementwise(FoldingContext &context,
   return std::nullopt;
 }
 
-template<typename DERIVED, typename RESULT, typename OPERAND>
+template <typename DERIVED, typename RESULT, typename OPERAND>
 auto ApplyElementwise(
     FoldingContext &context, Operation<DERIVED, RESULT, OPERAND> &operation)
     -> std::optional<Expr<RESULT>> {
@@ -1032,19 +1032,19 @@ auto ApplyElementwise(
 // in the flattening of an array expression?
 // TODO: capture such scalar expansions in temporaries, flatten everything
 struct UnexpandabilityFindingVisitor
-  : public AnyTraverse<UnexpandabilityFindingVisitor> {
+    : public AnyTraverse<UnexpandabilityFindingVisitor> {
   using Base = AnyTraverse<UnexpandabilityFindingVisitor>;
   using Base::operator();
   UnexpandabilityFindingVisitor() : Base{*this} {}
-  template<typename T> bool operator()(const FunctionRef<T> &) { return true; }
+  template <typename T> bool operator()(const FunctionRef<T> &) { return true; }
   bool operator()(const CoarrayRef &) { return true; }
 };
 
-template<typename T> bool IsExpandableScalar(const Expr<T> &expr) {
+template <typename T> bool IsExpandableScalar(const Expr<T> &expr) {
   return !UnexpandabilityFindingVisitor{}(expr);
 }
 
-template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
+template <typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
 auto ApplyElementwise(FoldingContext &context,
     Operation<DERIVED, RESULT, LEFT, RIGHT> &operation,
     std::function<Expr<RESULT>(Expr<LEFT> &&, Expr<RIGHT> &&)> &&f)
@@ -1081,7 +1081,7 @@ auto ApplyElementwise(FoldingContext &context,
   return std::nullopt;
 }
 
-template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
+template <typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
 auto ApplyElementwise(
     FoldingContext &context, Operation<DERIVED, RESULT, LEFT, RIGHT> &operation)
     -> std::optional<Expr<RESULT>> {
@@ -1094,7 +1094,7 @@ auto ApplyElementwise(
 
 // Unary operations
 
-template<typename TO, typename FROM>
+template <typename TO, typename FROM>
 common::IfNoLvalue<std::optional<TO>, FROM> ConvertString(FROM &&s) {
   if constexpr (std::is_same_v<TO, FROM>) {
     return std::make_optional<TO>(std::move(s));
@@ -1112,7 +1112,7 @@ common::IfNoLvalue<std::optional<TO>, FROM> ConvertString(FROM &&s) {
   }
 }
 
-template<typename TO, TypeCategory FROMCAT>
+template <typename TO, TypeCategory FROMCAT>
 Expr<TO> FoldOperation(
     FoldingContext &context, Convert<TO, FROMCAT> &&convert) {
   if (auto array{ApplyElementwise(context, convert)}) {
@@ -1178,14 +1178,14 @@ Expr<TO> FoldOperation(
           }
         } else if constexpr (std::is_same_v<Operand, TO> &&
             FROMCAT != TypeCategory::Character) {
-          return std::move(kindExpr);  // remove needless conversion
+          return std::move(kindExpr); // remove needless conversion
         }
         return Expr<TO>{std::move(convert)};
       },
       convert.left().u);
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Parentheses<T> &&x) {
   auto &operand{x.left()};
   operand = Fold(context, std::move(operand));
@@ -1200,7 +1200,7 @@ Expr<T> FoldOperation(FoldingContext &context, Parentheses<T> &&x) {
   }
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Negate<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1224,7 +1224,7 @@ Expr<T> FoldOperation(FoldingContext &context, Negate<T> &&x) {
 
 // Binary (dyadic) operations
 
-template<typename LEFT, typename RIGHT>
+template <typename LEFT, typename RIGHT>
 std::optional<std::pair<Scalar<LEFT>, Scalar<RIGHT>>> OperandsAreConstants(
     const Expr<LEFT> &x, const Expr<RIGHT> &y) {
   if (auto xvalue{GetScalarConstantValue<LEFT>(x)}) {
@@ -1235,13 +1235,13 @@ std::optional<std::pair<Scalar<LEFT>, Scalar<RIGHT>>> OperandsAreConstants(
   return std::nullopt;
 }
 
-template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
+template <typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
 std::optional<std::pair<Scalar<LEFT>, Scalar<RIGHT>>> OperandsAreConstants(
     const Operation<DERIVED, RESULT, LEFT, RIGHT> &operation) {
   return OperandsAreConstants(operation.left(), operation.right());
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Add<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1266,7 +1266,7 @@ Expr<T> FoldOperation(FoldingContext &context, Add<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Subtract<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1292,7 +1292,7 @@ Expr<T> FoldOperation(FoldingContext &context, Subtract<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Multiply<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1317,7 +1317,7 @@ Expr<T> FoldOperation(FoldingContext &context, Multiply<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Divide<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1346,7 +1346,7 @@ Expr<T> FoldOperation(FoldingContext &context, Divide<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Power<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1378,7 +1378,7 @@ Expr<T> FoldOperation(FoldingContext &context, Power<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, RealToIntPower<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
@@ -1399,7 +1399,7 @@ Expr<T> FoldOperation(FoldingContext &context, RealToIntPower<T> &&x) {
       x.right().u);
 }
 
-template<typename T>
+template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Extremum<T> &&x) {
   if (auto array{ApplyElementwise(context, x,
           std::function<Expr<T>(Expr<T> &&, Expr<T> &&)>{[=](Expr<T> &&l,
@@ -1436,7 +1436,7 @@ Expr<T> FoldOperation(FoldingContext &context, Extremum<T> &&x) {
   return Expr<T>{std::move(x)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> ToReal(
     FoldingContext &context, Expr<SomeType> &&expr) {
   using Result = Type<TypeCategory::Real, KIND>;
@@ -1452,7 +1452,7 @@ Expr<Type<TypeCategory::Real, KIND>> ToReal(
           CHECK(constant);
           Scalar<Result> real{constant->GetScalarValue().value()};
           From converted{From::ConvertUnsigned(real.RawBits()).value};
-          if (original != converted) {  // C1601
+          if (original != converted) { // C1601
             context.messages().Say(
                 "Nonzero bits truncated from BOZ literal constant in REAL intrinsic"_en_US);
           }
@@ -1466,7 +1466,7 @@ Expr<Type<TypeCategory::Real, KIND>> ToReal(
   return result.value();
 }
 
-template<typename T>
+template <typename T>
 Expr<T> ExpressionBase<T>::Rewrite(FoldingContext &context, Expr<T> &&expr) {
   return std::visit(
       [&](auto &&x) -> Expr<T> {
@@ -1486,5 +1486,5 @@ Expr<T> ExpressionBase<T>::Rewrite(FoldingContext &context, Expr<T> &&expr) {
 
 FOR_EACH_TYPE_AND_KIND(extern template class ExpressionBase, )
 
-}
-#endif  // FORTRAN_EVALUATE_FOLD_IMPLEMENTATION_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_FOLD_IMPLEMENTATION_H_
diff --git a/flang/lib/Evaluate/fold-integer.cpp b/flang/lib/Evaluate/fold-integer.cpp
index bf0eb6ca6c3e..6d159eda93e3 100644
--- a/flang/lib/Evaluate/fold-integer.cpp
+++ b/flang/lib/Evaluate/fold-integer.cpp
@@ -10,7 +10,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
     FunctionRef<Type<TypeCategory::Integer, KIND>> &&funcRef) {
   using T = Type<TypeCategory::Integer, KIND>;
@@ -27,7 +27,7 @@ Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
                 static_cast<std::intmax_t>(*dim64), rank);
             return MakeInvalidIntrinsic<T>(std::move(funcRef));
           } else {
-            dim = *dim64 - 1;  // 1-based to 0-based
+            dim = *dim64 - 1; // 1-based to 0-based
           }
         } else {
           // DIM= is present but not constant
@@ -48,7 +48,7 @@ Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
                 ConvertToType<T>(Expr<ExtentType>{std::move(*extents)}));
           }
         } else {
-          lowerBoundsAreOne = symbol.Rank() == 0;  // LBOUND(array%component)
+          lowerBoundsAreOne = symbol.Rank() == 0; // LBOUND(array%component)
         }
       }
       if (lowerBoundsAreOne) {
@@ -65,7 +65,7 @@ Expr<Type<TypeCategory::Integer, KIND>> LBOUND(FoldingContext &context,
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
     FunctionRef<Type<TypeCategory::Integer, KIND>> &&funcRef) {
   using T = Type<TypeCategory::Integer, KIND>;
@@ -82,7 +82,7 @@ Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
                 static_cast<std::intmax_t>(*dim64), rank);
             return MakeInvalidIntrinsic<T>(std::move(funcRef));
           } else {
-            dim = *dim64 - 1;  // 1-based to 0-based
+            dim = *dim64 - 1; // 1-based to 0-based
           }
         } else {
           // DIM= is present but not constant
@@ -112,7 +112,7 @@ Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
             }
           }
         } else {
-          takeBoundsFromShape = symbol.Rank() == 0;  // UBOUND(array%component)
+          takeBoundsFromShape = symbol.Rank() == 0; // UBOUND(array%component)
         }
       }
       if (takeBoundsFromShape) {
@@ -132,7 +132,7 @@ Expr<Type<TypeCategory::Integer, KIND>> UBOUND(FoldingContext &context,
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Integer, KIND>> &&funcRef) {
@@ -177,7 +177,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
           cx->u);
     }
   } else if (name == "count") {
-    if (!args[1]) {  // TODO: COUNT(x,DIM=d)
+    if (!args[1]) { // TODO: COUNT(x,DIM=d)
       if (const auto *constant{UnwrapConstantValue<LogicalResult>(args[0])}) {
         std::int64_t result{0};
         for (const auto &element : constant->values()) {
@@ -260,7 +260,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     }
   } else if (name == "iand" || name == "ior" || name == "ieor") {
     auto fptr{&Scalar<T>::IAND};
-    if (name == "iand") {  // done in fptr declaration
+    if (name == "iand") { // done in fptr declaration
     } else if (name == "ior") {
       fptr = &Scalar<T>::IOR;
     } else if (name == "ieor") {
@@ -275,7 +275,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
     // Second argument can be of any kind. However, it must be smaller or
     // equal than BIT_SIZE. It can be converted to Int4 to simplify.
     auto fptr{&Scalar<T>::IBCLR};
-    if (name == "ibclr") {  // done in fprt definition
+    if (name == "ibclr") { // done in fprt definition
     } else if (name == "ibset") {
       fptr = &Scalar<T>::IBSET;
     } else if (name == "ishft") {
@@ -299,7 +299,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
       return std::visit(
           [&](const auto &kch) -> Expr<T> {
             using TC = typename std::decay_t<decltype(kch)>::Result;
-            if (UnwrapExpr<Expr<SomeLogical>>(args[2])) {  // BACK=
+            if (UnwrapExpr<Expr<SomeLogical>>(args[2])) { // BACK=
               return FoldElementalIntrinsic<T, TC, TC, LogicalResult>(context,
                   std::move(funcRef),
                   ScalarFunc<T, TC, TC, LogicalResult>{
@@ -367,7 +367,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
                   }));
             }
             auto fptr{&Scalar<TI>::LEADZ};
-            if (name == "leadz") {  // done in fptr definition
+            if (name == "leadz") { // done in fptr definition
             } else if (name == "trailz") {
               fptr = &Scalar<TI>::TRAILZ;
             } else if (name == "popcnt") {
@@ -562,7 +562,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
             }));
   } else if (name == "size") {
     if (auto shape{GetShape(context, args[0])}) {
-      if (auto &dimArg{args[1]}) {  // DIM= is present, get one extent
+      if (auto &dimArg{args[1]}) { // DIM= is present, get one extent
         if (auto dim{GetInt64Arg(args[1])}) {
           int rank{GetRank(*shape)};
           if (*dim >= 1 && *dim <= rank) {
@@ -597,7 +597,7 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
 }
 
 // Substitute a bare type parameter reference with its value if it has one now
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Integer, KIND>> FoldOperation(
     FoldingContext &context, TypeParamInquiry<KIND> &&inquiry) {
   using IntKIND = Type<TypeCategory::Integer, KIND>;
@@ -644,4 +644,4 @@ std::optional<std::int64_t> ToInt64(const Expr<SomeType> &expr) {
 
 FOR_EACH_INTEGER_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeInteger>;
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/fold-logical.cpp b/flang/lib/Evaluate/fold-logical.cpp
index ebffbb20c6f3..99b95a962443 100644
--- a/flang/lib/Evaluate/fold-logical.cpp
+++ b/flang/lib/Evaluate/fold-logical.cpp
@@ -11,7 +11,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Logical, KIND>> &&funcRef) {
@@ -21,7 +21,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
   CHECK(intrinsic);
   std::string name{intrinsic->name};
   if (name == "all") {
-    if (!args[1]) {  // TODO: ALL(x,DIM=d)
+    if (!args[1]) { // TODO: ALL(x,DIM=d)
       if (const auto *constant{UnwrapConstantValue<T>(args[0])}) {
         bool result{true};
         for (const auto &element : constant->values()) {
@@ -34,7 +34,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
       }
     }
   } else if (name == "any") {
-    if (!args[1]) {  // TODO: ANY(x,DIM=d)
+    if (!args[1]) { // TODO: ANY(x,DIM=d)
       if (const auto *constant{UnwrapConstantValue<T>(args[0])}) {
         bool result{false};
         for (const auto &element : constant->values()) {
@@ -61,7 +61,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
       }
     }
     auto fptr{&Scalar<LargestInt>::BGE};
-    if (name == "bge") {  // done in fptr declaration
+    if (name == "bge") { // done in fptr declaration
     } else if (name == "bgt") {
       fptr = &Scalar<LargestInt>::BGT;
     } else if (name == "ble") {
@@ -95,7 +95,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
   return Expr<T>{std::move(funcRef)};
 }
 
-template<typename T>
+template <typename T>
 Expr<LogicalResult> FoldOperation(
     FoldingContext &context, Relational<T> &&relation) {
   if (auto array{ApplyElementwise(context, relation,
@@ -133,7 +133,7 @@ Expr<LogicalResult> FoldOperation(
       std::move(relation.u));
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
     FoldingContext &context, Not<KIND> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
@@ -147,7 +147,7 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
   return Expr<Ty>{x};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
     FoldingContext &context, LogicalOperation<KIND> &&operation) {
   using LOGICAL = Type<TypeCategory::Logical, KIND>;
@@ -162,11 +162,20 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
   if (auto folded{OperandsAreConstants(operation)}) {
     bool xt{folded->first.IsTrue()}, yt{folded->second.IsTrue()}, result{};
     switch (operation.logicalOperator) {
-    case LogicalOperator::And: result = xt && yt; break;
-    case LogicalOperator::Or: result = xt || yt; break;
-    case LogicalOperator::Eqv: result = xt == yt; break;
-    case LogicalOperator::Neqv: result = xt != yt; break;
-    case LogicalOperator::Not: DIE("not a binary operator");
+    case LogicalOperator::And:
+      result = xt && yt;
+      break;
+    case LogicalOperator::Or:
+      result = xt || yt;
+      break;
+    case LogicalOperator::Eqv:
+      result = xt == yt;
+      break;
+    case LogicalOperator::Neqv:
+      result = xt != yt;
+      break;
+    case LogicalOperator::Not:
+      DIE("not a binary operator");
     }
     return Expr<LOGICAL>{Constant<LOGICAL>{result}};
   }
@@ -175,4 +184,4 @@ Expr<Type<TypeCategory::Logical, KIND>> FoldOperation(
 
 FOR_EACH_LOGICAL_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeLogical>;
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/fold-real.cpp b/flang/lib/Evaluate/fold-real.cpp
index 1a0d1d2cfd45..ee2ff5937462 100644
--- a/flang/lib/Evaluate/fold-real.cpp
+++ b/flang/lib/Evaluate/fold-real.cpp
@@ -10,7 +10,7 @@
 
 namespace Fortran::evaluate {
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> FoldIntrinsicFunction(
     FoldingContext &context,
     FunctionRef<Type<TypeCategory::Real, KIND>> &&funcRef) {
@@ -52,7 +52,7 @@ Expr<Type<TypeCategory::Real, KIND>> FoldIntrinsicFunction(
           name, KIND, KIND);
     }
   } else if (name == "bessel_jn" || name == "bessel_yn") {
-    if (args.size() == 2) {  // elemental
+    if (args.size() == 2) { // elemental
       // runtime functions use int arg
       using Int4 = Type<TypeCategory::Integer, 4>;
       if (auto callable{
@@ -135,7 +135,7 @@ Expr<Type<TypeCategory::Real, KIND>> FoldIntrinsicFunction(
   return Expr<T>{std::move(funcRef)};
 }
 
-template<int KIND>
+template <int KIND>
 Expr<Type<TypeCategory::Real, KIND>> FoldOperation(
     FoldingContext &context, ComplexComponent<KIND> &&x) {
   using Operand = Type<TypeCategory::Complex, KIND>;
@@ -162,4 +162,4 @@ Expr<Type<TypeCategory::Real, KIND>> FoldOperation(
 
 FOR_EACH_REAL_KIND(template class ExpressionBase, )
 template class ExpressionBase<SomeReal>;
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/fold.cpp b/flang/lib/Evaluate/fold.cpp
index 3ec4a2ed213d..b878bb351c42 100644
--- a/flang/lib/Evaluate/fold.cpp
+++ b/flang/lib/Evaluate/fold.cpp
@@ -85,16 +85,16 @@ Triplet FoldOperation(FoldingContext &context, Triplet &&triplet) {
 }
 
 Subscript FoldOperation(FoldingContext &context, Subscript &&subscript) {
-  return std::visit(
-      common::visitors{
-          [&](IndirectSubscriptIntegerExpr &&expr) {
-            expr.value() = Fold(context, std::move(expr.value()));
-            return Subscript(std::move(expr));
-          },
-          [&](Triplet &&triplet) {
-            return Subscript(FoldOperation(context, std::move(triplet)));
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](IndirectSubscriptIntegerExpr &&expr) {
+                          expr.value() = Fold(context, std::move(expr.value()));
+                          return Subscript(std::move(expr));
+                        },
+                        [&](Triplet &&triplet) {
+                          return Subscript(
+                              FoldOperation(context, std::move(triplet)));
+                        },
+                    },
       std::move(subscript.u));
 }
 
@@ -128,13 +128,12 @@ CoarrayRef FoldOperation(FoldingContext &context, CoarrayRef &&coarrayRef) {
 }
 
 DataRef FoldOperation(FoldingContext &context, DataRef &&dataRef) {
-  return std::visit(
-      common::visitors{
-          [&](SymbolRef symbol) { return DataRef{*symbol}; },
-          [&](auto &&x) {
-            return DataRef{FoldOperation(context, std::move(x))};
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](SymbolRef symbol) { return DataRef{*symbol}; },
+                        [&](auto &&x) {
+                          return DataRef{FoldOperation(context, std::move(x))};
+                        },
+                    },
       std::move(dataRef.u));
 }
 
@@ -188,4 +187,4 @@ Expr<ImpliedDoIndex::Result> FoldOperation(
 template class ExpressionBase<SomeDerived>;
 template class ExpressionBase<SomeType>;
 
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/formatting.cpp b/flang/lib/Evaluate/formatting.cpp
index adcc22865762..c2cbe4521d45 100644
--- a/flang/lib/Evaluate/formatting.cpp
+++ b/flang/lib/Evaluate/formatting.cpp
@@ -31,7 +31,7 @@ static void ShapeAsFortran(
   }
 }
 
-template<typename RESULT, typename VALUE>
+template <typename RESULT, typename VALUE>
 llvm::raw_ostream &ConstantBase<RESULT, VALUE>::AsFortran(
     llvm::raw_ostream &o) const {
   if (Rank() > 1) {
@@ -72,7 +72,7 @@ llvm::raw_ostream &ConstantBase<RESULT, VALUE>::AsFortran(
   return o;
 }
 
-template<int KIND>
+template <int KIND>
 llvm::raw_ostream &Constant<Type<TypeCategory::Character, KIND>>::AsFortran(
     llvm::raw_ostream &o) const {
   if (Rank() > 1) {
@@ -146,67 +146,71 @@ llvm::raw_ostream &ProcedureRef::AsFortran(llvm::raw_ostream &o) const {
 // Operator precedence formatting; insert parentheses around operands
 // only when necessary.
 
-enum class Precedence {  // in increasing order for sane comparisons
+enum class Precedence { // in increasing order for sane comparisons
   DefinedBinary,
   Or,
   And,
-  Equivalence,  // .EQV., .NEQV.
-  Not,  // which binds *less* tightly in Fortran than relations
+  Equivalence, // .EQV., .NEQV.
+  Not, // which binds *less* tightly in Fortran than relations
   Relational,
-  Additive,  // +, -, and (arbitrarily) //
-  Negate,  // which binds *less* tightly than *, /, **
-  Multiplicative,  // *, /
-  Power,  // **, which is right-associative unlike the other dyadic operators
+  Additive, // +, -, and (arbitrarily) //
+  Negate, // which binds *less* tightly than *, /, **
+  Multiplicative, // *, /
+  Power, // **, which is right-associative unlike the other dyadic operators
   DefinedUnary,
   Top,
 };
 
-template<typename A> constexpr Precedence ToPrecedence(const A &) {
+template <typename A> constexpr Precedence ToPrecedence(const A &) {
   return Precedence::Top;
 }
-template<int KIND>
+template <int KIND>
 static Precedence ToPrecedence(const LogicalOperation<KIND> &x) {
   switch (x.logicalOperator) {
     SWITCH_COVERS_ALL_CASES
-  case LogicalOperator::And: return Precedence::And;
-  case LogicalOperator::Or: return Precedence::Or;
-  case LogicalOperator::Not: return Precedence::Not;
+  case LogicalOperator::And:
+    return Precedence::And;
+  case LogicalOperator::Or:
+    return Precedence::Or;
+  case LogicalOperator::Not:
+    return Precedence::Not;
   case LogicalOperator::Eqv:
-  case LogicalOperator::Neqv: return Precedence::Equivalence;
+  case LogicalOperator::Neqv:
+    return Precedence::Equivalence;
   }
 }
-template<int KIND> constexpr Precedence ToPrecedence(const Not<KIND> &) {
+template <int KIND> constexpr Precedence ToPrecedence(const Not<KIND> &) {
   return Precedence::Not;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Relational<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Relational<T> &) {
   return Precedence::Relational;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Add<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Add<T> &) {
   return Precedence::Additive;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Subtract<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Subtract<T> &) {
   return Precedence::Additive;
 }
-template<int KIND> constexpr Precedence ToPrecedence(const Concat<KIND> &) {
+template <int KIND> constexpr Precedence ToPrecedence(const Concat<KIND> &) {
   return Precedence::Additive;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Negate<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Negate<T> &) {
   return Precedence::Negate;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Multiply<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Multiply<T> &) {
   return Precedence::Multiplicative;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Divide<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Divide<T> &) {
   return Precedence::Multiplicative;
 }
-template<typename T> constexpr Precedence ToPrecedence(const Power<T> &) {
+template <typename T> constexpr Precedence ToPrecedence(const Power<T> &) {
   return Precedence::Power;
 }
-template<typename T>
+template <typename T>
 constexpr Precedence ToPrecedence(const RealToIntPower<T> &) {
   return Precedence::Power;
 }
-template<typename T> static Precedence ToPrecedence(const Constant<T> &x) {
+template <typename T> static Precedence ToPrecedence(const Constant<T> &x) {
   static constexpr TypeCategory cat{T::category};
   if constexpr (cat == TypeCategory::Integer || cat == TypeCategory::Real) {
     if (auto n{GetScalarConstantValue<T>(x)}) {
@@ -217,11 +221,11 @@ template<typename T> static Precedence ToPrecedence(const Constant<T> &x) {
   }
   return Precedence::Top;
 }
-template<typename T> static Precedence ToPrecedence(const Expr<T> &expr) {
+template <typename T> static Precedence ToPrecedence(const Expr<T> &expr) {
   return std::visit([](const auto &x) { return ToPrecedence(x); }, expr.u);
 }
 
-template<typename T> static bool IsNegatedScalarConstant(const Expr<T> &expr) {
+template <typename T> static bool IsNegatedScalarConstant(const Expr<T> &expr) {
   static constexpr TypeCategory cat{T::category};
   if constexpr (cat == TypeCategory::Integer || cat == TypeCategory::Real) {
     if (auto n{GetScalarConstantValue<T>(expr)}) {
@@ -231,7 +235,7 @@ template<typename T> static bool IsNegatedScalarConstant(const Expr<T> &expr) {
   return false;
 }
 
-template<TypeCategory CAT>
+template <TypeCategory CAT>
 static bool IsNegatedScalarConstant(const Expr<SomeKind<CAT>> &expr) {
   return std::visit(
       [](const auto &x) { return IsNegatedScalarConstant(x); }, expr.u);
@@ -241,74 +245,75 @@ struct OperatorSpelling {
   const char *prefix{""}, *infix{","}, *suffix{""};
 };
 
-template<typename A> constexpr OperatorSpelling SpellOperator(const A &) {
+template <typename A> constexpr OperatorSpelling SpellOperator(const A &) {
   return OperatorSpelling{};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Negate<A> &) {
   return OperatorSpelling{"-", "", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Parentheses<A> &) {
   return OperatorSpelling{"(", "", ")"};
 }
-template<int KIND>
+template <int KIND>
 static OperatorSpelling SpellOperator(const ComplexComponent<KIND> &x) {
   return {x.isImaginaryPart ? "aimag(" : "real(", "", ")"};
 }
-template<int KIND> constexpr OperatorSpelling SpellOperator(const Not<KIND> &) {
+template <int KIND>
+constexpr OperatorSpelling SpellOperator(const Not<KIND> &) {
   return OperatorSpelling{".NOT.", "", ""};
 }
-template<int KIND>
+template <int KIND>
 constexpr OperatorSpelling SpellOperator(const SetLength<KIND> &) {
   return OperatorSpelling{"%SET_LENGTH(", ",", ")"};
 }
-template<int KIND>
+template <int KIND>
 constexpr OperatorSpelling SpellOperator(const ComplexConstructor<KIND> &) {
   return OperatorSpelling{"(", ",", ")"};
 }
-template<typename A> constexpr OperatorSpelling SpellOperator(const Add<A> &) {
+template <typename A> constexpr OperatorSpelling SpellOperator(const Add<A> &) {
   return OperatorSpelling{"", "+", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Subtract<A> &) {
   return OperatorSpelling{"", "-", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Multiply<A> &) {
   return OperatorSpelling{"", "*", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Divide<A> &) {
   return OperatorSpelling{"", "/", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const Power<A> &) {
   return OperatorSpelling{"", "**", ""};
 }
-template<typename A>
+template <typename A>
 constexpr OperatorSpelling SpellOperator(const RealToIntPower<A> &) {
   return OperatorSpelling{"", "**", ""};
 }
-template<typename A>
+template <typename A>
 static OperatorSpelling SpellOperator(const Extremum<A> &x) {
   return OperatorSpelling{
       x.ordering == Ordering::Less ? "min(" : "max(", ",", ")"};
 }
-template<int KIND>
+template <int KIND>
 constexpr OperatorSpelling SpellOperator(const Concat<KIND> &) {
   return OperatorSpelling{"", "//", ""};
 }
-template<int KIND>
+template <int KIND>
 static OperatorSpelling SpellOperator(const LogicalOperation<KIND> &x) {
   return OperatorSpelling{"", AsFortran(x.logicalOperator), ""};
 }
-template<typename T>
+template <typename T>
 static OperatorSpelling SpellOperator(const Relational<T> &x) {
   return OperatorSpelling{"", AsFortran(x.opr), ""};
 }
 
-template<typename D, typename R, typename... O>
+template <typename D, typename R, typename... O>
 llvm::raw_ostream &Operation<D, R, O...>::AsFortran(
     llvm::raw_ostream &o) const {
   Precedence lhsPrec{ToPrecedence(left())};
@@ -340,7 +345,7 @@ llvm::raw_ostream &Operation<D, R, O...>::AsFortran(
   return o << spelling.suffix;
 }
 
-template<typename TO, TypeCategory FROMCAT>
+template <typename TO, TypeCategory FROMCAT>
 llvm::raw_ostream &Convert<TO, FROMCAT>::AsFortran(llvm::raw_ostream &o) const {
   static_assert(TO::category == TypeCategory::Integer ||
           TO::category == TypeCategory::Real ||
@@ -364,16 +369,16 @@ llvm::raw_ostream &Relational<SomeType>::AsFortran(llvm::raw_ostream &o) const {
   return o;
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const Expr<T> &expr) {
   return expr.AsFortran(o);
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &EmitArray(
     llvm::raw_ostream &, const ArrayConstructorValues<T> &);
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const ImpliedDo<T> &implDo) {
   o << '(';
   EmitArray(o, implDo.values());
@@ -385,7 +390,7 @@ llvm::raw_ostream &EmitArray(llvm::raw_ostream &o, const ImpliedDo<T> &implDo) {
   return o;
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &EmitArray(
     llvm::raw_ostream &o, const ArrayConstructorValues<T> &values) {
   const char *sep{""};
@@ -397,14 +402,14 @@ llvm::raw_ostream &EmitArray(
   return o;
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &ArrayConstructor<T>::AsFortran(llvm::raw_ostream &o) const {
   o << '[' << GetType().AsFortran() << "::";
   EmitArray(o, *this);
   return o << ']';
 }
 
-template<int KIND>
+template <int KIND>
 llvm::raw_ostream &
 ArrayConstructor<Type<TypeCategory::Character, KIND>>::AsFortran(
     llvm::raw_ostream &o) const {
@@ -420,7 +425,7 @@ llvm::raw_ostream &ArrayConstructor<SomeDerived>::AsFortran(
   return o << ']';
 }
 
-template<typename RESULT>
+template <typename RESULT>
 std::string ExpressionBase<RESULT>::AsFortran() const {
   std::string buf;
   llvm::raw_string_ostream ss{buf};
@@ -428,21 +433,20 @@ std::string ExpressionBase<RESULT>::AsFortran() const {
   return ss.str();
 }
 
-template<typename RESULT>
+template <typename RESULT>
 llvm::raw_ostream &ExpressionBase<RESULT>::AsFortran(
     llvm::raw_ostream &o) const {
-  std::visit(
-      common::visitors{
-          [&](const BOZLiteralConstant &x) {
-            o << "z'" << x.Hexadecimal() << "'";
-          },
-          [&](const NullPointer &) { o << "NULL()"; },
-          [&](const common::CopyableIndirection<Substring> &s) {
-            s.value().AsFortran(o);
-          },
-          [&](const ImpliedDoIndex &i) { o << i.name.ToString(); },
-          [&](const auto &x) { x.AsFortran(o); },
-      },
+  std::visit(common::visitors{
+                 [&](const BOZLiteralConstant &x) {
+                   o << "z'" << x.Hexadecimal() << "'";
+                 },
+                 [&](const NullPointer &) { o << "NULL()"; },
+                 [&](const common::CopyableIndirection<Substring> &s) {
+                   s.value().AsFortran(o);
+                 },
+                 [&](const ImpliedDoIndex &i) { o << i.name.ToString(); },
+                 [&](const auto &x) { x.AsFortran(o); },
+             },
       derived().u);
   return o;
 }
@@ -542,17 +546,17 @@ llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::u32string &lit) {
   return o << parser::QuoteCharacterLiteral(lit);
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const A &x) {
   return x.AsFortran(o);
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, common::Reference<A> x) {
   return EmitVar(o, *x);
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(
     llvm::raw_ostream &o, const A *p, const char *kw = nullptr) {
   if (p) {
@@ -564,7 +568,7 @@ llvm::raw_ostream &EmitVar(
   return o;
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(
     llvm::raw_ostream &o, const std::optional<A> &x, const char *kw = nullptr) {
   if (x) {
@@ -576,7 +580,7 @@ llvm::raw_ostream &EmitVar(
   return o;
 }
 
-template<typename A, bool COPY>
+template <typename A, bool COPY>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o,
     const common::Indirection<A, COPY> &p, const char *kw = nullptr) {
   if (kw) {
@@ -586,13 +590,13 @@ llvm::raw_ostream &EmitVar(llvm::raw_ostream &o,
   return o;
 }
 
-template<typename A>
+template <typename A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::shared_ptr<A> &p) {
   CHECK(p);
   return EmitVar(o, *p);
 }
 
-template<typename... A>
+template <typename... A>
 llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::variant<A...> &u) {
   std::visit([&](const auto &x) { EmitVar(o, x); }, u);
   return o;
@@ -602,7 +606,7 @@ llvm::raw_ostream &BaseObject::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
-template<int KIND>
+template <int KIND>
 llvm::raw_ostream &TypeParamInquiry<KIND>::AsFortran(
     llvm::raw_ostream &o) const {
   if (base_) {
@@ -617,11 +621,10 @@ llvm::raw_ostream &Component::AsFortran(llvm::raw_ostream &o) const {
 }
 
 llvm::raw_ostream &NamedEntity::AsFortran(llvm::raw_ostream &o) const {
-  std::visit(
-      common::visitors{
-          [&](SymbolRef s) { EmitVar(o, s); },
-          [&](const Component &c) { c.AsFortran(o); },
-      },
+  std::visit(common::visitors{
+                 [&](SymbolRef s) { EmitVar(o, s); },
+                 [&](const Component &c) { c.AsFortran(o); },
+             },
       u_);
   return o;
 }
@@ -699,24 +702,32 @@ llvm::raw_ostream &ProcedureDesignator::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
-template<typename T>
+template <typename T>
 llvm::raw_ostream &Designator<T>::AsFortran(llvm::raw_ostream &o) const {
-  std::visit(
-      common::visitors{
-          [&](SymbolRef symbol) { EmitVar(o, symbol); },
-          [&](const auto &x) { x.AsFortran(o); },
-      },
+  std::visit(common::visitors{
+                 [&](SymbolRef symbol) { EmitVar(o, symbol); },
+                 [&](const auto &x) { x.AsFortran(o); },
+             },
       u);
   return o;
 }
 
 llvm::raw_ostream &DescriptorInquiry::AsFortran(llvm::raw_ostream &o) const {
   switch (field_) {
-  case Field::LowerBound: o << "lbound("; break;
-  case Field::Extent: o << "size("; break;
-  case Field::Stride: o << "%STRIDE("; break;
-  case Field::Rank: o << "rank("; break;
-  case Field::Len: break;
+  case Field::LowerBound:
+    o << "lbound(";
+    break;
+  case Field::Extent:
+    o << "size(";
+    break;
+  case Field::Stride:
+    o << "%STRIDE(";
+    break;
+  case Field::Rank:
+    o << "rank(";
+    break;
+  case Field::Len:
+    break;
   }
   base_.AsFortran(o);
   if (field_ == Field::Len) {
@@ -769,4 +780,4 @@ llvm::raw_ostream &Assignment::AsFortran(llvm::raw_ostream &o) const {
 INSTANTIATE_CONSTANT_TEMPLATES
 INSTANTIATE_EXPRESSION_TEMPLATES
 INSTANTIATE_VARIABLE_TEMPLATES
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/host.cpp b/flang/lib/Evaluate/host.cpp
index bc55d53fc2e3..ea831274b942 100644
--- a/flang/lib/Evaluate/host.cpp
+++ b/flang/lib/Evaluate/host.cpp
@@ -31,26 +31,26 @@ void HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment(
 #if __x86_64__
   hasSubnormalFlushingHardwareControl_ = true;
   if (context.flushSubnormalsToZero()) {
-    currentFenv_.__mxcsr |= 0x8000;  // result
-    currentFenv_.__mxcsr |= 0x0040;  // operands
+    currentFenv_.__mxcsr |= 0x8000; // result
+    currentFenv_.__mxcsr |= 0x0040; // operands
   } else {
-    currentFenv_.__mxcsr &= ~0x8000;  // result
-    currentFenv_.__mxcsr &= ~0x0040;  // operands
+    currentFenv_.__mxcsr &= ~0x8000; // result
+    currentFenv_.__mxcsr &= ~0x0040; // operands
   }
 #elif defined(__aarch64__)
 #if defined(__GNU_LIBRARY__)
   hasSubnormalFlushingHardwareControl_ = true;
   if (context.flushSubnormalsToZero()) {
-    currentFenv_.__fpcr |= (1U << 24);  // control register
+    currentFenv_.__fpcr |= (1U << 24); // control register
   } else {
-    currentFenv_.__fpcr &= ~(1U << 24);  // control register
+    currentFenv_.__fpcr &= ~(1U << 24); // control register
   }
 #elif defined(__BIONIC__)
   hasSubnormalFlushingHardwareControl_ = true;
   if (context.flushSubnormalsToZero()) {
-    currentFenv_.__control |= (1U << 24);  // control register
+    currentFenv_.__control |= (1U << 24); // control register
   } else {
-    currentFenv_.__control &= ~(1U << 24);  // control register
+    currentFenv_.__control &= ~(1U << 24); // control register
   }
 #else
   // If F18 is built with other C libraries on AArch64, software flushing will
@@ -76,10 +76,18 @@ void HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment(
     return;
   }
   switch (context.rounding().mode) {
-  case common::RoundingMode::TiesToEven: fesetround(FE_TONEAREST); break;
-  case common::RoundingMode::ToZero: fesetround(FE_TOWARDZERO); break;
-  case common::RoundingMode::Up: fesetround(FE_UPWARD); break;
-  case common::RoundingMode::Down: fesetround(FE_DOWNWARD); break;
+  case common::RoundingMode::TiesToEven:
+    fesetround(FE_TONEAREST);
+    break;
+  case common::RoundingMode::ToZero:
+    fesetround(FE_TOWARDZERO);
+    break;
+  case common::RoundingMode::Up:
+    fesetround(FE_UPWARD);
+    break;
+  case common::RoundingMode::Down:
+    fesetround(FE_DOWNWARD);
+    break;
   case common::RoundingMode::TiesAwayFromZero:
     fesetround(FE_TONEAREST);
     context.messages().Say(
@@ -135,4 +143,4 @@ void HostFloatingPointEnvironment::CheckAndRestoreFloatingPointEnvironment(
   }
   errno = 0;
 }
-}
+} // namespace Fortran::evaluate::host
diff --git a/flang/lib/Evaluate/host.h b/flang/lib/Evaluate/host.h
index cb7d5806f0cf..20355ae3147a 100644
--- a/flang/lib/Evaluate/host.h
+++ b/flang/lib/Evaluate/host.h
@@ -48,14 +48,14 @@ private:
 };
 
 // Type mapping from F18 types to host types
-struct UnsupportedType {};  // There is no host type for the F18 type
+struct UnsupportedType {}; // There is no host type for the F18 type
 
-template<typename FTN_T> struct HostTypeHelper {
+template <typename FTN_T> struct HostTypeHelper {
   using Type = UnsupportedType;
 };
-template<typename FTN_T> using HostType = typename HostTypeHelper<FTN_T>::Type;
+template <typename FTN_T> using HostType = typename HostTypeHelper<FTN_T>::Type;
 
-template<typename... T> constexpr inline bool HostTypeExists() {
+template <typename... T> constexpr inline bool HostTypeExists() {
   return (... && (!std::is_same_v<HostType<T>, UnsupportedType>));
 }
 
@@ -64,7 +64,7 @@ template<typename... T> constexpr inline bool HostTypeExists() {
 // duplication.
 
 // Scalar conversion utilities from host scalars to F18 scalars
-template<typename FTN_T>
+template <typename FTN_T>
 inline constexpr Scalar<FTN_T> CastHostToFortran(const HostType<FTN_T> &x) {
   static_assert(HostTypeExists<FTN_T>());
   if constexpr (FTN_T::category == TypeCategory::Complex &&
@@ -79,7 +79,7 @@ inline constexpr Scalar<FTN_T> CastHostToFortran(const HostType<FTN_T> &x) {
 }
 
 // Scalar conversion utilities from  F18 scalars to host scalars
-template<typename FTN_T>
+template <typename FTN_T>
 inline constexpr HostType<FTN_T> CastFortranToHost(const Scalar<FTN_T> &x) {
   static_assert(HostTypeExists<FTN_T>());
   if constexpr (FTN_T::category == TypeCategory::Complex &&
@@ -93,40 +93,40 @@ inline constexpr HostType<FTN_T> CastFortranToHost(const Scalar<FTN_T> &x) {
   }
 }
 
-template<typename T> struct BiggerOrSameHostTypeHelper {
+template <typename T> struct BiggerOrSameHostTypeHelper {
   using Type =
       std::conditional_t<HostTypeExists<T>(), HostType<T>, UnsupportedType>;
   using FortranType = T;
 };
 
-template<typename FTN_T>
+template <typename FTN_T>
 using BiggerOrSameHostType = typename BiggerOrSameHostTypeHelper<FTN_T>::Type;
-template<typename FTN_T>
+template <typename FTN_T>
 using BiggerOrSameFortranTypeSupportedOnHost =
     typename BiggerOrSameHostTypeHelper<FTN_T>::FortranType;
 
-template<typename... T> constexpr inline bool BiggerOrSameHostTypeExists() {
+template <typename... T> constexpr inline bool BiggerOrSameHostTypeExists() {
   return (... && (!std::is_same_v<BiggerOrSameHostType<T>, UnsupportedType>));
 }
 
 // Defining the actual mapping
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 1>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 1>> {
   using Type = std::int8_t;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 2>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 2>> {
   using Type = std::int16_t;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 4>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 4>> {
   using Type = std::int32_t;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 8>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 8>> {
   using Type = std::int64_t;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Integer, 16>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Integer, 16>> {
 #if (defined(__GNUC__) || defined(__clang__)) && defined(__SIZEOF_INT128__)
   using Type = __int128_t;
 #else
@@ -137,21 +137,21 @@ template<> struct HostTypeHelper<Type<TypeCategory::Integer, 16>> {
 // TODO no mapping to host types are defined currently for 16bits float
 // It should be defined when gcc/clang have a better support for it.
 
-template<> struct HostTypeHelper<Type<TypeCategory::Real, 4>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 4>> {
   // IEE 754 64bits
   using Type = std::conditional_t<sizeof(float) == 4 &&
           std::numeric_limits<float>::is_iec559,
       float, UnsupportedType>;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Real, 8>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 8>> {
   // IEE 754 64bits
   using Type = std::conditional_t<sizeof(double) == 8 &&
           std::numeric_limits<double>::is_iec559,
       double, UnsupportedType>;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Real, 10>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 10>> {
   // X87 80bits
   using Type = std::conditional_t<sizeof(long double) >= 10 &&
           std::numeric_limits<long double>::digits == 64 &&
@@ -159,7 +159,7 @@ template<> struct HostTypeHelper<Type<TypeCategory::Real, 10>> {
       long double, UnsupportedType>;
 };
 
-template<> struct HostTypeHelper<Type<TypeCategory::Real, 16>> {
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 16>> {
   // IEE 754 128bits
   using Type = std::conditional_t<sizeof(long double) == 16 &&
           std::numeric_limits<long double>::digits == 113 &&
@@ -167,30 +167,30 @@ template<> struct HostTypeHelper<Type<TypeCategory::Real, 16>> {
       long double, UnsupportedType>;
 };
 
-template<int KIND> struct HostTypeHelper<Type<TypeCategory::Complex, KIND>> {
+template <int KIND> struct HostTypeHelper<Type<TypeCategory::Complex, KIND>> {
   using RealT = Fortran::evaluate::Type<TypeCategory::Real, KIND>;
   using Type = std::conditional_t<HostTypeExists<RealT>(),
       std::complex<HostType<RealT>>, UnsupportedType>;
 };
 
-template<int KIND> struct HostTypeHelper<Type<TypeCategory::Logical, KIND>> {
+template <int KIND> struct HostTypeHelper<Type<TypeCategory::Logical, KIND>> {
   using Type = std::conditional_t<KIND <= 8, std::uint8_t, UnsupportedType>;
 };
 
-template<int KIND> struct HostTypeHelper<Type<TypeCategory::Character, KIND>> {
+template <int KIND> struct HostTypeHelper<Type<TypeCategory::Character, KIND>> {
   using Type =
       Scalar<typename Fortran::evaluate::Type<TypeCategory::Character, KIND>>;
 };
 
 // Type mapping from host types to F18 types. This need to be placed after all
 // HostTypeHelper specializations.
-template<typename T, typename... TT> struct IndexInTupleHelper {};
-template<typename T, typename... TT>
+template <typename T, typename... TT> struct IndexInTupleHelper {};
+template <typename T, typename... TT>
 struct IndexInTupleHelper<T, std::tuple<TT...>> {
   static constexpr int value{common::TypeIndex<T, TT...>};
 };
-struct UnknownType {};  // the host type does not match any F18 types
-template<typename HOST_T> struct FortranTypeHelper {
+struct UnknownType {}; // the host type does not match any F18 types
+template <typename HOST_T> struct FortranTypeHelper {
   using HostTypeMapping =
       common::MapTemplate<HostType, AllIntrinsicTypes, std::tuple>;
   static constexpr int index{
@@ -202,38 +202,38 @@ template<typename HOST_T> struct FortranTypeHelper {
       UnknownType>;
 };
 
-template<typename HOST_T>
+template <typename HOST_T>
 using FortranType = typename FortranTypeHelper<HOST_T>::Type;
 
-template<typename... HT> constexpr inline bool FortranTypeExists() {
+template <typename... HT> constexpr inline bool FortranTypeExists() {
   return (... && (!std::is_same_v<FortranType<HT>, UnknownType>));
 }
 
 // Utility to find "bigger" types that exist on host. By bigger, it is meant
 // that the bigger type can represent all the values of the smaller types
 // without information loss.
-template<TypeCategory cat, int KIND> struct NextBiggerReal {
+template <TypeCategory cat, int KIND> struct NextBiggerReal {
   using Type = void;
 };
-template<TypeCategory cat> struct NextBiggerReal<cat, 2> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 2> {
   using Type = Fortran::evaluate::Type<cat, 4>;
 };
-template<TypeCategory cat> struct NextBiggerReal<cat, 3> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 3> {
   using Type = Fortran::evaluate::Type<cat, 4>;
 };
-template<TypeCategory cat> struct NextBiggerReal<cat, 4> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 4> {
   using Type = Fortran::evaluate::Type<cat, 8>;
 };
 
-template<TypeCategory cat> struct NextBiggerReal<cat, 8> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 8> {
   using Type = Fortran::evaluate::Type<cat, 10>;
 };
 
-template<TypeCategory cat> struct NextBiggerReal<cat, 10> {
+template <TypeCategory cat> struct NextBiggerReal<cat, 10> {
   using Type = Fortran::evaluate::Type<cat, 16>;
 };
 
-template<int KIND>
+template <int KIND>
 struct BiggerOrSameHostTypeHelper<Type<TypeCategory::Real, KIND>> {
   using T = Fortran::evaluate::Type<TypeCategory::Real, KIND>;
   using NextT = typename NextBiggerReal<TypeCategory::Real, KIND>::Type;
@@ -243,7 +243,7 @@ struct BiggerOrSameHostTypeHelper<Type<TypeCategory::Real, KIND>> {
       typename BiggerOrSameHostTypeHelper<NextT>::FortranType>;
 };
 
-template<int KIND>
+template <int KIND>
 struct BiggerOrSameHostTypeHelper<Type<TypeCategory::Complex, KIND>> {
   using T = Fortran::evaluate::Type<TypeCategory::Complex, KIND>;
   using NextT = typename NextBiggerReal<TypeCategory::Complex, KIND>::Type;
@@ -252,7 +252,7 @@ struct BiggerOrSameHostTypeHelper<Type<TypeCategory::Complex, KIND>> {
   using FortranType = std::conditional_t<HostTypeExists<T>(), T,
       typename BiggerOrSameHostTypeHelper<NextT>::FortranType>;
 };
-}
-}
+} // namespace host
+} // namespace Fortran::evaluate
 
-#endif  // FORTRAN_EVALUATE_HOST_H_
+#endif // FORTRAN_EVALUATE_HOST_H_
diff --git a/flang/lib/Evaluate/int-power.h b/flang/lib/Evaluate/int-power.h
index 5ab16cd6d209..e700cacd380f 100644
--- a/flang/lib/Evaluate/int-power.h
+++ b/flang/lib/Evaluate/int-power.h
@@ -15,7 +15,7 @@
 
 namespace Fortran::evaluate {
 
-template<typename REAL, typename INT>
+template <typename REAL, typename INT>
 ValueWithRealFlags<REAL> TimesIntPowerOf(const REAL &factor, const REAL &base,
     const INT &power, Rounding rounding = defaultRounding) {
   ValueWithRealFlags<REAL> result{factor};
@@ -48,11 +48,11 @@ ValueWithRealFlags<REAL> TimesIntPowerOf(const REAL &factor, const REAL &base,
   return result;
 }
 
-template<typename REAL, typename INT>
+template <typename REAL, typename INT>
 ValueWithRealFlags<REAL> IntPower(
     const REAL &base, const INT &power, Rounding rounding = defaultRounding) {
   REAL one{REAL::FromInteger(INT{1}).value};
   return TimesIntPowerOf(one, base, power, rounding);
 }
-}
-#endif  // FORTRAN_EVALUATE_INT_POWER_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_INT_POWER_H_
diff --git a/flang/lib/Evaluate/integer.cpp b/flang/lib/Evaluate/integer.cpp
index 074bee7b9fb8..e8173b44e873 100644
--- a/flang/lib/Evaluate/integer.cpp
+++ b/flang/lib/Evaluate/integer.cpp
@@ -28,4 +28,4 @@ static_assert(Integer<64>::partBits == 32);
 static_assert(std::is_same_v<typename Integer<64>::Part, std::uint32_t>);
 static_assert(Integer<128>::partBits == 32);
 static_assert(std::is_same_v<typename Integer<128>::Part, std::uint32_t>);
-}
+} // namespace Fortran::evaluate::value
diff --git a/flang/lib/Evaluate/intrinsics-library-templates.h b/flang/lib/Evaluate/intrinsics-library-templates.h
index 268a50718992..8accd2bbbd28 100644
--- a/flang/lib/Evaluate/intrinsics-library-templates.h
+++ b/flang/lib/Evaluate/intrinsics-library-templates.h
@@ -29,8 +29,8 @@ namespace Fortran::evaluate {
 // Define meaningful types for the runtime
 using RuntimeTypes = evaluate::AllIntrinsicTypes;
 
-template<typename T, typename... TT> struct IndexInTupleHelper {};
-template<typename T, typename... TT>
+template <typename T, typename... TT> struct IndexInTupleHelper {};
+template <typename T, typename... TT>
 struct IndexInTupleHelper<T, std::tuple<TT...>> {
   static constexpr TypeCode value{common::TypeIndex<T, TT...>};
 };
@@ -38,36 +38,36 @@ struct IndexInTupleHelper<T, std::tuple<TT...>> {
 static_assert(
     std::tuple_size_v<RuntimeTypes> < std::numeric_limits<TypeCode>::max(),
     "TypeCode is too small");
-template<typename T>
+template <typename T>
 inline constexpr TypeCode typeCodeOf{
     IndexInTupleHelper<T, RuntimeTypes>::value};
 
-template<TypeCode n>
+template <TypeCode n>
 using RuntimeTypeOf = typename std::tuple_element_t<n, RuntimeTypes>;
 
-template<typename TA, PassBy Pass>
+template <typename TA, PassBy Pass>
 using HostArgType = std::conditional_t<Pass == PassBy::Ref,
     std::add_lvalue_reference_t<std::add_const_t<host::HostType<TA>>>,
     host::HostType<TA>>;
 
-template<typename TR, typename... ArgInfo>
+template <typename TR, typename... ArgInfo>
 using HostFuncPointer = FuncPointer<host::HostType<TR>,
     HostArgType<typename ArgInfo::Type, ArgInfo::pass>...>;
 
 // Software Subnormal Flushing helper.
-template<typename T> struct Flusher {
+template <typename T> struct Flusher {
   // Only flush floating-points. Forward other scalars untouched.
   static constexpr inline const Scalar<T> &FlushSubnormals(const Scalar<T> &x) {
     return x;
   }
 };
-template<int Kind> struct Flusher<Type<TypeCategory::Real, Kind>> {
+template <int Kind> struct Flusher<Type<TypeCategory::Real, Kind>> {
   using T = Type<TypeCategory::Real, Kind>;
   static constexpr inline Scalar<T> FlushSubnormals(const Scalar<T> &x) {
     return x.FlushSubnormalToZero();
   }
 };
-template<int Kind> struct Flusher<Type<TypeCategory::Complex, Kind>> {
+template <int Kind> struct Flusher<Type<TypeCategory::Complex, Kind>> {
   using T = Type<TypeCategory::Complex, Kind>;
   static constexpr inline Scalar<T> FlushSubnormals(const Scalar<T> &x) {
     return x.FlushSubnormalToZero();
@@ -75,7 +75,7 @@ template<int Kind> struct Flusher<Type<TypeCategory::Complex, Kind>> {
 };
 
 // Callable factory
-template<typename TR, typename... ArgInfo> struct CallableHostWrapper {
+template <typename TR, typename... ArgInfo> struct CallableHostWrapper {
   static Scalar<TR> scalarCallable(FoldingContext &context,
       HostFuncPointer<TR, ArgInfo...> func,
       const Scalar<typename ArgInfo::Type> &... x) {
@@ -120,28 +120,28 @@ template<typename TR, typename... ArgInfo> struct CallableHostWrapper {
   }
 };
 
-template<typename TR, typename... TA>
+template <typename TR, typename... TA>
 inline GenericFunctionPointer ToGenericFunctionPointer(
     FuncPointer<TR, TA...> f) {
   return reinterpret_cast<GenericFunctionPointer>(f);
 }
 
-template<typename TR, typename... TA>
+template <typename TR, typename... TA>
 inline FuncPointer<TR, TA...> FromGenericFunctionPointer(
     GenericFunctionPointer g) {
   return reinterpret_cast<FuncPointer<TR, TA...>>(g);
 }
 
-template<typename TR, typename... ArgInfo>
+template <typename TR, typename... ArgInfo>
 IntrinsicProcedureRuntimeDescription::IntrinsicProcedureRuntimeDescription(
     const Signature<TR, ArgInfo...> &signature, bool isElemental)
-  : name{signature.name}, returnType{typeCodeOf<TR>},
-    argumentsType{typeCodeOf<typename ArgInfo::Type>...},
-    argumentsPassedBy{ArgInfo::pass...}, isElemental{isElemental},
-    callable{ToGenericFunctionPointer(
-        CallableHostWrapper<TR, ArgInfo...>::MakeScalarCallable())} {}
+    : name{signature.name}, returnType{typeCodeOf<TR>},
+      argumentsType{typeCodeOf<typename ArgInfo::Type>...},
+      argumentsPassedBy{ArgInfo::pass...}, isElemental{isElemental},
+      callable{ToGenericFunctionPointer(
+          CallableHostWrapper<TR, ArgInfo...>::MakeScalarCallable())} {}
 
-template<typename HostTA> static constexpr inline PassBy PassByMethod() {
+template <typename HostTA> static constexpr inline PassBy PassByMethod() {
   if constexpr (std::is_pointer_v<std::decay_t<HostTA>> ||
       std::is_lvalue_reference_v<HostTA>) {
     return PassBy::Ref;
@@ -149,24 +149,24 @@ template<typename HostTA> static constexpr inline PassBy PassByMethod() {
   return PassBy::Val;
 }
 
-template<typename HostTA>
+template <typename HostTA>
 using ArgInfoFromHostType =
     ArgumentInfo<host::FortranType<std::remove_pointer_t<std::decay_t<HostTA>>>,
         PassByMethod<HostTA>()>;
 
-template<typename HostTR, typename... HostTA>
+template <typename HostTR, typename... HostTA>
 using SignatureFromHostFuncPointer =
     Signature<host::FortranType<HostTR>, ArgInfoFromHostType<HostTA>...>;
 
-template<typename HostTR, typename... HostTA>
+template <typename HostTR, typename... HostTA>
 HostRuntimeIntrinsicProcedure::HostRuntimeIntrinsicProcedure(
     const std::string &name, FuncPointer<HostTR, HostTA...> func,
     bool isElemental)
-  : IntrinsicProcedureRuntimeDescription(
-        SignatureFromHostFuncPointer<HostTR, HostTA...>{name}, isElemental),
-    handle{ToGenericFunctionPointer(func)} {}
+    : IntrinsicProcedureRuntimeDescription(
+          SignatureFromHostFuncPointer<HostTR, HostTA...>{name}, isElemental),
+      handle{ToGenericFunctionPointer(func)} {}
 
-template<template<typename> typename ConstantContainer, typename TR,
+template <template <typename> typename ConstantContainer, typename TR,
     typename... TA>
 std::optional<HostProcedureWrapper<ConstantContainer, TR, TA...>>
 HostIntrinsicProceduresLibrary::GetHostProcedureWrapper(
@@ -205,5 +205,5 @@ HostIntrinsicProceduresLibrary::GetHostProcedureWrapper(
   return std::nullopt;
 }
 
-}
-#endif  // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_TEMPLATES_H_
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_TEMPLATES_H_
diff --git a/flang/lib/Evaluate/intrinsics-library.cpp b/flang/lib/Evaluate/intrinsics-library.cpp
index 9636179d01e4..84c71e145bb6 100644
--- a/flang/lib/Evaluate/intrinsics-library.cpp
+++ b/flang/lib/Evaluate/intrinsics-library.cpp
@@ -46,7 +46,7 @@ bool HostIntrinsicProceduresLibrary::HasEquivalentProcedure(
 
 // Define which host runtime functions will be used for folding
 
-template<typename HostT>
+template <typename HostT>
 static void AddLibmRealHostProcedures(
     HostIntrinsicProceduresLibrary &hostIntrinsicLibrary) {
   using F = FuncPointer<HostT, HostT>;
@@ -96,7 +96,7 @@ static void AddLibmRealHostProcedures(
   }
 }
 
-template<typename HostT>
+template <typename HostT>
 static void AddLibmComplexHostProcedures(
     HostIntrinsicProceduresLibrary &hostIntrinsicLibrary) {
   using F = FuncPointer<std::complex<HostT>, const std::complex<HostT> &>;
@@ -207,21 +207,21 @@ enum class I {
 enum class L { F, R, P };
 
 struct NoSuchRuntimeSymbol {};
-template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
+template <L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 
 // Macros to declare fast/relaxed/precise libpgmath variants.
 #define DECLARE_PGMATH_FAST_REAL(func) \
   extern "C" float __fs_##func##_1(float); \
   extern "C" double __fd_##func##_1(double); \
-  template<> constexpr auto Sym<L::F, I::func, float>{__fs_##func##_1}; \
-  template<> constexpr auto Sym<L::F, I::func, double>{__fd_##func##_1};
+  template <> constexpr auto Sym<L::F, I::func, float>{__fs_##func##_1}; \
+  template <> constexpr auto Sym<L::F, I::func, double>{__fd_##func##_1};
 
 #define DECLARE_PGMATH_FAST_COMPLEX(func) \
   extern "C" float _Complex __fc_##func##_1(float _Complex); \
   extern "C" double _Complex __fz_##func##_1(double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::F, I::func, std::complex<float>>{__fc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::F, I::func, std::complex<double>>{__fz_##func##_1};
 
 #define DECLARE_PGMATH_FAST_ALL_FP(func) \
@@ -231,15 +231,15 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_PRECISE_REAL(func) \
   extern "C" float __ps_##func##_1(float); \
   extern "C" double __pd_##func##_1(double); \
-  template<> constexpr auto Sym<L::P, I::func, float>{__ps_##func##_1}; \
-  template<> constexpr auto Sym<L::P, I::func, double>{__pd_##func##_1};
+  template <> constexpr auto Sym<L::P, I::func, float>{__ps_##func##_1}; \
+  template <> constexpr auto Sym<L::P, I::func, double>{__pd_##func##_1};
 
 #define DECLARE_PGMATH_PRECISE_COMPLEX(func) \
   extern "C" float _Complex __pc_##func##_1(float _Complex); \
   extern "C" double _Complex __pz_##func##_1(double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::P, I::func, std::complex<float>>{__pc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::P, I::func, std::complex<double>>{__pz_##func##_1};
 
 #define DECLARE_PGMATH_PRECISE_ALL_FP(func) \
@@ -249,15 +249,15 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_RELAXED_REAL(func) \
   extern "C" float __rs_##func##_1(float); \
   extern "C" double __rd_##func##_1(double); \
-  template<> constexpr auto Sym<L::R, I::func, float>{__rs_##func##_1}; \
-  template<> constexpr auto Sym<L::R, I::func, double>{__rd_##func##_1};
+  template <> constexpr auto Sym<L::R, I::func, float>{__rs_##func##_1}; \
+  template <> constexpr auto Sym<L::R, I::func, double>{__rd_##func##_1};
 
 #define DECLARE_PGMATH_RELAXED_COMPLEX(func) \
   extern "C" float _Complex __rc_##func##_1(float _Complex); \
   extern "C" double _Complex __rz_##func##_1(double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::R, I::func, std::complex<float>>{__rc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::R, I::func, std::complex<double>>{__rz_##func##_1};
 
 #define DECLARE_PGMATH_RELAXED_ALL_FP(func) \
@@ -282,16 +282,16 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_FAST_REAL2(func) \
   extern "C" float __fs_##func##_1(float, float); \
   extern "C" double __fd_##func##_1(double, double); \
-  template<> constexpr auto Sym<L::F, I::func, float>{__fs_##func##_1}; \
-  template<> constexpr auto Sym<L::F, I::func, double>{__fd_##func##_1};
+  template <> constexpr auto Sym<L::F, I::func, float>{__fs_##func##_1}; \
+  template <> constexpr auto Sym<L::F, I::func, double>{__fd_##func##_1};
 
 #define DECLARE_PGMATH_FAST_COMPLEX2(func) \
   extern "C" float _Complex __fc_##func##_1(float _Complex, float _Complex); \
   extern "C" double _Complex __fz_##func##_1( \
       double _Complex, double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::F, I::func, std::complex<float>>{__fc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::F, I::func, std::complex<double>>{__fz_##func##_1};
 
 #define DECLARE_PGMATH_FAST_ALL_FP2(func) \
@@ -301,16 +301,16 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_PRECISE_REAL2(func) \
   extern "C" float __ps_##func##_1(float, float); \
   extern "C" double __pd_##func##_1(double, double); \
-  template<> constexpr auto Sym<L::P, I::func, float>{__ps_##func##_1}; \
-  template<> constexpr auto Sym<L::P, I::func, double>{__pd_##func##_1};
+  template <> constexpr auto Sym<L::P, I::func, float>{__ps_##func##_1}; \
+  template <> constexpr auto Sym<L::P, I::func, double>{__pd_##func##_1};
 
 #define DECLARE_PGMATH_PRECISE_COMPLEX2(func) \
   extern "C" float _Complex __pc_##func##_1(float _Complex, float _Complex); \
   extern "C" double _Complex __pz_##func##_1( \
       double _Complex, double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::P, I::func, std::complex<float>>{__pc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::P, I::func, std::complex<double>>{__pz_##func##_1};
 
 #define DECLARE_PGMATH_PRECISE_ALL_FP2(func) \
@@ -320,16 +320,16 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_RELAXED_REAL2(func) \
   extern "C" float __rs_##func##_1(float, float); \
   extern "C" double __rd_##func##_1(double, double); \
-  template<> constexpr auto Sym<L::R, I::func, float>{__rs_##func##_1}; \
-  template<> constexpr auto Sym<L::R, I::func, double>{__rd_##func##_1};
+  template <> constexpr auto Sym<L::R, I::func, float>{__rs_##func##_1}; \
+  template <> constexpr auto Sym<L::R, I::func, double>{__rd_##func##_1};
 
 #define DECLARE_PGMATH_RELAXED_COMPLEX2(func) \
   extern "C" float _Complex __rc_##func##_1(float _Complex, float _Complex); \
   extern "C" double _Complex __rz_##func##_1( \
       double _Complex, double _Complex); \
-  template<> \
+  template <> \
   constexpr auto Sym<L::R, I::func, std::complex<float>>{__rc_##func##_1}; \
-  template<> \
+  template <> \
   constexpr auto Sym<L::R, I::func, std::complex<double>>{__rz_##func##_1};
 
 #define DECLARE_PGMATH_RELAXED_ALL_FP2(func) \
@@ -354,12 +354,12 @@ template<L, I, typename> constexpr auto Sym{NoSuchRuntimeSymbol{}};
 #define DECLARE_PGMATH_MTH_VERSION_REAL(func) \
   extern "C" float __mth_i_##func(float); \
   extern "C" double __mth_i_d##func(double); \
-  template<> constexpr auto Sym<L::F, I::func, float>{__mth_i_##func}; \
-  template<> constexpr auto Sym<L::F, I::func, double>{__mth_i_d##func}; \
-  template<> constexpr auto Sym<L::P, I::func, float>{__mth_i_##func}; \
-  template<> constexpr auto Sym<L::P, I::func, double>{__mth_i_d##func}; \
-  template<> constexpr auto Sym<L::R, I::func, float>{__mth_i_##func}; \
-  template<> constexpr auto Sym<L::R, I::func, double>{__mth_i_d##func};
+  template <> constexpr auto Sym<L::F, I::func, float>{__mth_i_##func}; \
+  template <> constexpr auto Sym<L::F, I::func, double>{__mth_i_d##func}; \
+  template <> constexpr auto Sym<L::P, I::func, float>{__mth_i_##func}; \
+  template <> constexpr auto Sym<L::P, I::func, double>{__mth_i_d##func}; \
+  template <> constexpr auto Sym<L::R, I::func, float>{__mth_i_##func}; \
+  template <> constexpr auto Sym<L::R, I::func, double>{__mth_i_d##func};
 
 // Actual libpgmath declarations
 DECLARE_PGMATH_ALL(acos)
@@ -376,20 +376,20 @@ DECLARE_PGMATH_MTH_VERSION_REAL(bessel_y1)
 // bessel_jn and bessel_yn takes an int as first arg
 extern "C" float __mth_i_bessel_jn(int, float);
 extern "C" double __mth_i_dbessel_jn(int, double);
-template<> constexpr auto Sym<L::F, I::bessel_jn, float>{__mth_i_bessel_jn};
-template<> constexpr auto Sym<L::F, I::bessel_jn, double>{__mth_i_dbessel_jn};
-template<> constexpr auto Sym<L::P, I::bessel_jn, float>{__mth_i_bessel_jn};
-template<> constexpr auto Sym<L::P, I::bessel_jn, double>{__mth_i_dbessel_jn};
-template<> constexpr auto Sym<L::R, I::bessel_jn, float>{__mth_i_bessel_jn};
-template<> constexpr auto Sym<L::R, I::bessel_jn, double>{__mth_i_dbessel_jn};
+template <> constexpr auto Sym<L::F, I::bessel_jn, float>{__mth_i_bessel_jn};
+template <> constexpr auto Sym<L::F, I::bessel_jn, double>{__mth_i_dbessel_jn};
+template <> constexpr auto Sym<L::P, I::bessel_jn, float>{__mth_i_bessel_jn};
+template <> constexpr auto Sym<L::P, I::bessel_jn, double>{__mth_i_dbessel_jn};
+template <> constexpr auto Sym<L::R, I::bessel_jn, float>{__mth_i_bessel_jn};
+template <> constexpr auto Sym<L::R, I::bessel_jn, double>{__mth_i_dbessel_jn};
 extern "C" float __mth_i_bessel_yn(int, float);
 extern "C" double __mth_i_dbessel_yn(int, double);
-template<> constexpr auto Sym<L::F, I::bessel_yn, float>{__mth_i_bessel_yn};
-template<> constexpr auto Sym<L::F, I::bessel_yn, double>{__mth_i_dbessel_yn};
-template<> constexpr auto Sym<L::P, I::bessel_yn, float>{__mth_i_bessel_yn};
-template<> constexpr auto Sym<L::P, I::bessel_yn, double>{__mth_i_dbessel_yn};
-template<> constexpr auto Sym<L::R, I::bessel_yn, float>{__mth_i_bessel_yn};
-template<> constexpr auto Sym<L::R, I::bessel_yn, double>{__mth_i_dbessel_yn};
+template <> constexpr auto Sym<L::F, I::bessel_yn, float>{__mth_i_bessel_yn};
+template <> constexpr auto Sym<L::F, I::bessel_yn, double>{__mth_i_dbessel_yn};
+template <> constexpr auto Sym<L::P, I::bessel_yn, float>{__mth_i_bessel_yn};
+template <> constexpr auto Sym<L::P, I::bessel_yn, double>{__mth_i_dbessel_yn};
+template <> constexpr auto Sym<L::R, I::bessel_yn, float>{__mth_i_bessel_yn};
+template <> constexpr auto Sym<L::R, I::bessel_yn, double>{__mth_i_dbessel_yn};
 DECLARE_PGMATH_ALL(cos)
 DECLARE_PGMATH_ALL(cosh)
 DECLARE_PGMATH_MTH_VERSION_REAL(erf)
@@ -399,34 +399,34 @@ DECLARE_PGMATH_ALL(exp)
 DECLARE_PGMATH_MTH_VERSION_REAL(gamma)
 extern "C" float __mth_i_hypot(float, float);
 extern "C" double __mth_i_dhypot(double, double);
-template<> constexpr auto Sym<L::F, I::hypot, float>{__mth_i_hypot};
-template<> constexpr auto Sym<L::F, I::hypot, double>{__mth_i_dhypot};
-template<> constexpr auto Sym<L::P, I::hypot, float>{__mth_i_hypot};
-template<> constexpr auto Sym<L::P, I::hypot, double>{__mth_i_dhypot};
-template<> constexpr auto Sym<L::R, I::hypot, float>{__mth_i_hypot};
-template<> constexpr auto Sym<L::R, I::hypot, double>{__mth_i_dhypot};
+template <> constexpr auto Sym<L::F, I::hypot, float>{__mth_i_hypot};
+template <> constexpr auto Sym<L::F, I::hypot, double>{__mth_i_dhypot};
+template <> constexpr auto Sym<L::P, I::hypot, float>{__mth_i_hypot};
+template <> constexpr auto Sym<L::P, I::hypot, double>{__mth_i_dhypot};
+template <> constexpr auto Sym<L::R, I::hypot, float>{__mth_i_hypot};
+template <> constexpr auto Sym<L::R, I::hypot, double>{__mth_i_dhypot};
 DECLARE_PGMATH_ALL(log)
 DECLARE_PGMATH_REAL(log10)
 DECLARE_PGMATH_MTH_VERSION_REAL(log_gamma)
 // no function for modulo in libpgmath
 extern "C" float __fs_mod_1(float, float);
 extern "C" double __fd_mod_1(double, double);
-template<> constexpr auto Sym<L::F, I::mod, float>{__fs_mod_1};
-template<> constexpr auto Sym<L::F, I::mod, double>{__fd_mod_1};
-template<> constexpr auto Sym<L::P, I::mod, float>{__fs_mod_1};
-template<> constexpr auto Sym<L::P, I::mod, double>{__fd_mod_1};
-template<> constexpr auto Sym<L::R, I::mod, float>{__fs_mod_1};
-template<> constexpr auto Sym<L::R, I::mod, double>{__fd_mod_1};
+template <> constexpr auto Sym<L::F, I::mod, float>{__fs_mod_1};
+template <> constexpr auto Sym<L::F, I::mod, double>{__fd_mod_1};
+template <> constexpr auto Sym<L::P, I::mod, float>{__fs_mod_1};
+template <> constexpr auto Sym<L::P, I::mod, double>{__fd_mod_1};
+template <> constexpr auto Sym<L::R, I::mod, float>{__fs_mod_1};
+template <> constexpr auto Sym<L::R, I::mod, double>{__fd_mod_1};
 DECLARE_PGMATH_ALL2(pow)
 DECLARE_PGMATH_ALL(sin)
 DECLARE_PGMATH_ALL(sinh)
 DECLARE_PGMATH_MTH_VERSION_REAL(sqrt)
-DECLARE_PGMATH_COMPLEX(sqrt)  // real versions are __mth_i...
+DECLARE_PGMATH_COMPLEX(sqrt) // real versions are __mth_i...
 DECLARE_PGMATH_ALL(tan)
 DECLARE_PGMATH_ALL(tanh)
 
 // Fill the function map used for folding with libpgmath symbols
-template<L Lib, typename HostT>
+template <L Lib, typename HostT>
 static void AddLibpgmathRealHostProcedures(
     HostIntrinsicProceduresLibrary &hostIntrinsicLibrary) {
   static_assert(std::is_same_v<HostT, float> || std::is_same_v<HostT, double>);
@@ -437,7 +437,7 @@ static void AddLibpgmathRealHostProcedures(
       {"asinh", Sym<Lib, I::asinh, HostT>, true},
       {"atan", Sym<Lib, I::atan, HostT>, true},
       {"atan", Sym<Lib, I::atan2, HostT>,
-          true},  // atan is also the generic name for atan2
+          true}, // atan is also the generic name for atan2
       {"atanh", Sym<Lib, I::atanh, HostT>, true},
       {"bessel_j0", Sym<Lib, I::bessel_j0, HostT>, true},
       {"bessel_j1", Sym<Lib, I::bessel_j1, HostT>, true},
@@ -475,19 +475,19 @@ static void AddLibpgmathRealHostProcedures(
 // by a pair of register but std::complex<float> is returned by structure
 // address. To fix the issue, wrapper around C _Complex functions are defined
 // below.
-template<FuncPointer<float _Complex, float _Complex> func>
+template <FuncPointer<float _Complex, float _Complex> func>
 static std::complex<float> ComplexCFuncWrapper(std::complex<float> &arg) {
   float _Complex res{func(*reinterpret_cast<float _Complex *>(&arg))};
   return *reinterpret_cast<std::complex<float> *>(&res);
 }
 
-template<FuncPointer<double _Complex, double _Complex> func>
+template <FuncPointer<double _Complex, double _Complex> func>
 static std::complex<double> ComplexCFuncWrapper(std::complex<double> &arg) {
   double _Complex res{func(*reinterpret_cast<double _Complex *>(&arg))};
   return *reinterpret_cast<std::complex<double> *>(&res);
 }
 
-template<FuncPointer<float _Complex, float _Complex, float _Complex> func>
+template <FuncPointer<float _Complex, float _Complex, float _Complex> func>
 static std::complex<float> ComplexCFuncWrapper(
     std::complex<float> &arg1, std::complex<float> &arg2) {
   float _Complex res{func(*reinterpret_cast<float _Complex *>(&arg1),
@@ -495,7 +495,7 @@ static std::complex<float> ComplexCFuncWrapper(
   return *reinterpret_cast<std::complex<float> *>(&res);
 }
 
-template<FuncPointer<double _Complex, double _Complex, double _Complex> func>
+template <FuncPointer<double _Complex, double _Complex, double _Complex> func>
 static std::complex<double> ComplexCFuncWrapper(
     std::complex<double> &arg1, std::complex<double> &arg2) {
   double _Complex res{func(*reinterpret_cast<double _Complex *>(&arg1),
@@ -503,7 +503,7 @@ static std::complex<double> ComplexCFuncWrapper(
   return *reinterpret_cast<std::complex<double> *>(&res);
 }
 
-template<L Lib, typename HostT>
+template <L Lib, typename HostT>
 static void AddLibpgmathComplexHostProcedures(
     HostIntrinsicProceduresLibrary &hostIntrinsicLibrary) {
   static_assert(std::is_same_v<HostT, float> || std::is_same_v<HostT, double>);
@@ -535,7 +535,7 @@ static void AddLibpgmathComplexHostProcedures(
   }
 }
 
-template<L Lib>
+template <L Lib>
 static void InitHostIntrinsicLibraryWithLibpgmath(
     HostIntrinsicProceduresLibrary &lib) {
   if constexpr (host::FortranTypeExists<float>()) {
@@ -558,8 +558,8 @@ static void InitHostIntrinsicLibraryWithLibpgmath(
     AddLibmComplexHostProcedures<long double>(lib);
   }
 }
-}
-#endif  // LINK_WITH_LIBPGMATH
+} // namespace pgmath
+#endif // LINK_WITH_LIBPGMATH
 
 // Define which host runtime functions will be used for folding
 HostIntrinsicProceduresLibrary::HostIntrinsicProceduresLibrary() {
@@ -581,4 +581,4 @@ HostIntrinsicProceduresLibrary::HostIntrinsicProceduresLibrary() {
   InitHostIntrinsicLibraryWithLibm(*this);
 #endif
 }
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/intrinsics.cpp b/flang/lib/Evaluate/intrinsics.cpp
index 1936ca2cebbf..cbf082bd8ac5 100644
--- a/flang/lib/Evaluate/intrinsics.cpp
+++ b/flang/lib/Evaluate/intrinsics.cpp
@@ -70,20 +70,20 @@ static constexpr CategorySet IntrinsicType{
 static constexpr CategorySet AnyType{IntrinsicType | DerivedType};
 
 ENUM_CLASS(KindCode, none, defaultIntegerKind,
-    defaultRealKind,  // is also the default COMPLEX kind
+    defaultRealKind, // is also the default COMPLEX kind
     doublePrecision, defaultCharKind, defaultLogicalKind,
-    any,  // matches any kind value; each instance is independent
-    same,  // match any kind, but all "same" kinds must be equal
-    operand,  // match any kind, with promotion (non-standard)
-    typeless,  // BOZ literals are INTEGER with this kind
-    teamType,  // TEAM_TYPE from module ISO_FORTRAN_ENV (for coarrays)
-    kindArg,  // this argument is KIND=
-    effectiveKind,  // for function results: "kindArg" value, possibly defaulted
-    dimArg,  // this argument is DIM=
-    likeMultiply,  // for DOT_PRODUCT and MATMUL
-    subscript,  // address-sized integer
-    size,  // default KIND= for SIZE(), UBOUND, &c.
-    addressable,  // for PRESENT(), &c.; anything (incl. procedure) but BOZ
+    any, // matches any kind value; each instance is independent
+    same, // match any kind, but all "same" kinds must be equal
+    operand, // match any kind, with promotion (non-standard)
+    typeless, // BOZ literals are INTEGER with this kind
+    teamType, // TEAM_TYPE from module ISO_FORTRAN_ENV (for coarrays)
+    kindArg, // this argument is KIND=
+    effectiveKind, // for function results: "kindArg" value, possibly defaulted
+    dimArg, // this argument is DIM=
+    likeMultiply, // for DOT_PRODUCT and MATMUL
+    subscript, // address-sized integer
+    size, // default KIND= for SIZE(), UBOUND, &c.
+    addressable, // for PRESENT(), &c.; anything (incl. procedure) but BOZ
 )
 
 struct TypePattern {
@@ -166,27 +166,27 @@ static constexpr TypePattern KINDLogical{LogicalType, KindCode::effectiveKind};
 // The default rank pattern for dummy arguments and function results is
 // "elemental".
 ENUM_CLASS(Rank,
-    elemental,  // scalar, or array that conforms with other array arguments
-    elementalOrBOZ,  // elemental, or typeless BOZ literal scalar
+    elemental, // scalar, or array that conforms with other array arguments
+    elementalOrBOZ, // elemental, or typeless BOZ literal scalar
     scalar, vector,
-    shape,  // INTEGER vector of known length and no negative element
+    shape, // INTEGER vector of known length and no negative element
     matrix,
-    array,  // not scalar, rank is known and greater than zero
-    known,  // rank is known and can be scalar
-    anyOrAssumedRank,  // rank can be unknown; assumed-type TYPE(*) allowed
-    conformable,  // scalar, or array of same rank & shape as "array" argument
-    reduceOperation,  // a pure function with constraints for REDUCE
-    dimReduced,  // scalar if no DIM= argument, else rank(array)-1
-    dimRemoved,  // scalar, or rank(array)-1
-    rankPlus1,  // rank(known)+1
-    shaped,  // rank is length of SHAPE vector
+    array, // not scalar, rank is known and greater than zero
+    known, // rank is known and can be scalar
+    anyOrAssumedRank, // rank can be unknown; assumed-type TYPE(*) allowed
+    conformable, // scalar, or array of same rank & shape as "array" argument
+    reduceOperation, // a pure function with constraints for REDUCE
+    dimReduced, // scalar if no DIM= argument, else rank(array)-1
+    dimRemoved, // scalar, or rank(array)-1
+    rankPlus1, // rank(known)+1
+    shaped, // rank is length of SHAPE vector
 )
 
 ENUM_CLASS(Optionality, required, optional,
-    defaultsToSameKind,  // for MatchingDefaultKIND
-    defaultsToDefaultForResult,  // for DefaultingKIND
-    defaultsToSizeKind,  // for SizeDefaultKIND
-    repeats,  // for MAX/MIN and their several variants
+    defaultsToSameKind, // for MatchingDefaultKIND
+    defaultsToDefaultForResult, // for DefaultingKIND
+    defaultsToSizeKind, // for SizeDefaultKIND
+    repeats, // for MAX/MIN and their several variants
 )
 
 struct IntrinsicDummyArgument {
@@ -224,7 +224,7 @@ static constexpr IntrinsicDummyArgument OptionalMASK{
     "mask", AnyLogical, Rank::conformable, Optionality::optional};
 
 struct IntrinsicInterface {
-  static constexpr int maxArguments{7};  // if not a MAX/MIN(...)
+  static constexpr int maxArguments{7}; // if not a MAX/MIN(...)
   const char *name{nullptr};
   IntrinsicDummyArgument dummy[maxArguments];
   TypePattern result;
@@ -350,7 +350,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
     {"dot_product",
         {{"vector_a", AnyComplex, Rank::vector},
             {"vector_b", AnyNumeric, Rank::vector}},
-        ResultNumeric, Rank::scalar},  // conjugates vector_a
+        ResultNumeric, Rank::scalar}, // conjugates vector_a
     {"dot_product",
         {{"vector_a", AnyIntOrReal, Rank::vector},
             {"vector_b", AnyNumeric, Rank::vector}},
@@ -600,7 +600,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
     {"rank", {{"a", AnyData, Rank::anyOrAssumedRank}}, DefaultInt,
         Rank::scalar},
     {"real", {{"a", SameComplex, Rank::elemental}},
-        SameReal},  // 16.9.160(4)(ii)
+        SameReal}, // 16.9.160(4)(ii)
     {"real", {{"a", AnyNumeric, Rank::elementalOrBOZ}, DefaultingKIND},
         KINDReal},
     {"reduce",
@@ -943,7 +943,7 @@ static const IntrinsicInterface intrinsicSubroutine[]{
     {"mvbits",
         {{"from", SameInt}, {"frompos", AnyInt}, {"len", AnyInt},
             {"to", SameInt}, {"topos", AnyInt}},
-        {}},  // elemental
+        {}}, // elemental
     {"random_init",
         {{"repeatable", AnyLogical, Rank::scalar},
             {"image_distinct", AnyLogical, Rank::scalar}},
@@ -953,7 +953,7 @@ static const IntrinsicInterface intrinsicSubroutine[]{
         {{"size", DefaultInt, Rank::scalar, Optionality::optional},
             {"put", DefaultInt, Rank::vector, Optionality::optional},
             {"get", DefaultInt, Rank::vector, Optionality::optional}},
-        {}},  // TODO: at most one argument can be present
+        {}}, // TODO: at most one argument can be present
     {"system_clock",
         {{"count", AnyInt, Rank::scalar, Optionality::optional},
             {"count_rate", AnyIntOrReal, Rank::scalar, Optionality::optional},
@@ -1066,7 +1066,7 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
     if (!arg) {
       if (d.optionality == Optionality::required) {
         messages.Say("missing mandatory '%s=' argument"_err_en_US, d.keyword);
-        return std::nullopt;  // missing non-OPTIONAL argument
+        return std::nullopt; // missing non-OPTIONAL argument
       } else {
         continue;
       }
@@ -1114,13 +1114,13 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
     } else if (!d.typePattern.categorySet.test(type->category())) {
       messages.Say("Actual argument for '%s=' has bad type '%s'"_err_en_US,
           d.keyword, type->AsFortran());
-      return std::nullopt;  // argument has invalid type category
+      return std::nullopt; // argument has invalid type category
     }
     bool argOk{false};
     switch (d.typePattern.kindCode) {
     case KindCode::none:
     case KindCode::typeless:
-    case KindCode::teamType:  // TODO: TEAM_TYPE
+    case KindCode::teamType: // TODO: TEAM_TYPE
       argOk = false;
       break;
     case KindCode::defaultIntegerKind:
@@ -1138,7 +1138,9 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
     case KindCode::defaultLogicalKind:
       argOk = type->kind() == defaults.GetDefaultKind(TypeCategory::Logical);
       break;
-    case KindCode::any: argOk = true; break;
+    case KindCode::any:
+      argOk = true;
+      break;
     case KindCode::kindArg:
       CHECK(type->category() == TypeCategory::Integer);
       CHECK(!kindArg);
@@ -1175,8 +1177,11 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
                   "for intrinsic '%s'",
           d.keyword, name);
       break;
-    case KindCode::addressable: argOk = true; break;
-    default: CRASH_NO_CASE;
+    case KindCode::addressable:
+      argOk = true;
+      break;
+    default:
+      CRASH_NO_CASE;
     }
     if (!argOk) {
       messages.Say(
@@ -1210,8 +1215,12 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
         }
         argOk = rank == 0 || rank == elementalRank;
         break;
-      case Rank::scalar: argOk = rank == 0; break;
-      case Rank::vector: argOk = rank == 1; break;
+      case Rank::scalar:
+        argOk = rank == 0;
+        break;
+      case Rank::vector:
+        argOk = rank == 1;
+        break;
       case Rank::shape:
         CHECK(!shapeArgSize);
         if (rank == 1) {
@@ -1229,7 +1238,9 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
           return std::nullopt;
         }
         break;
-      case Rank::matrix: argOk = rank == 2; break;
+      case Rank::matrix:
+        argOk = rank == 2;
+        break;
       case Rank::array:
         argOk = rank > 0;
         if (!arrayArg) {
@@ -1244,7 +1255,9 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
         }
         argOk = rank == knownArg->Rank();
         break;
-      case Rank::anyOrAssumedRank: argOk = true; break;
+      case Rank::anyOrAssumedRank:
+        argOk = true;
+        break;
       case Rank::conformable:
         CHECK(arrayArg);
         argOk = rank == 0 || rank == arrayArg->Rank();
@@ -1383,7 +1396,8 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
       common::die(
           "INTERNAL: bad KindCode appears on intrinsic '%s' result", name);
       break;
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
   } else {
     if (!call.isSubroutineCall) {
@@ -1396,10 +1410,18 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
   // Determine the rank of the function result.
   int resultRank{0};
   switch (rank) {
-  case Rank::elemental: resultRank = elementalRank; break;
-  case Rank::scalar: resultRank = 0; break;
-  case Rank::vector: resultRank = 1; break;
-  case Rank::matrix: resultRank = 2; break;
+  case Rank::elemental:
+    resultRank = elementalRank;
+    break;
+  case Rank::scalar:
+    resultRank = 0;
+    break;
+  case Rank::vector:
+    resultRank = 1;
+    break;
+  case Rank::matrix:
+    resultRank = 2;
+    break;
   case Rank::conformable:
     CHECK(arrayArg);
     resultRank = arrayArg->Rank();
@@ -1496,7 +1518,7 @@ std::optional<SpecificCall> IntrinsicInterface::Match(
 class IntrinsicProcTable::Implementation {
 public:
   explicit Implementation(const common::IntrinsicTypeDefaultKinds &dfts)
-    : defaults_{dfts} {
+      : defaults_{dfts} {
     for (const IntrinsicInterface &f : genericIntrinsicFunction) {
       genericFuncs_.insert(std::make_pair(std::string{f.name}, &f));
     }
@@ -1798,10 +1820,14 @@ static DynamicType GetReturnType(const SpecificIntrinsicInterface &interface,
     const common::IntrinsicTypeDefaultKinds &defaults) {
   TypeCategory category{TypeCategory::Integer};
   switch (interface.result.kindCode) {
-  case KindCode::defaultIntegerKind: break;
+  case KindCode::defaultIntegerKind:
+    break;
   case KindCode::doublePrecision:
-  case KindCode::defaultRealKind: category = TypeCategory::Real; break;
-  default: CRASH_NO_CASE;
+  case KindCode::defaultRealKind:
+    category = TypeCategory::Real;
+    break;
+  default:
+    CRASH_NO_CASE;
   }
   int kind{interface.result.kindCode == KindCode::doublePrecision
           ? defaults.doublePrecisionKind()
@@ -1836,7 +1862,7 @@ std::optional<SpecificCall> IntrinsicProcTable::Implementation::Probe(
         return specificCall;
       }
     }
-    return std::nullopt;  // TODO
+    return std::nullopt; // TODO
   }
 
   // Helper to avoid emitting errors before it is sure there is no match
@@ -2063,4 +2089,4 @@ llvm::raw_ostream &IntrinsicProcTable::Implementation::Dump(
 llvm::raw_ostream &IntrinsicProcTable::Dump(llvm::raw_ostream &o) const {
   return impl_->Dump(o);
 }
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/logical.cpp b/flang/lib/Evaluate/logical.cpp
index c29ed1df33d3..520d11fb967f 100644
--- a/flang/lib/Evaluate/logical.cpp
+++ b/flang/lib/Evaluate/logical.cpp
@@ -14,4 +14,4 @@ template class Logical<8>;
 template class Logical<16>;
 template class Logical<32>;
 template class Logical<64>;
-}
+} // namespace Fortran::evaluate::value
diff --git a/flang/lib/Evaluate/real.cpp b/flang/lib/Evaluate/real.cpp
index 18309d9adb64..58aa833dd6dd 100644
--- a/flang/lib/Evaluate/real.cpp
+++ b/flang/lib/Evaluate/real.cpp
@@ -16,26 +16,26 @@
 
 namespace Fortran::evaluate::value {
 
-template<typename W, int P> Relation Real<W, P>::Compare(const Real &y) const {
-  if (IsNotANumber() || y.IsNotANumber()) {  // NaN vs x, x vs NaN
+template <typename W, int P> Relation Real<W, P>::Compare(const Real &y) const {
+  if (IsNotANumber() || y.IsNotANumber()) { // NaN vs x, x vs NaN
     return Relation::Unordered;
   } else if (IsInfinite()) {
     if (y.IsInfinite()) {
-      if (IsNegative()) {  // -Inf vs +/-Inf
+      if (IsNegative()) { // -Inf vs +/-Inf
         return y.IsNegative() ? Relation::Equal : Relation::Less;
-      } else {  // +Inf vs +/-Inf
+      } else { // +Inf vs +/-Inf
         return y.IsNegative() ? Relation::Greater : Relation::Equal;
       }
-    } else {  // +/-Inf vs finite
+    } else { // +/-Inf vs finite
       return IsNegative() ? Relation::Less : Relation::Greater;
     }
-  } else if (y.IsInfinite()) {  // finite vs +/-Inf
+  } else if (y.IsInfinite()) { // finite vs +/-Inf
     return y.IsNegative() ? Relation::Greater : Relation::Less;
-  } else {  // two finite numbers
+  } else { // two finite numbers
     bool isNegative{IsNegative()};
     if (isNegative != y.IsNegative()) {
       if (word_.IOR(y.word_).IBCLR(bits - 1).IsZero()) {
-        return Relation::Equal;  // +/-0.0 == -/+0.0
+        return Relation::Equal; // +/-0.0 == -/+0.0
       } else {
         return isNegative ? Relation::Less : Relation::Greater;
       }
@@ -53,12 +53,12 @@ template<typename W, int P> Relation Real<W, P>::Compare(const Real &y) const {
   }
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
-    result.value = NotANumber();  // NaN + x -> NaN
+    result.value = NotANumber(); // NaN + x -> NaN
     if (IsSignalingNaN() || y.IsSignalingNaN()) {
       result.flags.set(RealFlag::InvalidArgument);
     }
@@ -69,18 +69,18 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
   if (IsInfinite()) {
     if (y.IsInfinite()) {
       if (isNegative == yIsNegative) {
-        result.value = *this;  // +/-Inf + +/-Inf -> +/-Inf
+        result.value = *this; // +/-Inf + +/-Inf -> +/-Inf
       } else {
-        result.value = NotANumber();  // +/-Inf + -/+Inf -> NaN
+        result.value = NotANumber(); // +/-Inf + -/+Inf -> NaN
         result.flags.set(RealFlag::InvalidArgument);
       }
     } else {
-      result.value = *this;  // +/-Inf + x -> +/-Inf
+      result.value = *this; // +/-Inf + x -> +/-Inf
     }
     return result;
   }
   if (y.IsInfinite()) {
-    result.value = y;  // x + +/-Inf -> +/-Inf
+    result.value = y; // x + +/-Inf -> +/-Inf
     return result;
   }
   int exponent{Exponent()};
@@ -98,7 +98,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
     if (order == Ordering::Equal) {
       // x + (-x) -> +0.0 unless rounding is directed downwards
       if (rounding.mode == common::RoundingMode::Down) {
-        result.value.word_ = result.value.word_.IBSET(bits - 1);  // -0.0
+        result.value.word_ = result.value.word_.IBSET(bits - 1); // -0.0
       }
       return result;
     }
@@ -110,7 +110,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
   Fraction yFraction{y.GetFraction()};
   int rshift = exponent - yExponent;
   if (exponent > 0 && yExponent == 0) {
-    --rshift;  // correct overshift when only y is subnormal
+    --rshift; // correct overshift when only y is subnormal
   }
   RoundingBits roundingBits{yFraction, rshift};
   yFraction = yFraction.SHIFTR(rshift);
@@ -133,12 +133,12 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Add(
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::Multiply(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
-    result.value = NotANumber();  // NaN * x -> NaN
+    result.value = NotANumber(); // NaN * x -> NaN
     if (IsSignalingNaN() || y.IsSignalingNaN()) {
       result.flags.set(RealFlag::InvalidArgument);
     }
@@ -146,7 +146,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Multiply(
     bool isNegative{IsNegative() != y.IsNegative()};
     if (IsInfinite() || y.IsInfinite()) {
       if (IsZero() || y.IsZero()) {
-        result.value = NotANumber();  // 0 * Inf -> NaN
+        result.value = NotANumber(); // 0 * Inf -> NaN
         result.flags.set(RealFlag::InvalidArgument);
       } else {
         result.value = Infinity(isNegative);
@@ -193,12 +193,12 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Multiply(
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::Divide(
     const Real &y, Rounding rounding) const {
   ValueWithRealFlags<Real> result;
   if (IsNotANumber() || y.IsNotANumber()) {
-    result.value = NotANumber();  // NaN / x -> NaN, x / NaN -> NaN
+    result.value = NotANumber(); // NaN / x -> NaN, x / NaN -> NaN
     if (IsSignalingNaN() || y.IsSignalingNaN()) {
       result.flags.set(RealFlag::InvalidArgument);
     }
@@ -206,20 +206,20 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Divide(
     bool isNegative{IsNegative() != y.IsNegative()};
     if (IsInfinite()) {
       if (y.IsInfinite()) {
-        result.value = NotANumber();  // Inf/Inf -> NaN
+        result.value = NotANumber(); // Inf/Inf -> NaN
         result.flags.set(RealFlag::InvalidArgument);
-      } else {  // Inf/x -> Inf,  Inf/0 -> Inf
+      } else { // Inf/x -> Inf,  Inf/0 -> Inf
         result.value = Infinity(isNegative);
       }
     } else if (y.IsZero()) {
-      if (IsZero()) {  // 0/0 -> NaN
+      if (IsZero()) { // 0/0 -> NaN
         result.value = NotANumber();
         result.flags.set(RealFlag::InvalidArgument);
-      } else {  // x/0 -> Inf, Inf/0 -> Inf
+      } else { // x/0 -> Inf, Inf/0 -> Inf
         result.value = Infinity(isNegative);
         result.flags.set(RealFlag::DivideByZero);
       }
-    } else if (IsZero() || y.IsInfinite()) {  // 0/x, x/Inf -> 0
+    } else if (IsZero() || y.IsInfinite()) { // 0/x, x/Inf -> 0
       if (isNegative) {
         result.value.word_ = result.value.word_.IBSET(bits - 1);
       }
@@ -261,7 +261,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Divide(
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::ToWholeNumber(
     common::RoundingMode mode) const {
   ValueWithRealFlags<Real> result{*this};
@@ -273,11 +273,11 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::ToWholeNumber(
   } else {
     constexpr int noClipExponent{exponentBias + binaryPrecision - 1};
     if (Exponent() < noClipExponent) {
-      Real adjust;  // ABS(EPSILON(adjust)) == 0.5
+      Real adjust; // ABS(EPSILON(adjust)) == 0.5
       adjust.Normalize(IsSignBitSet(), noClipExponent, Fraction::MASKL(1));
       // Compute ival=(*this + adjust), losing any fractional bits; keep flags
       result = Add(adjust, Rounding{mode});
-      result.flags.reset(RealFlag::Inexact);  // result *is* exact
+      result.flags.reset(RealFlag::Inexact); // result *is* exact
       // Return (ival-adjust) with original sign in case we've generated a zero.
       result.value =
           result.value.Subtract(adjust, Rounding{common::RoundingMode::ToZero})
@@ -287,7 +287,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::ToWholeNumber(
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 RealFlags Real<W, P>::Normalize(bool negative, int exponent,
     const Fraction &fraction, Rounding rounding, RoundingBits *roundingBits) {
   int lshift{fraction.LEADZ()};
@@ -311,7 +311,7 @@ RealFlags Real<W, P>::Normalize(bool negative, int exponent,
         rounding.mode == common::RoundingMode::TiesAwayFromZero ||
         (rounding.mode == common::RoundingMode::Up && !negative) ||
         (rounding.mode == common::RoundingMode::Down && negative)) {
-      word_ = Word{maxExponent}.SHIFTL(significandBits);  // Inf
+      word_ = Word{maxExponent}.SHIFTL(significandBits); // Inf
     } else {
       // directed rounding: round to largest finite value rather than infinity
       // (x86 does this, not sure whether it's standard behavior)
@@ -347,7 +347,7 @@ RealFlags Real<W, P>::Normalize(bool negative, int exponent,
   return {};
 }
 
-template<typename W, int P>
+template <typename W, int P>
 RealFlags Real<W, P>::Round(
     Rounding rounding, const RoundingBits &bits, bool multiply) {
   int origExponent{Exponent()};
@@ -365,7 +365,7 @@ RealFlags Real<W, P>::Round(
       // The fraction was all ones before rounding; sum.value is now zero
       sum.value = sum.value.IBSET(binaryPrecision - 1);
       if (++newExponent >= maxExponent) {
-        flags.set(RealFlag::Overflow);  // rounded away to an infinity
+        flags.set(RealFlag::Overflow); // rounded away to an infinity
       }
     }
     flags |= Normalize(IsNegative(), newExponent, sum.value);
@@ -388,7 +388,7 @@ RealFlags Real<W, P>::Round(
   return flags;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 void Real<W, P>::NormalizeAndRound(ValueWithRealFlags<Real> &result,
     bool isNegative, int exponent, const Fraction &fraction, Rounding rounding,
     RoundingBits roundingBits, bool multiply) {
@@ -400,13 +400,18 @@ void Real<W, P>::NormalizeAndRound(ValueWithRealFlags<Real> &result,
 inline enum decimal::FortranRounding MapRoundingMode(
     common::RoundingMode rounding) {
   switch (rounding) {
-  case common::RoundingMode::TiesToEven: break;
-  case common::RoundingMode::ToZero: return decimal::RoundToZero;
-  case common::RoundingMode::Down: return decimal::RoundDown;
-  case common::RoundingMode::Up: return decimal::RoundUp;
-  case common::RoundingMode::TiesAwayFromZero: return decimal::RoundCompatible;
+  case common::RoundingMode::TiesToEven:
+    break;
+  case common::RoundingMode::ToZero:
+    return decimal::RoundToZero;
+  case common::RoundingMode::Down:
+    return decimal::RoundDown;
+  case common::RoundingMode::Up:
+    return decimal::RoundUp;
+  case common::RoundingMode::TiesAwayFromZero:
+    return decimal::RoundCompatible;
   }
-  return decimal::RoundNearest;  // dodge gcc warning about lack of result
+  return decimal::RoundNearest; // dodge gcc warning about lack of result
 }
 
 inline RealFlags MapFlags(decimal::ConversionResultFlags flags) {
@@ -423,7 +428,7 @@ inline RealFlags MapFlags(decimal::ConversionResultFlags flags) {
   return result;
 }
 
-template<typename W, int P>
+template <typename W, int P>
 ValueWithRealFlags<Real<W, P>> Real<W, P>::Read(
     const char *&p, Rounding rounding) {
   auto converted{
@@ -432,7 +437,7 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::Read(
   return {*value, MapFlags(converted.flags)};
 }
 
-template<typename W, int P> std::string Real<W, P>::DumpHexadecimal() const {
+template <typename W, int P> std::string Real<W, P>::DumpHexadecimal() const {
   if (IsNotANumber()) {
     return "NaN 0x"s + word_.Hexadecimal();
   } else if (IsNegative()) {
@@ -478,7 +483,7 @@ template<typename W, int P> std::string Real<W, P>::DumpHexadecimal() const {
   }
 }
 
-template<typename W, int P>
+template <typename W, int P>
 llvm::raw_ostream &Real<W, P>::AsFortran(
     llvm::raw_ostream &o, int kind, bool minimal) const {
   if (IsNotANumber()) {
@@ -492,8 +497,8 @@ llvm::raw_ostream &Real<W, P>::AsFortran(
   } else {
     using B = decimal::BinaryFloatingPointNumber<P>;
     const auto *value{reinterpret_cast<const B *>(this)};
-    char buffer[24000];  // accommodate real*16
-    decimal::DecimalConversionFlags flags{};  // default: exact representation
+    char buffer[24000]; // accommodate real*16
+    decimal::DecimalConversionFlags flags{}; // default: exact representation
     if (minimal) {
       flags = decimal::Minimize;
     }
@@ -522,4 +527,4 @@ template class Real<Integer<32>, 24>;
 template class Real<Integer<64>, 53>;
 template class Real<Integer<80>, 64>;
 template class Real<Integer<128>, 113>;
-}
+} // namespace Fortran::evaluate::value
diff --git a/flang/lib/Evaluate/shape.cpp b/flang/lib/Evaluate/shape.cpp
index f27ee5814075..7d33a8b0594c 100644
--- a/flang/lib/Evaluate/shape.cpp
+++ b/flang/lib/Evaluate/shape.cpp
@@ -18,7 +18,7 @@
 #include "flang/Semantics/symbol.h"
 #include <functional>
 
-using namespace std::placeholders;  // _1, _2, &c. for std::bind()
+using namespace std::placeholders; // _1, _2, &c. for std::bind()
 
 namespace Fortran::evaluate {
 
@@ -36,7 +36,7 @@ bool IsExplicitShape(const Symbol &symbol0) {
   const Symbol &symbol{ResolveAssociations(symbol0)};
   if (const auto *details{symbol.detailsIf<semantics::ObjectEntityDetails>()}) {
     const auto &shape{details->shape()};
-    return shape.Rank() == 0 || shape.IsExplicitShape();  // even if scalar
+    return shape.Rank() == 0 || shape.IsExplicitShape(); // even if scalar
   } else {
     return false;
   }
@@ -186,7 +186,7 @@ public:
   using Base = Traverse<GetLowerBoundHelper, ExtentExpr>;
   using Base::operator();
   GetLowerBoundHelper(FoldingContext &c, int d)
-    : Base{*this}, context_{c}, dimension_{d} {}
+      : Base{*this}, context_{c}, dimension_{d} {}
   static ExtentExpr Default() { return ExtentExpr{1}; }
   static ExtentExpr Combine(Result &&, Result &&) { return Default(); }
   ExtentExpr operator()(const Symbol &);
@@ -318,7 +318,7 @@ MaybeExtentExpr GetExtent(FoldingContext &context, const Subscript &subscript,
           [&](const IndirectSubscriptIntegerExpr &subs) -> MaybeExtentExpr {
             if (auto shape{GetShape(context, subs.value())}) {
               if (GetRank(*shape) > 0) {
-                CHECK(GetRank(*shape) == 1);  // vector-valued subscript
+                CHECK(GetRank(*shape) == 1); // vector-valued subscript
                 return std::move(shape->at(0));
               }
             }
@@ -378,7 +378,7 @@ Shape GetUpperBounds(FoldingContext &context, const NamedEntity &base) {
         result.emplace_back(Fold(context, common::Clone(*bound)));
       } else if (details->IsAssumedSize()) {
         CHECK(dim + 1 == base.Rank());
-        result.emplace_back(std::nullopt);  // UBOUND folding replaces with -1
+        result.emplace_back(std::nullopt); // UBOUND folding replaces with -1
       } else {
         result.emplace_back(ComputeUpperBound(context,
             GetLowerBound(context, base, dim), GetExtent(context, base, dim)));
@@ -409,7 +409,7 @@ auto GetShapeHelper::operator()(const Symbol &symbol) const -> Result {
             }
           },
           [](const semantics::EntityDetails &) {
-            return Scalar();  // no dimensions seen
+            return Scalar(); // no dimensions seen
           },
           [&](const semantics::ProcEntityDetails &proc) {
             if (const Symbol * interface{proc.interface().symbol()}) {
@@ -617,7 +617,7 @@ auto GetShapeHelper::operator()(const ProcedureRef &call) const -> Result {
         }
       }
     } else if (intrinsic->characteristics.value().attrs.test(characteristics::
-                       Procedure::Attr::NullPointer)) {  // NULL(MOLD=)
+                       Procedure::Attr::NullPointer)) { // NULL(MOLD=)
       return (*this)(call.arguments());
     } else {
       // TODO: shapes of other non-elemental intrinsic results
@@ -653,4 +653,4 @@ bool CheckConformance(parser::ContextualMessages &messages, const Shape &left,
   }
   return true;
 }
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/static-data.cpp b/flang/lib/Evaluate/static-data.cpp
index bd1a729c4996..a288b08ebfab 100644
--- a/flang/lib/Evaluate/static-data.cpp
+++ b/flang/lib/Evaluate/static-data.cpp
@@ -93,4 +93,4 @@ std::optional<std::u32string> StaticDataObject::AsU32String() const {
   }
   return std::nullopt;
 }
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/tools.cpp b/flang/lib/Evaluate/tools.cpp
index c3a30aad8ce6..693d25bd31fa 100644
--- a/flang/lib/Evaluate/tools.cpp
+++ b/flang/lib/Evaluate/tools.cpp
@@ -705,13 +705,12 @@ bool IsProcedure(const Expr<SomeType> &expr) {
 }
 
 bool IsProcedurePointer(const Expr<SomeType> &expr) {
-  return std::visit(
-      common::visitors{
-          [](const NullPointer &) { return true; },
-          [](const ProcedureDesignator &) { return true; },
-          [](const ProcedureRef &) { return true; },
-          [](const auto &) { return false; },
-      },
+  return std::visit(common::visitors{
+                        [](const NullPointer &) { return true; },
+                        [](const ProcedureDesignator &) { return true; },
+                        [](const ProcedureRef &) { return true; },
+                        [](const auto &) { return false; },
+                    },
       expr.u);
 }
 
diff --git a/flang/lib/Evaluate/type.cpp b/flang/lib/Evaluate/type.cpp
index d8d30264b397..d1fb80f6a781 100644
--- a/flang/lib/Evaluate/type.cpp
+++ b/flang/lib/Evaluate/type.cpp
@@ -80,11 +80,11 @@ bool IsDescriptor(const Symbol &symbol) {
       },
       symbol.details());
 }
-}
+} // namespace Fortran::semantics
 
 namespace Fortran::evaluate {
 
-template<typename A> inline bool PointeeComparison(const A *x, const A *y) {
+template <typename A> inline bool PointeeComparison(const A *x, const A *y) {
   return x == y || (x && y && *x == *y);
 }
 
@@ -198,7 +198,7 @@ static bool AreSameDerivedType(const semantics::DerivedTypeSpec &x,
   }
   auto thisQuery{std::make_pair(&x, &y)};
   if (inProgress.find(thisQuery) != inProgress.end()) {
-    return true;  // recursive use of types in components
+    return true; // recursive use of types in components
   }
   inProgress.insert(thisQuery);
   const auto &xDetails{xSymbol.get<semantics::DerivedTypeDetails>()};
@@ -243,7 +243,7 @@ static bool AreSameComponent(const semantics::Symbol &x,
   if (x.attrs().test(semantics::Attr::PRIVATE)) {
     return false;
   }
-#if 0  // TODO
+#if 0 // TODO
   if (const auto *xObject{x.detailsIf<semantics::ObjectEntityDetails>()}) {
     if (const auto *yObject{y.detailsIf<semantics::ObjectEntityDetails>()}) {
 #else
@@ -256,7 +256,7 @@ static bool AreSameComponent(const semantics::Symbol &x,
 else {
   return false;
 }
-}
+} // namespace Fortran::evaluate
 else {
   // TODO: non-object components
   return true;
@@ -343,7 +343,7 @@ bool DynamicType::IsTkCompatibleWith(const DynamicType &that) const {
     return false;
   } else if (!derived_ || !that.derived_ ||
       !IsKindCompatible(*derived_, *that.derived_)) {
-    return false;  // kind params don't match
+    return false; // kind params don't match
   } else {
     return AreCompatibleDerivedTypes(derived_, that.derived_, IsPolymorphic());
   }
@@ -377,7 +377,7 @@ std::optional<DynamicType> DynamicType::From(
 }
 
 std::optional<DynamicType> DynamicType::From(const semantics::Symbol &symbol) {
-  return From(symbol.GetType());  // Symbol -> DeclTypeSpec -> DynamicType
+  return From(symbol.GetType()); // Symbol -> DeclTypeSpec -> DynamicType
 }
 
 DynamicType DynamicType::ResultTypeForMultiply(const DynamicType &that) const {
@@ -387,37 +387,45 @@ DynamicType DynamicType::ResultTypeForMultiply(const DynamicType &that) const {
     case TypeCategory::Integer:
       return DynamicType{TypeCategory::Integer, std::max(kind_, that.kind_)};
     case TypeCategory::Real:
-    case TypeCategory::Complex: return that;
-    default: CRASH_NO_CASE;
+    case TypeCategory::Complex:
+      return that;
+    default:
+      CRASH_NO_CASE;
     }
     break;
   case TypeCategory::Real:
     switch (that.category_) {
-    case TypeCategory::Integer: return *this;
+    case TypeCategory::Integer:
+      return *this;
     case TypeCategory::Real:
       return DynamicType{TypeCategory::Real, std::max(kind_, that.kind_)};
     case TypeCategory::Complex:
       return DynamicType{TypeCategory::Complex, std::max(kind_, that.kind_)};
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
     break;
   case TypeCategory::Complex:
     switch (that.category_) {
-    case TypeCategory::Integer: return *this;
+    case TypeCategory::Integer:
+      return *this;
     case TypeCategory::Real:
     case TypeCategory::Complex:
       return DynamicType{TypeCategory::Complex, std::max(kind_, that.kind_)};
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
     break;
   case TypeCategory::Logical:
     switch (that.category_) {
     case TypeCategory::Logical:
       return DynamicType{TypeCategory::Logical, std::max(kind_, that.kind_)};
-    default: CRASH_NO_CASE;
+    default:
+      CRASH_NO_CASE;
     }
     break;
-  default: CRASH_NO_CASE;
+  default:
+    CRASH_NO_CASE;
   }
   return *this;
 }
@@ -463,7 +471,7 @@ bool SomeKind<TypeCategory::Derived>::operator==(
   return PointeeComparison(derivedTypeSpec_, that.derivedTypeSpec_);
 }
 
-int SelectedCharKind(const std::string &s, int defaultKind) {  // 16.9.168
+int SelectedCharKind(const std::string &s, int defaultKind) { // 16.9.168
   auto lower{parser::ToLowerCaseLetters(s)};
   auto n{lower.size()};
   while (n > 0 && lower[0] == ' ') {
@@ -491,7 +499,7 @@ public:
   explicit SelectedIntKindVisitor(std::int64_t p) : precision_{p} {}
   using Result = std::optional<int>;
   using Types = IntegerTypes;
-  template<typename T> Result Test() const {
+  template <typename T> Result Test() const {
     if (Scalar<T>::RANGE >= precision_) {
       return T::kind;
     } else {
@@ -514,10 +522,10 @@ int SelectedIntKind(std::int64_t precision) {
 class SelectedRealKindVisitor {
 public:
   explicit SelectedRealKindVisitor(std::int64_t p, std::int64_t r)
-    : precision_{p}, range_{r} {}
+      : precision_{p}, range_{r} {}
   using Result = std::optional<int>;
   using Types = RealTypes;
-  template<typename T> Result Test() const {
+  template <typename T> Result Test() const {
     if (Scalar<T>::PRECISION >= precision_ && Scalar<T>::RANGE >= range_) {
       return {T::kind};
     } else {
@@ -557,4 +565,4 @@ int SelectedRealKind(
     }
   }
 }
-}
+} // namespace Fortran::evaluate
diff --git a/flang/lib/Evaluate/variable.cpp b/flang/lib/Evaluate/variable.cpp
index 10362c583831..3ebd68a4543b 100644
--- a/flang/lib/Evaluate/variable.cpp
+++ b/flang/lib/Evaluate/variable.cpp
@@ -27,7 +27,7 @@ Triplet::Triplet() : stride_{Expr<SubscriptInteger>{1}} {}
 Triplet::Triplet(std::optional<Expr<SubscriptInteger>> &&l,
     std::optional<Expr<SubscriptInteger>> &&u,
     std::optional<Expr<SubscriptInteger>> &&s)
-  : stride_{s ? std::move(*s) : Expr<SubscriptInteger>{1}} {
+    : stride_{s ? std::move(*s) : Expr<SubscriptInteger>{1}} {
   if (l) {
     lower_.emplace(std::move(*l));
   }
@@ -77,8 +77,8 @@ bool Triplet::IsStrideOne() const {
 
 CoarrayRef::CoarrayRef(SymbolVector &&base, std::vector<Subscript> &&ss,
     std::vector<Expr<SubscriptInteger>> &&css)
-  : base_{std::move(base)}, subscript_(std::move(ss)),
-    cosubscript_(std::move(css)) {
+    : base_{std::move(base)}, subscript_(std::move(ss)),
+      cosubscript_(std::move(css)) {
   CHECK(!base_.empty());
   CHECK(!cosubscript_.empty());
 }
@@ -230,7 +230,8 @@ std::optional<Expr<SomeCharacter>> Substring::Fold(FoldingContext &context) {
       case 4:
         return {AsCategoryExpr(Constant<Type<TypeCategory::Character, 4>>{
             *newStaticData->AsU32String()})};
-      default: CRASH_NO_CASE;
+      default:
+        CRASH_NO_CASE;
       }
     }
   }
@@ -239,7 +240,7 @@ std::optional<Expr<SomeCharacter>> Substring::Fold(FoldingContext &context) {
 
 DescriptorInquiry::DescriptorInquiry(
     const NamedEntity &base, Field field, int dim)
-  : base_{base}, field_{field}, dimension_{dim} {
+    : base_{base}, field_{field}, dimension_{dim} {
   const Symbol &last{base_.GetLastSymbol()};
   CHECK(IsDescriptor(last));
   CHECK((field == Field::Len && dim == 0) ||
@@ -247,7 +248,7 @@ DescriptorInquiry::DescriptorInquiry(
 }
 
 DescriptorInquiry::DescriptorInquiry(NamedEntity &&base, Field field, int dim)
-  : base_{std::move(base)}, field_{field}, dimension_{dim} {
+    : base_{std::move(base)}, field_{field}, dimension_{dim} {
   const Symbol &last{base_.GetLastSymbol()};
   CHECK(IsDescriptor(last));
   CHECK((field == Field::Len && dim == 0) ||
@@ -298,11 +299,10 @@ std::optional<Expr<SubscriptInteger>> CoarrayRef::LEN() const {
 }
 
 std::optional<Expr<SubscriptInteger>> DataRef::LEN() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return SymbolLEN(symbol); },
-          [](const auto &x) { return x.LEN(); },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return SymbolLEN(symbol); },
+                        [](const auto &x) { return x.LEN(); },
+                    },
       u);
 }
 
@@ -316,14 +316,13 @@ std::optional<Expr<SubscriptInteger>> Substring::LEN() const {
   }
 }
 
-template<typename T>
+template <typename T>
 std::optional<Expr<SubscriptInteger>> Designator<T>::LEN() const {
   if constexpr (T::category == TypeCategory::Character) {
-    return std::visit(
-        common::visitors{
-            [](SymbolRef symbol) { return SymbolLEN(symbol); },
-            [](const auto &x) { return x.LEN(); },
-        },
+    return std::visit(common::visitors{
+                          [](SymbolRef symbol) { return SymbolLEN(symbol); },
+                          [](const auto &x) { return x.LEN(); },
+                      },
         u);
   } else {
     common::die("Designator<non-char>::LEN() called");
@@ -354,11 +353,10 @@ std::optional<Expr<SubscriptInteger>> ProcedureDesignator::LEN() const {
 
 // Rank()
 int BaseObject::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return symbol->Rank(); },
-          [](const StaticDataObject::Pointer &) { return 0; },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return symbol->Rank(); },
+                        [](const StaticDataObject::Pointer &) { return 0; },
+                    },
       u);
 }
 
@@ -370,22 +368,20 @@ int Component::Rank() const {
 }
 
 int NamedEntity::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](const SymbolRef s) { return s->Rank(); },
-          [](const Component &c) { return c.Rank(); },
-      },
+  return std::visit(common::visitors{
+                        [](const SymbolRef s) { return s->Rank(); },
+                        [](const Component &c) { return c.Rank(); },
+                    },
       u_);
 }
 
 int Subscript::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](const IndirectSubscriptIntegerExpr &x) {
-            return x.value().Rank();
-          },
-          [](const Triplet &) { return 1; },
-      },
+  return std::visit(common::visitors{
+                        [](const IndirectSubscriptIntegerExpr &x) {
+                          return x.value().Rank();
+                        },
+                        [](const Triplet &) { return 1; },
+                    },
       u);
 }
 
@@ -416,31 +412,28 @@ int CoarrayRef::Rank() const {
 }
 
 int DataRef::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return symbol->Rank(); },
-          [](const auto &x) { return x.Rank(); },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return symbol->Rank(); },
+                        [](const auto &x) { return x.Rank(); },
+                    },
       u);
 }
 
 int Substring::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](const DataRef &dataRef) { return dataRef.Rank(); },
-          [](const StaticDataObject::Pointer &) { return 0; },
-      },
+  return std::visit(common::visitors{
+                        [](const DataRef &dataRef) { return dataRef.Rank(); },
+                        [](const StaticDataObject::Pointer &) { return 0; },
+                    },
       parent_);
 }
 
 int ComplexPart::Rank() const { return complex_.Rank(); }
 
-template<typename T> int Designator<T>::Rank() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return symbol->Rank(); },
-          [](const auto &x) { return x.Rank(); },
-      },
+template <typename T> int Designator<T>::Rank() const {
+  return std::visit(common::visitors{
+                        [](SymbolRef symbol) { return symbol->Rank(); },
+                        [](const auto &x) { return x.Rank(); },
+                    },
       u);
 }
 
@@ -450,42 +443,38 @@ const Symbol &Component::GetFirstSymbol() const {
 }
 
 const Symbol &NamedEntity::GetFirstSymbol() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef s) -> const Symbol & { return s; },
-          [](const Component &c) -> const Symbol & {
-            return c.GetFirstSymbol();
-          },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef s) -> const Symbol & { return s; },
+                        [](const Component &c) -> const Symbol & {
+                          return c.GetFirstSymbol();
+                        },
+                    },
       u_);
 }
 
 const Symbol &NamedEntity::GetLastSymbol() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef s) -> const Symbol & { return s; },
-          [](const Component &c) -> const Symbol & {
-            return c.GetLastSymbol();
-          },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef s) -> const Symbol & { return s; },
+                        [](const Component &c) -> const Symbol & {
+                          return c.GetLastSymbol();
+                        },
+                    },
       u_);
 }
 
 const Component *NamedEntity::UnwrapComponent() const {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef) -> const Component * { return nullptr; },
-          [](const Component &c) { return &c; },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef) -> const Component * { return nullptr; },
+                        [](const Component &c) { return &c; },
+                    },
       u_);
 }
 
 Component *NamedEntity::UnwrapComponent() {
-  return std::visit(
-      common::visitors{
-          [](SymbolRef &) -> Component * { return nullptr; },
-          [](Component &c) { return &c; },
-      },
+  return std::visit(common::visitors{
+                        [](SymbolRef &) -> Component * { return nullptr; },
+                        [](Component &c) { return &c; },
+                    },
       u_);
 }
 
@@ -496,33 +485,30 @@ const Symbol &ArrayRef::GetFirstSymbol() const {
 const Symbol &ArrayRef::GetLastSymbol() const { return base_.GetLastSymbol(); }
 
 const Symbol &DataRef::GetFirstSymbol() const {
-  return *std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return &*symbol; },
-          [](const auto &x) { return &x.GetFirstSymbol(); },
-      },
+  return *std::visit(common::visitors{
+                         [](SymbolRef symbol) { return &*symbol; },
+                         [](const auto &x) { return &x.GetFirstSymbol(); },
+                     },
       u);
 }
 
 const Symbol &DataRef::GetLastSymbol() const {
-  return *std::visit(
-      common::visitors{
-          [](SymbolRef symbol) { return &*symbol; },
-          [](const auto &x) { return &x.GetLastSymbol(); },
-      },
+  return *std::visit(common::visitors{
+                         [](SymbolRef symbol) { return &*symbol; },
+                         [](const auto &x) { return &x.GetLastSymbol(); },
+                     },
       u);
 }
 
 BaseObject Substring::GetBaseObject() const {
-  return std::visit(
-      common::visitors{
-          [](const DataRef &dataRef) {
-            return BaseObject{dataRef.GetFirstSymbol()};
-          },
-          [](StaticDataObject::Pointer pointer) {
-            return BaseObject{std::move(pointer)};
-          },
-      },
+  return std::visit(common::visitors{
+                        [](const DataRef &dataRef) {
+                          return BaseObject{dataRef.GetFirstSymbol()};
+                        },
+                        [](StaticDataObject::Pointer pointer) {
+                          return BaseObject{std::move(pointer)};
+                        },
+                    },
       parent_);
 }
 
@@ -535,7 +521,7 @@ const Symbol *Substring::GetLastSymbol() const {
       parent_);
 }
 
-template<typename T> BaseObject Designator<T>::GetBaseObject() const {
+template <typename T> BaseObject Designator<T>::GetBaseObject() const {
   return std::visit(
       common::visitors{
           [](SymbolRef symbol) { return BaseObject{symbol}; },
@@ -553,7 +539,7 @@ template<typename T> BaseObject Designator<T>::GetBaseObject() const {
       u);
 }
 
-template<typename T> const Symbol *Designator<T>::GetLastSymbol() const {
+template <typename T> const Symbol *Designator<T>::GetLastSymbol() const {
   return std::visit(
       common::visitors{
           [](SymbolRef symbol) { return &*symbol; },
@@ -571,7 +557,8 @@ template<typename T> const Symbol *Designator<T>::GetLastSymbol() const {
       u);
 }
 
-template<typename T> std::optional<DynamicType> Designator<T>::GetType() const {
+template <typename T>
+std::optional<DynamicType> Designator<T>::GetType() const {
   if constexpr (IsLengthlessIntrinsicType<Result>) {
     return {Result::GetType()};
   } else {
@@ -616,7 +603,7 @@ static bool AreSameSymbol(const Symbol &x, const Symbol &y) {
 
 // Implements operator==() for a union type, using special case handling
 // for Symbol references.
-template<typename A> static bool TestVariableEquality(const A &x, const A &y) {
+template <typename A> static bool TestVariableEquality(const A &x, const A &y) {
   const SymbolRef *xSymbol{std::get_if<SymbolRef>(&x.u)};
   if (const SymbolRef * ySymbol{std::get_if<SymbolRef>(&y.u)}) {
     return xSymbol && AreSameSymbol(*xSymbol, *ySymbol);
@@ -639,7 +626,7 @@ bool NamedEntity::operator==(const NamedEntity &that) const {
     return !that.IsSymbol() && GetComponent() == that.GetComponent();
   }
 }
-template<int KIND>
+template <int KIND>
 bool TypeParamInquiry<KIND>::operator==(
     const TypeParamInquiry<KIND> &that) const {
   return &*parameter_ == &*that.parameter_ && base_ == that.base_;
@@ -670,11 +657,11 @@ bool ComplexPart::operator==(const ComplexPart &that) const {
 bool ProcedureRef::operator==(const ProcedureRef &that) const {
   return proc_ == that.proc_ && arguments_ == that.arguments_;
 }
-template<typename T>
+template <typename T>
 bool Designator<T>::operator==(const Designator<T> &that) const {
   return TestVariableEquality(*this, that);
 }
-template<typename T>
+template <typename T>
 bool Variable<T>::operator==(const Variable<T> &that) const {
   return u == that.u;
 }
@@ -684,6 +671,6 @@ bool DescriptorInquiry::operator==(const DescriptorInquiry &that) const {
 }
 
 INSTANTIATE_VARIABLE_TEMPLATES
-}
+} // namespace Fortran::evaluate
 
 template class Fortran::common::Indirection<Fortran::evaluate::Component, true>;
diff --git a/flang/lib/Optimizer/Dialect/FIRAttr.cpp b/flang/lib/Optimizer/Dialect/FIRAttr.cpp
index 1ba242b9484b..76cccbfb06d3 100644
--- a/flang/lib/Optimizer/Dialect/FIRAttr.cpp
+++ b/flang/lib/Optimizer/Dialect/FIRAttr.cpp
@@ -32,9 +32,7 @@ struct RealAttributeStorage : public mlir::AttributeStorage {
   RealAttributeStorage(const KeyTy &key)
       : RealAttributeStorage(key.first, key.second) {}
 
-  static unsigned hashKey(const KeyTy &key) {
-    return llvm::hash_value(key);
-  }
+  static unsigned hashKey(const KeyTy &key) { return llvm::hash_value(key); }
 
   bool operator==(const KeyTy &key) const {
     return key.first == kind &&
diff --git a/flang/lib/Optimizer/Dialect/FIRDialect.cpp b/flang/lib/Optimizer/Dialect/FIRDialect.cpp
index b6dd9edb2a2f..9a56c6bc403e 100644
--- a/flang/lib/Optimizer/Dialect/FIRDialect.cpp
+++ b/flang/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -25,7 +25,7 @@ fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
   addOperations<
 #define GET_OP_LIST
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"
-                >();
+      >();
 }
 
 // anchor the class vtable to this compilation unit
diff --git a/flang/lib/Parser/Fortran-parsers.cpp b/flang/lib/Parser/Fortran-parsers.cpp
index 1bf5393b9b42..fb6ab347979d 100644
--- a/flang/lib/Parser/Fortran-parsers.cpp
+++ b/flang/lib/Parser/Fortran-parsers.cpp
@@ -594,7 +594,7 @@ TYPE_PARSER(recovery("END ENUM"_tok, "END" >> SkipPast<'\n'>{}) >>
 //        declaration-type-spec [[, attr-spec]... ::] entity-decl-list
 constexpr auto entityDeclWithoutEqInit{construct<EntityDecl>(name,
     maybe(arraySpec), maybe(coarraySpec), maybe("*" >> charLength),
-    !"="_tok >> maybe(initialization))};  // old-style REAL A/0/ still works
+    !"="_tok >> maybe(initialization))}; // old-style REAL A/0/ still works
 TYPE_PARSER(
     construct<TypeDeclarationStmt>(declarationTypeSpec,
         defaulted("," >> nonemptyList(Parser<AttrSpec>{})) / "::",
@@ -738,7 +738,7 @@ TYPE_PARSER(construct<AccessStmt>(accessSpec,
 
 // R828 access-id -> access-name | generic-spec
 TYPE_PARSER(construct<AccessId>(indirect(genericSpec)) ||
-    construct<AccessId>(name))  // initially ambiguous with genericSpec
+    construct<AccessId>(name)) // initially ambiguous with genericSpec
 
 // R829 allocatable-stmt -> ALLOCATABLE [::] allocatable-decl-list
 TYPE_PARSER(construct<AllocatableStmt>("ALLOCATABLE" >> maybe("::"_tok) >>
@@ -1254,4 +1254,4 @@ TYPE_CONTEXT_PARSER("PAUSE statement"_en_US,
 //     is not used because parsing is not sensitive to rank
 //   R1030 default-char-constant-expr -> default-char-expr
 //     is only used via scalar-default-char-constant-expr
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/basic-parsers.h b/flang/lib/Parser/basic-parsers.h
index 10df4a71bcf9..b05a68da7922 100644
--- a/flang/lib/Parser/basic-parsers.h
+++ b/flang/lib/Parser/basic-parsers.h
@@ -46,7 +46,7 @@ namespace Fortran::parser {
 // error message at the current position.  The result type is unused,
 // but might have to be specified at the point of call to satisfy
 // the type checker.  The state remains valid.
-template<typename A> class FailParser {
+template <typename A> class FailParser {
 public:
   using resultType = A;
   constexpr FailParser(const FailParser &) = default;
@@ -60,13 +60,13 @@ private:
   const MessageFixedText text_;
 };
 
-template<typename A = Success> inline constexpr auto fail(MessageFixedText t) {
+template <typename A = Success> inline constexpr auto fail(MessageFixedText t) {
   return FailParser<A>{t};
 }
 
 // pure(x) returns a parser that always succeeds, does not advance the
 // parse, and returns a captured value whose type must be copy-constructible.
-template<typename A> class PureParser {
+template <typename A> class PureParser {
 public:
   using resultType = A;
   constexpr PureParser(const PureParser &) = default;
@@ -77,13 +77,13 @@ private:
   const A value_;
 };
 
-template<typename A> inline constexpr auto pure(A x) {
+template <typename A> inline constexpr auto pure(A x) {
   return PureParser<A>(std::move(x));
 }
 
 // If a is a parser, attempt(a) is the same parser, but on failure
 // the ParseState is guaranteed to have been restored to its initial value.
-template<typename A> class BacktrackingParser {
+template <typename A> class BacktrackingParser {
 public:
   using resultType = typename A::resultType;
   constexpr BacktrackingParser(const BacktrackingParser &) = default;
@@ -105,13 +105,13 @@ private:
   const A parser_;
 };
 
-template<typename A> inline constexpr auto attempt(const A &parser) {
+template <typename A> inline constexpr auto attempt(const A &parser) {
   return BacktrackingParser<A>{parser};
 }
 
 // For any parser x, the parser returned by !x is one that succeeds when
 // x fails, returning a useless (but present) result.  !x fails when x succeeds.
-template<typename PA> class NegatedParser {
+template <typename PA> class NegatedParser {
 public:
   using resultType = Success;
   constexpr NegatedParser(const NegatedParser &) = default;
@@ -129,14 +129,14 @@ private:
   const PA parser_;
 };
 
-template<typename PA, typename = typename PA::resultType>
+template <typename PA, typename = typename PA::resultType>
 constexpr auto operator!(PA p) {
   return NegatedParser<PA>(p);
 }
 
 // For any parser x, the parser returned by lookAhead(x) is one that succeeds
 // or fails if x does, but the state is not modified.
-template<typename PA> class LookAheadParser {
+template <typename PA> class LookAheadParser {
 public:
   using resultType = Success;
   constexpr LookAheadParser(const LookAheadParser &) = default;
@@ -154,18 +154,18 @@ private:
   const PA parser_;
 };
 
-template<typename PA> inline constexpr auto lookAhead(PA p) {
+template <typename PA> inline constexpr auto lookAhead(PA p) {
   return LookAheadParser<PA>{p};
 }
 
 // If a is a parser, inContext("..."_en_US, a) runs it in a nested message
 // context.
-template<typename PA> class MessageContextParser {
+template <typename PA> class MessageContextParser {
 public:
   using resultType = typename PA::resultType;
   constexpr MessageContextParser(const MessageContextParser &) = default;
   constexpr MessageContextParser(MessageFixedText t, PA p)
-    : text_{t}, parser_{p} {}
+      : text_{t}, parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     state.PushContext(text_);
     std::optional<resultType> result{parser_.Parse(state)};
@@ -178,7 +178,7 @@ private:
   const PA parser_;
 };
 
-template<typename PA>
+template <typename PA>
 inline constexpr auto inContext(MessageFixedText context, PA parser) {
   return MessageContextParser{context, parser};
 }
@@ -186,12 +186,12 @@ inline constexpr auto inContext(MessageFixedText context, PA parser) {
 // If a is a parser, withMessage("..."_en_US, a) runs it unchanged if it
 // succeeds, and overrides its messages with a specific one if it fails and
 // has matched no tokens.
-template<typename PA> class WithMessageParser {
+template <typename PA> class WithMessageParser {
 public:
   using resultType = typename PA::resultType;
   constexpr WithMessageParser(const WithMessageParser &) = default;
   constexpr WithMessageParser(MessageFixedText t, PA p)
-    : text_{t}, parser_{p} {}
+      : text_{t}, parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     Messages messages{std::move(state.messages())};
     ParseState backtrack{state};
@@ -226,7 +226,7 @@ private:
   const PA parser_;
 };
 
-template<typename PA>
+template <typename PA>
 inline constexpr auto withMessage(MessageFixedText msg, PA parser) {
   return WithMessageParser{msg, parser};
 }
@@ -235,7 +235,7 @@ inline constexpr auto withMessage(MessageFixedText msg, PA parser) {
 // b succeeds after a does so, but fails when either a or b does.  The
 // result is taken from b.  Similarly, a / b also succeeds if both a and b
 // do so, but the result is that returned by a.
-template<typename PA, typename PB> class SequenceParser {
+template <typename PA, typename PB> class SequenceParser {
 public:
   using resultType = typename PB::resultType;
   constexpr SequenceParser(const SequenceParser &) = default;
@@ -253,12 +253,12 @@ private:
   const PB pb_;
 };
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto operator>>(PA pa, PB pb) {
   return SequenceParser<PA, PB>{pa, pb};
 }
 
-template<typename PA, typename PB> class FollowParser {
+template <typename PA, typename PB> class FollowParser {
 public:
   using resultType = typename PA::resultType;
   constexpr FollowParser(const FollowParser &) = default;
@@ -277,12 +277,12 @@ private:
   const PB pb_;
 };
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto operator/(PA pa, PB pb) {
   return FollowParser<PA, PB>{pa, pb};
 }
 
-template<typename PA, typename... Ps> class AlternativesParser {
+template <typename PA, typename... Ps> class AlternativesParser {
 public:
   using resultType = typename PA::resultType;
   constexpr AlternativesParser(PA pa, Ps... ps) : ps_{pa, ps...} {}
@@ -301,7 +301,7 @@ public:
   }
 
 private:
-  template<int J>
+  template <int J>
   void ParseRest(std::optional<resultType> &result, ParseState &state,
       ParseState &backtrack) const {
     ParseState prevState{std::move(state)};
@@ -318,11 +318,11 @@ private:
   const std::tuple<PA, Ps...> ps_;
 };
 
-template<typename... Ps> inline constexpr auto first(Ps... ps) {
+template <typename... Ps> inline constexpr auto first(Ps... ps) {
   return AlternativesParser<Ps...>{ps...};
 }
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto operator||(PA pa, PB pb) {
   return AlternativesParser<PA, PB>{pa, pb};
 }
@@ -331,7 +331,7 @@ inline constexpr auto operator||(PA pa, PB pb) {
 // a does so, or if a fails and b succeeds.  If a succeeds, b is not attempted.
 // All messages from the first parse are retained.
 // The two parsers must return values of the same type.
-template<typename PA, typename PB> class RecoveryParser {
+template <typename PA, typename PB> class RecoveryParser {
 public:
   using resultType = typename PA::resultType;
   static_assert(std::is_same_v<resultType, typename PB::resultType>);
@@ -386,7 +386,7 @@ private:
   const PB pb_;
 };
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto recovery(PA pa, PB pb) {
   return RecoveryParser<PA, PB>{pa, pb};
 }
@@ -394,7 +394,7 @@ inline constexpr auto recovery(PA pa, PB pb) {
 // If x is a parser, then many(x) returns a parser that always succeeds
 // and whose value is a list, possibly empty, of the values returned from
 // repeated application of x until it fails or does not advance the parse.
-template<typename PA> class ManyParser {
+template <typename PA> class ManyParser {
   using paType = typename PA::resultType;
 
 public:
@@ -407,7 +407,7 @@ public:
     while (std::optional<paType> x{parser_.Parse(state)}) {
       result.emplace_back(std::move(*x));
       if (state.GetLocation() <= at) {
-        break;  // no forward progress, don't loop
+        break; // no forward progress, don't loop
       }
       at = state.GetLocation();
     }
@@ -418,7 +418,7 @@ private:
   const BacktrackingParser<PA> parser_;
 };
 
-template<typename PA> inline constexpr auto many(PA parser) {
+template <typename PA> inline constexpr auto many(PA parser) {
   return ManyParser<PA>{parser};
 }
 
@@ -426,7 +426,7 @@ template<typename PA> inline constexpr auto many(PA parser) {
 // and whose value is a nonempty list of the values returned from repeated
 // application of x until it fails or does not advance the parse.  In other
 // words, some(x) is a variant of many(x) that has to succeed at least once.
-template<typename PA> class SomeParser {
+template <typename PA> class SomeParser {
   using paType = typename PA::resultType;
 
 public:
@@ -450,12 +450,12 @@ private:
   const PA parser_;
 };
 
-template<typename PA> inline constexpr auto some(PA parser) {
+template <typename PA> inline constexpr auto some(PA parser) {
   return SomeParser<PA>{parser};
 }
 
 // If x is a parser, skipMany(x) is equivalent to many(x) but with no result.
-template<typename PA> class SkipManyParser {
+template <typename PA> class SkipManyParser {
 public:
   using resultType = Success;
   constexpr SkipManyParser(const SkipManyParser &) = default;
@@ -472,14 +472,14 @@ private:
   const BacktrackingParser<PA> parser_;
 };
 
-template<typename PA> inline constexpr auto skipMany(PA parser) {
+template <typename PA> inline constexpr auto skipMany(PA parser) {
   return SkipManyParser<PA>{parser};
 }
 
 // If x is a parser, skipManyFast(x) is equivalent to skipMany(x).
 // The parser x must always advance on success and never invalidate the
 // state on failure.
-template<typename PA> class SkipManyFastParser {
+template <typename PA> class SkipManyFastParser {
 public:
   using resultType = Success;
   constexpr SkipManyFastParser(const SkipManyFastParser &) = default;
@@ -494,13 +494,13 @@ private:
   const PA parser_;
 };
 
-template<typename PA> inline constexpr auto skipManyFast(PA parser) {
+template <typename PA> inline constexpr auto skipManyFast(PA parser) {
   return SkipManyFastParser<PA>{parser};
 }
 
 // If x is a parser returning some type A, then maybe(x) returns a
 // parser that returns std::optional<A>, always succeeding.
-template<typename PA> class MaybeParser {
+template <typename PA> class MaybeParser {
   using paType = typename PA::resultType;
 
 public:
@@ -519,21 +519,21 @@ private:
   const BacktrackingParser<PA> parser_;
 };
 
-template<typename PA> inline constexpr auto maybe(PA parser) {
+template <typename PA> inline constexpr auto maybe(PA parser) {
   return MaybeParser<PA>{parser};
 }
 
 // If x is a parser, then defaulted(x) returns a parser that always
 // succeeds.  When x succeeds, its result is that of x; otherwise, its
 // result is a default-constructed value of x's result type.
-template<typename PA> class DefaultedParser {
+template <typename PA> class DefaultedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr DefaultedParser(const DefaultedParser &) = default;
   constexpr DefaultedParser(PA p) : parser_{p} {}
   std::optional<resultType> Parse(ParseState &state) const {
     std::optional<std::optional<resultType>> ax{maybe(parser_).Parse(state)};
-    if (ax.value()) {  // maybe() always succeeds
+    if (ax.value()) { // maybe() always succeeds
       return std::move(*ax);
     }
     return resultType{};
@@ -543,7 +543,7 @@ private:
   const BacktrackingParser<PA> parser_;
 };
 
-template<typename PA> inline constexpr auto defaulted(PA p) {
+template <typename PA> inline constexpr auto defaulted(PA p) {
   return DefaultedParser<PA>(p);
 }
 
@@ -568,10 +568,10 @@ template<typename PA> inline constexpr auto defaulted(PA p) {
 
 // Runs a sequence of parsers until one fails or all have succeeded.
 // Collects their results in a std::tuple<std::optional<>...>.
-template<typename... PARSER>
+template <typename... PARSER>
 using ApplyArgs = std::tuple<std::optional<typename PARSER::resultType>...>;
 
-template<typename... PARSER, std::size_t... J>
+template <typename... PARSER, std::size_t... J>
 inline bool ApplyHelperArgs(const std::tuple<PARSER...> &parsers,
     ApplyArgs<PARSER...> &args, ParseState &state, std::index_sequence<J...>) {
   return (... &&
@@ -580,20 +580,20 @@ inline bool ApplyHelperArgs(const std::tuple<PARSER...> &parsers,
 }
 
 // Applies a function to the arguments collected by ApplyHelperArgs.
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 using ApplicableFunctionPointer = RESULT (*)(typename PARSER::resultType &&...);
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 using ApplicableFunctionObject =
     const std::function<RESULT(typename PARSER::resultType &&...)> &;
 
-template<template<typename...> class FUNCTION, typename RESULT,
+template <template <typename...> class FUNCTION, typename RESULT,
     typename... PARSER, std::size_t... J>
 inline RESULT ApplyHelperFunction(FUNCTION<RESULT, PARSER...> f,
     ApplyArgs<PARSER...> &&args, std::index_sequence<J...>) {
   return f(std::move(*std::get<J>(args))...);
 }
 
-template<template<typename...> class FUNCTION, typename RESULT,
+template <template <typename...> class FUNCTION, typename RESULT,
     typename... PARSER>
 class ApplyFunction {
   using funcType = FUNCTION<RESULT, PARSER...>;
@@ -602,7 +602,7 @@ public:
   using resultType = RESULT;
   constexpr ApplyFunction(const ApplyFunction &) = default;
   constexpr ApplyFunction(funcType f, PARSER... p)
-    : function_{f}, parsers_{p...} {}
+      : function_{f}, parsers_{p...} {}
   std::optional<resultType> Parse(ParseState &state) const {
     ApplyArgs<PARSER...> results;
     using Sequence = std::index_sequence_for<PARSER...>;
@@ -619,14 +619,14 @@ private:
   const std::tuple<PARSER...> parsers_;
 };
 
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 inline constexpr auto applyFunction(
     ApplicableFunctionPointer<RESULT, PARSER...> f, const PARSER &... parser) {
   return ApplyFunction<ApplicableFunctionPointer, RESULT, PARSER...>{
       f, parser...};
 }
 
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 inline /* not constexpr */ auto applyLambda(
     ApplicableFunctionObject<RESULT, PARSER...> f, const PARSER &... parser) {
   return ApplyFunction<ApplicableFunctionObject, RESULT, PARSER...>{
@@ -634,17 +634,17 @@ inline /* not constexpr */ auto applyLambda(
 }
 
 // Member function application
-template<typename OBJPARSER, typename... PARSER> class AMFPHelper {
+template <typename OBJPARSER, typename... PARSER> class AMFPHelper {
   using resultType = typename OBJPARSER::resultType;
 
 public:
   using type = void (resultType::*)(typename PARSER::resultType &&...);
 };
-template<typename OBJPARSER, typename... PARSER>
+template <typename OBJPARSER, typename... PARSER>
 using ApplicableMemberFunctionPointer =
     typename AMFPHelper<OBJPARSER, PARSER...>::type;
 
-template<typename OBJPARSER, typename... PARSER, std::size_t... J>
+template <typename OBJPARSER, typename... PARSER, std::size_t... J>
 inline auto ApplyHelperMember(
     ApplicableMemberFunctionPointer<OBJPARSER, PARSER...> mfp,
     ApplyArgs<OBJPARSER, PARSER...> &&args, std::index_sequence<J...>) ->
@@ -653,14 +653,14 @@ inline auto ApplyHelperMember(
   return std::get<0>(std::move(args));
 }
 
-template<typename OBJPARSER, typename... PARSER> class ApplyMemberFunction {
+template <typename OBJPARSER, typename... PARSER> class ApplyMemberFunction {
   using funcType = ApplicableMemberFunctionPointer<OBJPARSER, PARSER...>;
 
 public:
   using resultType = typename OBJPARSER::resultType;
   constexpr ApplyMemberFunction(const ApplyMemberFunction &) = default;
   constexpr ApplyMemberFunction(funcType f, OBJPARSER o, PARSER... p)
-    : function_{f}, parsers_{o, p...} {}
+      : function_{f}, parsers_{o, p...} {}
   std::optional<resultType> Parse(ParseState &state) const {
     ApplyArgs<OBJPARSER, PARSER...> results;
     using Sequence1 = std::index_sequence_for<OBJPARSER, PARSER...>;
@@ -678,7 +678,7 @@ private:
   const std::tuple<OBJPARSER, PARSER...> parsers_;
 };
 
-template<typename OBJPARSER, typename... PARSER>
+template <typename OBJPARSER, typename... PARSER>
 inline constexpr auto applyMem(
     ApplicableMemberFunctionPointer<OBJPARSER, PARSER...> mfp,
     const OBJPARSER &objParser, PARSER... parser) {
@@ -698,13 +698,13 @@ inline constexpr auto applyMem(
 // the opportunity to make construct<> capture source provenance all of the
 // time, and the first form will then lead to better error positioning.)
 
-template<typename RESULT, typename... PARSER, std::size_t... J>
+template <typename RESULT, typename... PARSER, std::size_t... J>
 inline RESULT ApplyHelperConstructor(
     ApplyArgs<PARSER...> &&args, std::index_sequence<J...>) {
   return RESULT{std::move(*std::get<J>(args))...};
 }
 
-template<typename RESULT, typename... PARSER> class ApplyConstructor {
+template <typename RESULT, typename... PARSER> class ApplyConstructor {
 public:
   using resultType = RESULT;
   constexpr ApplyConstructor(const ApplyConstructor &) = default;
@@ -737,14 +737,14 @@ private:
   const std::tuple<PARSER...> parsers_;
 };
 
-template<typename RESULT, typename... PARSER>
+template <typename RESULT, typename... PARSER>
 inline constexpr auto construct(PARSER... p) {
   return ApplyConstructor<RESULT, PARSER...>{p...};
 }
 
 // For a parser p, indirect(p) returns a parser that builds an indirect
 // reference to p's return type.
-template<typename PA> inline constexpr auto indirect(PA p) {
+template <typename PA> inline constexpr auto indirect(PA p) {
   return construct<common::Indirection<typename PA::resultType>>(p);
 }
 
@@ -752,13 +752,13 @@ template<typename PA> inline constexpr auto indirect(PA p) {
 // that succeeds if a does.  If a succeeds, it then applies many(b >> a).
 // The result is the list of the values returned from all of the applications
 // of a.
-template<typename T>
+template <typename T>
 common::IfNoLvalue<std::list<T>, T> prepend(T &&head, std::list<T> &&rest) {
   rest.push_front(std::move(head));
   return std::move(rest);
 }
 
-template<typename PA, typename PB> class NonemptySeparated {
+template <typename PA, typename PB> class NonemptySeparated {
 private:
   using paType = typename PA::resultType;
 
@@ -776,7 +776,7 @@ private:
   const PB separator_;
 };
 
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto nonemptySeparated(PA p, PB sep) {
   return NonemptySeparated<PA, PB>{p, sep};
 }
@@ -791,7 +791,7 @@ inline constexpr auto nonemptySeparated(PA p, PB sep) {
 // which is essentially what "pure(T{})" would be able to do for x's
 // result type T, but without requiring that T have a default constructor
 // or a non-trivial destructor.  The state is preserved.
-template<bool pass> struct FixedParser {
+template <bool pass> struct FixedParser {
   using resultType = Success;
   constexpr FixedParser() {}
   static constexpr std::optional<Success> Parse(ParseState &) {
@@ -807,7 +807,7 @@ constexpr FixedParser<true> ok;
 constexpr FixedParser<false> cut;
 
 // A variant of recovery() above for convenience.
-template<typename PA, typename PB>
+template <typename PA, typename PB>
 inline constexpr auto localRecovery(MessageFixedText msg, PA pa, PB pb) {
   return recovery(withMessage(msg, pa), pb >> defaulted(cut >> pa));
 }
@@ -832,7 +832,7 @@ constexpr NextCh nextCh;
 // If a is a parser for some nonstandard language feature LF, extension<LF>(a)
 // is a parser that optionally enabled, sets a strict conformance violation
 // flag, and may emit a warning message, if those are enabled.
-template<LanguageFeature LF, typename PA> class NonstandardParser {
+template <LanguageFeature LF, typename PA> class NonstandardParser {
 public:
   using resultType = typename PA::resultType;
   constexpr NonstandardParser(const NonstandardParser &) = default;
@@ -856,7 +856,7 @@ private:
   const PA parser_;
 };
 
-template<LanguageFeature LF, typename PA>
+template <LanguageFeature LF, typename PA>
 inline constexpr auto extension(PA parser) {
   return NonstandardParser<LF, PA>(parser);
 }
@@ -864,7 +864,7 @@ inline constexpr auto extension(PA parser) {
 // If a is a parser for some deprecated or deleted language feature LF,
 // deprecated<LF>(a) is a parser that is optionally enabled, sets a strict
 // conformance violation flag, and may emit a warning message, if enabled.
-template<LanguageFeature LF, typename PA> class DeprecatedParser {
+template <LanguageFeature LF, typename PA> class DeprecatedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr DeprecatedParser(const DeprecatedParser &) = default;
@@ -888,13 +888,13 @@ private:
   const PA parser_;
 };
 
-template<LanguageFeature LF, typename PA>
+template <LanguageFeature LF, typename PA>
 inline constexpr auto deprecated(PA parser) {
   return DeprecatedParser<LF, PA>(parser);
 }
 
 // Parsing objects with "source" members.
-template<typename PA> class SourcedParser {
+template <typename PA> class SourcedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr SourcedParser(const SourcedParser &) = default;
@@ -917,8 +917,8 @@ private:
   const PA parser_;
 };
 
-template<typename PA> inline constexpr auto sourced(PA parser) {
+template <typename PA> inline constexpr auto sourced(PA parser) {
   return SourcedParser<PA>{parser};
 }
-}
-#endif  // FORTRAN_PARSER_BASIC_PARSERS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_BASIC_PARSERS_H_
diff --git a/flang/lib/Parser/char-block.cpp b/flang/lib/Parser/char-block.cpp
index f74b08268c6d..5228464fd7b7 100644
--- a/flang/lib/Parser/char-block.cpp
+++ b/flang/lib/Parser/char-block.cpp
@@ -15,4 +15,4 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const CharBlock &x) {
   return os << x.ToString();
 }
 
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/char-buffer.cpp b/flang/lib/Parser/char-buffer.cpp
index 4f72a7bdac31..e0fc7335424b 100644
--- a/flang/lib/Parser/char-buffer.cpp
+++ b/flang/lib/Parser/char-buffer.cpp
@@ -87,4 +87,4 @@ std::string CharBuffer::MarshalNormalized() const {
   result.shrink_to_fit();
   return result;
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/char-set.cpp b/flang/lib/Parser/char-set.cpp
index 382cc4f430d5..439e9fbff3a8 100644
--- a/flang/lib/Parser/char-set.cpp
+++ b/flang/lib/Parser/char-set.cpp
@@ -21,4 +21,4 @@ std::string SetOfChars::ToString() const {
   }
   return result;
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/characters.cpp b/flang/lib/Parser/characters.cpp
index 62df4013332c..dce20a4e5fe4 100644
--- a/flang/lib/Parser/characters.cpp
+++ b/flang/lib/Parser/characters.cpp
@@ -33,7 +33,7 @@ int UTF_8CharacterBytes(const char *p) {
   }
 }
 
-template<typename STRING>
+template <typename STRING>
 std::string QuoteCharacterLiteralHelper(
     const STRING &str, bool backslashEscapes, Encoding encoding) {
   std::string result{'"'};
@@ -42,7 +42,7 @@ std::string QuoteCharacterLiteralHelper(
     using CharT = std::decay_t<decltype(ch)>;
     char32_t ch32{static_cast<std::make_unsigned_t<CharT>>(ch)};
     if (ch32 == static_cast<unsigned char>('"')) {
-      emit('"');  // double the " when it appears in the text
+      emit('"'); // double the " when it appears in the text
     }
     EmitQuotedChar(ch32, emit, emit, backslashEscapes, encoding);
   }
@@ -65,7 +65,7 @@ std::string QuoteCharacterLiteral(
   return QuoteCharacterLiteralHelper(str, backslashEscapes, encoding);
 }
 
-template<> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t ucs) {
+template <> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t ucs) {
   CHECK(ucs <= 0xff);
   EncodedCharacter result;
   result.buffer[0] = ucs;
@@ -73,7 +73,7 @@ template<> EncodedCharacter EncodeCharacter<Encoding::LATIN_1>(char32_t ucs) {
   return result;
 }
 
-template<> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t ucs) {
+template <> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t ucs) {
   // N.B. char32_t is unsigned
   EncodedCharacter result;
   if (ucs <= 0x7f) {
@@ -118,12 +118,14 @@ template<> EncodedCharacter EncodeCharacter<Encoding::UTF_8>(char32_t ucs) {
 EncodedCharacter EncodeCharacter(Encoding encoding, char32_t ucs) {
   switch (encoding) {
     SWITCH_COVERS_ALL_CASES
-  case Encoding::LATIN_1: return EncodeCharacter<Encoding::LATIN_1>(ucs);
-  case Encoding::UTF_8: return EncodeCharacter<Encoding::UTF_8>(ucs);
+  case Encoding::LATIN_1:
+    return EncodeCharacter<Encoding::LATIN_1>(ucs);
+  case Encoding::UTF_8:
+    return EncodeCharacter<Encoding::UTF_8>(ucs);
   }
 }
 
-template<Encoding ENCODING, typename STRING>
+template <Encoding ENCODING, typename STRING>
 std::string EncodeString(const STRING &str) {
   std::string result;
   for (auto ch : str) {
@@ -141,7 +143,7 @@ template std::string EncodeString<Encoding::UTF_8, std::u16string>(
 template std::string EncodeString<Encoding::UTF_8, std::u32string>(
     const std::u32string &);
 
-template<>
+template <>
 DecodedCharacter DecodeRawCharacter<Encoding::LATIN_1>(
     const char *cp, std::size_t bytes) {
   if (bytes >= 1) {
@@ -151,7 +153,7 @@ DecodedCharacter DecodeRawCharacter<Encoding::LATIN_1>(
   }
 }
 
-template<>
+template <>
 DecodedCharacter DecodeRawCharacter<Encoding::UTF_8>(
     const char *cp, std::size_t bytes) {
   auto p{reinterpret_cast<const std::uint8_t *>(cp)};
@@ -174,7 +176,7 @@ DecodedCharacter DecodeRawCharacter<Encoding::UTF_8>(
     ch = ((ch & 0x1f) << 6) | (p[1] & 0x3f);
     return {ch, 2};
   } else {
-    return {};  // not valid UTF-8
+    return {}; // not valid UTF-8
   }
 }
 
@@ -186,7 +188,7 @@ static DecodedCharacter DecodeEscapedCharacter(
     } else if (IsOctalDigit(cp[1])) {
       std::size_t maxLen{std::min(std::size_t{4}, bytes)};
       char32_t code{static_cast<char32_t>(DecimalDigitValue(cp[1]))};
-      std::size_t len{2};  // so far
+      std::size_t len{2}; // so far
       for (; code <= 037 && len < maxLen && IsOctalDigit(cp[len]); ++len) {
         code = 8 * code + DecimalDigitValue(cp[len]);
       }
@@ -207,7 +209,7 @@ static DecodedCharacter DecodeEscapedCharacter(
   return {static_cast<unsigned char>(cp[0]), 1};
 }
 
-template<Encoding ENCODING>
+template <Encoding ENCODING>
 static DecodedCharacter DecodeEscapedCharacters(
     const char *cp, std::size_t bytes) {
   char buffer[EncodedCharacter::maxEncodingBytes];
@@ -229,7 +231,7 @@ static DecodedCharacter DecodeEscapedCharacters(
   return code;
 }
 
-template<Encoding ENCODING>
+template <Encoding ENCODING>
 DecodedCharacter DecodeCharacter(
     const char *cp, std::size_t bytes, bool backslashEscapes) {
   if (backslashEscapes && bytes >= 2 && *cp == '\\') {
@@ -255,7 +257,7 @@ DecodedCharacter DecodeCharacter(Encoding encoding, const char *cp,
   }
 }
 
-template<typename RESULT, Encoding ENCODING>
+template <typename RESULT, Encoding ENCODING>
 RESULT DecodeString(const std::string &s, bool backslashEscapes) {
   RESULT result;
   const char *p{s.c_str()};
@@ -283,4 +285,4 @@ template std::u16string DecodeString<std::u16string, Encoding::UTF_8>(
     const std::string &, bool);
 template std::u32string DecodeString<std::u32string, Encoding::UTF_8>(
     const std::string &, bool);
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/debug-parser.cpp b/flang/lib/Parser/debug-parser.cpp
index 75578ec51840..dbcc64f14bb1 100644
--- a/flang/lib/Parser/debug-parser.cpp
+++ b/flang/lib/Parser/debug-parser.cpp
@@ -23,4 +23,4 @@ std::optional<Success> DebugParser::Parse(ParseState &state) const {
   }
   return {Success{}};
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/debug-parser.h b/flang/lib/Parser/debug-parser.h
index fb9f208cd2fd..3c0079bf623c 100644
--- a/flang/lib/Parser/debug-parser.h
+++ b/flang/lib/Parser/debug-parser.h
@@ -25,7 +25,7 @@ public:
   using resultType = Success;
   constexpr DebugParser(const DebugParser &) = default;
   constexpr DebugParser(const char *str, std::size_t n)
-    : str_{str}, length_{n} {}
+      : str_{str}, length_{n} {}
   std::optional<Success> Parse(ParseState &) const;
 
 private:
@@ -36,5 +36,5 @@ private:
 constexpr DebugParser operator""_debug(const char str[], std::size_t n) {
   return DebugParser{str, n};
 }
-}
-#endif  // FORTRAN_PARSER_DEBUG_PARSER_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_DEBUG_PARSER_H_
diff --git a/flang/lib/Parser/executable-parsers.cpp b/flang/lib/Parser/executable-parsers.cpp
index df1e7ba59d44..160b2dc376a4 100644
--- a/flang/lib/Parser/executable-parsers.cpp
+++ b/flang/lib/Parser/executable-parsers.cpp
@@ -121,7 +121,7 @@ TYPE_PARSER(first(construct<ActionStmt>(indirect(Parser<AllocateStmt>{})),
     construct<ActionStmt>(indirect(Parser<ReadStmt>{})),
     construct<ActionStmt>(indirect(Parser<ReturnStmt>{})),
     construct<ActionStmt>(indirect(Parser<RewindStmt>{})),
-    construct<ActionStmt>(indirect(Parser<StopStmt>{})),  // & error-stop-stmt
+    construct<ActionStmt>(indirect(Parser<StopStmt>{})), // & error-stop-stmt
     construct<ActionStmt>(indirect(Parser<SyncAllStmt>{})),
     construct<ActionStmt>(indirect(Parser<SyncImagesStmt>{})),
     construct<ActionStmt>(indirect(Parser<SyncMemoryStmt>{})),
@@ -163,7 +163,7 @@ TYPE_PARSER(construct<EndAssociateStmt>(
 //         block-stmt [block-specification-part] block end-block-stmt
 TYPE_CONTEXT_PARSER("BLOCK construct"_en_US,
     construct<BlockConstruct>(statement(Parser<BlockStmt>{}),
-        Parser<BlockSpecificationPart>{},  // can be empty
+        Parser<BlockSpecificationPart>{}, // can be empty
         block, statement(Parser<EndBlockStmt>{})))
 
 // R1108 block-stmt -> [block-construct-name :] BLOCK
@@ -522,4 +522,4 @@ TYPE_CONTEXT_PARSER("UNLOCK statement"_en_US,
     construct<UnlockStmt>("UNLOCK (" >> lockVariable,
         defaulted("," >> nonemptyList(statOrErrmsg)) / ")"))
 
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/expr-parsers.cpp b/flang/lib/Parser/expr-parsers.cpp
index 79370881759c..a7ae7c32f9f6 100644
--- a/flang/lib/Parser/expr-parsers.cpp
+++ b/flang/lib/Parser/expr-parsers.cpp
@@ -84,7 +84,7 @@ constexpr auto primary{instrumented("primary"_en_US,
 // R1002 level-1-expr -> [defined-unary-op] primary
 // TODO: Reasonable extension: permit multiple defined-unary-ops
 constexpr auto level1Expr{sourced(
-    first(primary,  // must come before define op to resolve .TRUE._8 ambiguity
+    first(primary, // must come before define op to resolve .TRUE._8 ambiguity
         construct<Expr>(construct<Expr::DefinedUnary>(definedOpName, primary)),
         extension<LanguageFeature::SignedPrimary>(
             construct<Expr>(construct<Expr::UnaryPlus>("+" >> primary))),
@@ -110,7 +110,7 @@ inline std::optional<Expr> MultOperand::Parse(ParseState &state) {
       std::function<Expr(Expr &&)> power{[&result](Expr &&right) {
         return Expr{Expr::Power(std::move(result).value(), std::move(right))};
       }};
-      return applyLambda(power, multOperand).Parse(state);  // right-recursive
+      return applyLambda(power, multOperand).Parse(state); // right-recursive
     }
   }
   return result;
@@ -362,7 +362,7 @@ constexpr struct Level5Expr {
 
 // R1022 expr -> [expr defined-binary-op] level-5-expr
 // Defined binary operators associate leftwards.
-template<> std::optional<Expr> Parser<Expr>::Parse(ParseState &state) {
+template <> std::optional<Expr> Parser<Expr>::Parse(ParseState &state) {
   std::optional<Expr> result{level5Expr.Parse(state)};
   if (result) {
     auto source{result->source};
@@ -513,4 +513,4 @@ TYPE_CONTEXT_PARSER("END FORALL statement"_en_US,
 TYPE_CONTEXT_PARSER("FORALL statement"_en_US,
     construct<ForallStmt>("FORALL" >> indirect(concurrentHeader),
         unlabeledStatement(forallAssignmentStmt)))
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/expr-parsers.h b/flang/lib/Parser/expr-parsers.h
index 7106352943f9..1a93344fffb7 100644
--- a/flang/lib/Parser/expr-parsers.h
+++ b/flang/lib/Parser/expr-parsers.h
@@ -18,24 +18,24 @@ namespace Fortran::parser {
 
 // R403 scalar-xyz -> xyz
 // Also define constant-xyz, int-xyz, default-char-xyz.
-template<typename PA> inline constexpr auto scalar(const PA &p) {
-  return construct<Scalar<typename PA::resultType>>(p);  // scalar-p
+template <typename PA> inline constexpr auto scalar(const PA &p) {
+  return construct<Scalar<typename PA::resultType>>(p); // scalar-p
 }
 
-template<typename PA> inline constexpr auto constant(const PA &p) {
-  return construct<Constant<typename PA::resultType>>(p);  // constant-p
+template <typename PA> inline constexpr auto constant(const PA &p) {
+  return construct<Constant<typename PA::resultType>>(p); // constant-p
 }
 
-template<typename PA> inline constexpr auto integer(const PA &p) {
-  return construct<Integer<typename PA::resultType>>(p);  // int-p
+template <typename PA> inline constexpr auto integer(const PA &p) {
+  return construct<Integer<typename PA::resultType>>(p); // int-p
 }
 
-template<typename PA> inline constexpr auto logical(const PA &p) {
-  return construct<Logical<typename PA::resultType>>(p);  // logical-p
+template <typename PA> inline constexpr auto logical(const PA &p) {
+  return construct<Logical<typename PA::resultType>>(p); // logical-p
 }
 
-template<typename PA> inline constexpr auto defaultChar(const PA &p) {
-  return construct<DefaultChar<typename PA::resultType>>(p);  // default-char-p
+template <typename PA> inline constexpr auto defaultChar(const PA &p) {
+  return construct<DefaultChar<typename PA::resultType>>(p); // default-char-p
 }
 
 // N.B. charLiteralConstantWithoutKind does not skip preceding space.
@@ -97,9 +97,9 @@ inline constexpr auto loopBounds(decltype(scalarExpr) &p) {
   return construct<LoopBounds<ScalarName, ScalarExpr>>(
       scalar(name) / "=", p / ",", p, maybe("," >> p));
 }
-template<typename PA> inline constexpr auto loopBounds(const PA &p) {
+template <typename PA> inline constexpr auto loopBounds(const PA &p) {
   return construct<LoopBounds<DoVariable, typename PA::resultType>>(
       doVariable / "=", p / ",", p, maybe("," >> p));
 }
-}
+} // namespace Fortran::parser
 #endif
diff --git a/flang/lib/Parser/instrumented-parser.cpp b/flang/lib/Parser/instrumented-parser.cpp
index 7419c53874ca..765d29219395 100644
--- a/flang/lib/Parser/instrumented-parser.cpp
+++ b/flang/lib/Parser/instrumented-parser.cpp
@@ -35,7 +35,7 @@ bool ParsingLog::Fails(
   }
   auto &entry{tagIter->second};
   if (entry.deferred && !state.deferMessages()) {
-    return false;  // don't fail fast, we want to generate messages
+    return false; // don't fail fast, we want to generate messages
   }
   ++entry.count;
   if (!state.deferMessages()) {
@@ -74,4 +74,4 @@ void ParsingLog::Dump(llvm::raw_ostream &o, const CookedSource &cooked) const {
     }
   }
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/io-parsers.cpp b/flang/lib/Parser/io-parsers.cpp
index 48b383bfd80a..9eab72172b7b 100644
--- a/flang/lib/Parser/io-parsers.cpp
+++ b/flang/lib/Parser/io-parsers.cpp
@@ -136,7 +136,7 @@ TYPE_CONTEXT_PARSER("CLOSE statement"_en_US,
 //         READ format [, input-item-list]
 constexpr auto inputItemList{
     extension<LanguageFeature::IOListLeadingComma>(
-        some("," >> inputItem)) ||  // legacy extension: leading comma
+        some("," >> inputItem)) || // legacy extension: leading comma
     optionalList(inputItem)};
 
 TYPE_CONTEXT_PARSER("READ statement"_en_US,
@@ -217,7 +217,7 @@ TYPE_PARSER(first(construct<IoControlSpec>("UNIT =" >> ioUnit),
 // R1211 write-stmt -> WRITE ( io-control-spec-list ) [output-item-list]
 constexpr auto outputItemList{
     extension<LanguageFeature::IOListLeadingComma>(
-        some("," >> outputItem)) ||  // legacy: allow leading comma
+        some("," >> outputItem)) || // legacy: allow leading comma
     optionalList(outputItem)};
 
 TYPE_CONTEXT_PARSER("WRITE statement"_en_US,
@@ -285,7 +285,7 @@ TYPE_PARSER(first(construct<WaitSpec>(maybe("UNIT ="_tok) >> fileUnitNumber),
     construct<WaitSpec>("IOMSG =" >> msgVariable),
     construct<WaitSpec>("IOSTAT =" >> statVariable)))
 
-template<typename A> common::IfNoLvalue<std::list<A>, A> singletonList(A &&x) {
+template <typename A> common::IfNoLvalue<std::list<A>, A> singletonList(A &&x) {
   std::list<A> result;
   result.push_front(std::move(x));
   return result;
@@ -661,4 +661,4 @@ TYPE_PARSER(construct<format::ControlEditDesc>(
                    pure(format::ControlEditDesc::Kind::Dollar)) ||
         "\\" >> construct<format::ControlEditDesc>(
                     pure(format::ControlEditDesc::Kind::Backslash))))
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/message.cpp b/flang/lib/Parser/message.cpp
index 1af00ad401b9..87594d64a8c1 100644
--- a/flang/lib/Parser/message.cpp
+++ b/flang/lib/Parser/message.cpp
@@ -112,14 +112,13 @@ std::string MessageExpectedText::ToString() const {
 }
 
 bool MessageExpectedText::Merge(const MessageExpectedText &that) {
-  return std::visit(
-      common::visitors{
-          [](SetOfChars &s1, const SetOfChars &s2) {
-            s1 = s1.Union(s2);
-            return true;
-          },
-          [](const auto &, const auto &) { return false; },
-      },
+  return std::visit(common::visitors{
+                        [](SetOfChars &s1, const SetOfChars &s2) {
+                          s1 = s1.Union(s2);
+                          return true;
+                        },
+                        [](const auto &, const auto &) { return false; },
+                    },
       u_, that.u_);
 }
 
@@ -335,4 +334,4 @@ bool Messages::AnyFatalError() const {
   }
   return false;
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/misc-parsers.h b/flang/lib/Parser/misc-parsers.h
index ca98e691ad82..b9d6ca541802 100644
--- a/flang/lib/Parser/misc-parsers.h
+++ b/flang/lib/Parser/misc-parsers.h
@@ -21,17 +21,17 @@
 namespace Fortran::parser {
 
 // R401 xzy-list -> xzy [, xzy]...
-template<typename PA> inline constexpr auto nonemptyList(const PA &p) {
-  return nonemptySeparated(p, ","_tok);  // p-list
+template <typename PA> inline constexpr auto nonemptyList(const PA &p) {
+  return nonemptySeparated(p, ","_tok); // p-list
 }
 
-template<typename PA>
+template <typename PA>
 inline constexpr auto nonemptyList(MessageFixedText error, const PA &p) {
-  return withMessage(error, nonemptySeparated(p, ","_tok));  // p-list
+  return withMessage(error, nonemptySeparated(p, ","_tok)); // p-list
 }
 
-template<typename PA> inline constexpr auto optionalList(const PA &p) {
-  return defaulted(nonemptySeparated(p, ","_tok));  // [p-list]
+template <typename PA> inline constexpr auto optionalList(const PA &p) {
+  return defaulted(nonemptySeparated(p, ","_tok)); // [p-list]
 }
 
 // R402 xzy-name -> name
@@ -52,5 +52,5 @@ constexpr auto pointer{construct<Pointer>("POINTER"_tok)};
 constexpr auto protectedAttr{construct<Protected>("PROTECTED"_tok)};
 constexpr auto save{construct<Save>("SAVE"_tok)};
 
-}
+} // namespace Fortran::parser
 #endif
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
index 407b5125e2b5..2d81f5a8197b 100644
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -23,7 +23,7 @@ namespace Fortran::parser {
 constexpr auto startOmpLine = skipStuffBeforeStatement >> "!$OMP "_sptok;
 constexpr auto endOmpLine = space >> endOfLine;
 
-template<typename A> constexpr decltype(auto) verbatim(A x) {
+template <typename A> constexpr decltype(auto) verbatim(A x) {
   return sourced(construct<Verbatim>(x));
 }
 
@@ -524,4 +524,4 @@ TYPE_PARSER(
 
 TYPE_PARSER(construct<OpenMPLoopConstruct>(
     Parser<OmpBeginLoopDirective>{} / endOmpLine))
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/parse-tree.cpp b/flang/lib/Parser/parse-tree.cpp
index 819e4abfc831..650635ec97bc 100644
--- a/flang/lib/Parser/parse-tree.cpp
+++ b/flang/lib/Parser/parse-tree.cpp
@@ -22,13 +22,13 @@ struct GenericExprWrapper {
 struct GenericAssignmentWrapper {
   ~GenericAssignmentWrapper();
 };
-}
+} // namespace Fortran::evaluate
 
 namespace Fortran::parser {
 
 // R867
 ImportStmt::ImportStmt(common::ImportKind &&k, std::list<Name> &&n)
-  : kind{k}, names(std::move(n)) {
+    : kind{k}, names(std::move(n)) {
   CHECK(kind == common::ImportKind::Default ||
       kind == common::ImportKind::Only || names.empty());
 }
@@ -75,9 +75,9 @@ DataRef::DataRef(std::list<PartRef> &&prl) : u{std::move(prl.front().name)} {
 
 // R1001 - R1022 expression
 Expr::Expr(Designator &&x)
-  : u{common::Indirection<Designator>::Make(std::move(x))} {}
+    : u{common::Indirection<Designator>::Make(std::move(x))} {}
 Expr::Expr(FunctionReference &&x)
-  : u{common::Indirection<FunctionReference>::Make(std::move(x))} {}
+    : u{common::Indirection<FunctionReference>::Make(std::move(x))} {}
 
 const std::optional<LoopControl> &DoConstruct::GetLoopControl() const {
   const NonLabelDoStmt &doStmt{
@@ -124,7 +124,7 @@ static Designator MakeArrayElementRef(
 }
 
 // Set source in any type of node that has it.
-template<typename T> T WithSource(CharBlock source, T &&x) {
+template <typename T> T WithSource(CharBlock source, T &&x) {
   x.source = source;
   return std::move(x);
 }
@@ -257,7 +257,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Name &x) {
   return os << x.ToString();
 }
 
-}
+} // namespace Fortran::parser
 
 template class std::unique_ptr<Fortran::evaluate::GenericExprWrapper>;
 template class std::unique_ptr<Fortran::evaluate::GenericAssignmentWrapper>;
diff --git a/flang/lib/Parser/parsing.cpp b/flang/lib/Parser/parsing.cpp
index 1b8256a00a81..5e12b5545f0a 100644
--- a/flang/lib/Parser/parsing.cpp
+++ b/flang/lib/Parser/parsing.cpp
@@ -69,7 +69,7 @@ const SourceFile *Parsing::Prescan(const std::string &path, Options options) {
       .AddCompilerDirectiveSentinel("dir$");
   if (options.features.IsEnabled(LanguageFeature::OpenMP)) {
     prescanner.AddCompilerDirectiveSentinel("$omp");
-    prescanner.AddCompilerDirectiveSentinel("$");  // OMP conditional line
+    prescanner.AddCompilerDirectiveSentinel("$"); // OMP conditional line
   }
   ProvenanceRange range{allSources.AddIncludedFile(
       *sourceFile, ProvenanceRange{}, options.isModuleFile)};
@@ -140,4 +140,4 @@ bool Parsing::ForTesting(std::string path, llvm::raw_ostream &err) {
   }
   return true;
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/preprocessor.cpp b/flang/lib/Parser/preprocessor.cpp
index d2fd07268ee5..3b09597ddeb7 100644
--- a/flang/lib/Parser/preprocessor.cpp
+++ b/flang/lib/Parser/preprocessor.cpp
@@ -26,19 +26,19 @@ namespace Fortran::parser {
 
 Definition::Definition(
     const TokenSequence &repl, std::size_t firstToken, std::size_t tokens)
-  : replacement_{Tokenize({}, repl, firstToken, tokens)} {}
+    : replacement_{Tokenize({}, repl, firstToken, tokens)} {}
 
 Definition::Definition(const std::vector<std::string> &argNames,
     const TokenSequence &repl, std::size_t firstToken, std::size_t tokens,
     bool isVariadic)
-  : isFunctionLike_{true},
-    argumentCount_(argNames.size()), isVariadic_{isVariadic},
-    replacement_{Tokenize(argNames, repl, firstToken, tokens)} {}
+    : isFunctionLike_{true},
+      argumentCount_(argNames.size()), isVariadic_{isVariadic},
+      replacement_{Tokenize(argNames, repl, firstToken, tokens)} {}
 
 Definition::Definition(const std::string &predefined, AllSources &sources)
-  : isPredefined_{true}, replacement_{predefined,
-                             sources.AddCompilerInsertion(predefined).start()} {
-}
+    : isPredefined_{true},
+      replacement_{
+          predefined, sources.AddCompilerInsertion(predefined).start()} {}
 
 bool Definition::set_isDisabled(bool disable) {
   bool was{isDisabled_};
@@ -200,9 +200,9 @@ Preprocessor::Preprocessor(AllSources &allSources) : allSources_{allSources} {
   // of __DATE__ or __TIME__ change during compilation.
   std::time_t now;
   std::time(&now);
-  definitions_.emplace(SaveTokenAsName("__DATE__"s),  // e.g., "Jun 16 1904"
+  definitions_.emplace(SaveTokenAsName("__DATE__"s), // e.g., "Jun 16 1904"
       Definition{FormatTime(now, "\"%h %e %Y\""), allSources});
-  definitions_.emplace(SaveTokenAsName("__TIME__"s),  // e.g., "23:59:60"
+  definitions_.emplace(SaveTokenAsName("__TIME__"s), // e.g., "23:59:60"
       Definition{FormatTime(now, "\"%T\""), allSources});
   // The values of these predefined macros depend on their invocation sites.
   definitions_.emplace(
@@ -230,7 +230,7 @@ std::optional<TokenSequence> Preprocessor::MacroReplacement(
     }
   }
   if (j == tokens) {
-    return std::nullopt;  // input contains nothing that would be replaced
+    return std::nullopt; // input contains nothing that would be replaced
   }
   TokenSequence result{input, 0, j};
   for (; j < tokens; ++j) {
@@ -342,7 +342,7 @@ std::optional<TokenSequence> Preprocessor::MacroReplacement(
           allSources_.AddMacroCall(from, use, replaced.ToString())};
       result.Put(replaced, newRange);
     }
-    j = k;  // advance to the terminal ')'
+    j = k; // advance to the terminal ')'
   }
   return result;
 }
@@ -373,7 +373,7 @@ void Preprocessor::Directive(const TokenSequence &dir, Prescanner *prescanner) {
     return;
   }
   if (IsDecimalDigit(dir.TokenAt(j)[0]) || dir.TokenAt(j)[0] == '"') {
-    return;  // treat like #line, ignore it
+    return; // treat like #line, ignore it
   }
   std::size_t dirOffset{j};
   std::string dirName{ToLowerCaseLetters(dir.TokenAt(dirOffset).ToString())};
@@ -677,8 +677,8 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
   enum Operator {
     PARENS,
     CONST,
-    NOTZERO,  // !
-    COMPLEMENT,  // ~
+    NOTZERO, // !
+    COMPLEMENT, // ~
     UPLUS,
     UMINUS,
     POWER,
@@ -707,13 +707,13 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
     COMMA
   };
   static const int precedence[]{
-      15, 15, 15, 15,  // (), 6, !, ~
-      14, 14,  // unary +, -
-      13, 12, 12, 12, 11, 11, 10, 10,  // **, *, /, %, +, -, <<, >>
-      9, 8, 7,  // &, ^, |
-      6, 6, 6, 6, 6, 6,  // relations .LT. to .GT.
-      5, 4, 3, 2, 2,  // .NOT., .AND., .OR., .EQV., .NEQV.
-      1, 0  // ?: and ,
+      15, 15, 15, 15, // (), 6, !, ~
+      14, 14, // unary +, -
+      13, 12, 12, 12, 11, 11, 10, 10, // **, *, /, %, +, -, <<, >>
+      9, 8, 7, // &, ^, |
+      6, 6, 6, 6, 6, 6, // relations .LT. to .GT.
+      5, 4, 3, 2, 2, // .NOT., .AND., .OR., .EQV., .NEQV.
+      1, 0 // ?: and ,
   };
   static const int operandPrecedence[]{0, -1, 15, 15, 15, 15, 13, 12, 12, 12,
       11, 11, 11, 11, 9, 8, 7, 7, 7, 7, 7, 7, 7, 6, 4, 3, 3, 3, 1, 0};
@@ -821,12 +821,22 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
             token.GetTokenProvenanceRange(*atToken), "expected ')'"_err_en_US};
       }
       return 0;
-    case NOTZERO: left = !left; break;
-    case COMPLEMENT: left = ~left; break;
-    case UPLUS: break;
-    case UMINUS: left = -left; break;
-    case NOT: left = -!left; break;
-    default: CRASH_NO_CASE;
+    case NOTZERO:
+      left = !left;
+      break;
+    case COMPLEMENT:
+      left = ~left;
+      break;
+    case UPLUS:
+      break;
+    case UMINUS:
+      left = -left;
+      break;
+    case NOT:
+      left = -!left;
+      break;
+    default:
+      CRASH_NO_CASE;
     }
   }
 
@@ -934,18 +944,40 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
       left = right >= 64 ? 0 : left >> right;
       break;
     case BITAND:
-    case AND: left = left & right; break;
-    case BITXOR: left = left ^ right; break;
+    case AND:
+      left = left & right;
+      break;
+    case BITXOR:
+      left = left ^ right;
+      break;
     case BITOR:
-    case OR: left = left | right; break;
-    case LT: left = -(left < right); break;
-    case LE: left = -(left <= right); break;
-    case EQ: left = -(left == right); break;
-    case NE: left = -(left != right); break;
-    case GE: left = -(left >= right); break;
-    case GT: left = -(left > right); break;
-    case EQV: left = -(!left == !right); break;
-    case NEQV: left = -(!left != !right); break;
+    case OR:
+      left = left | right;
+      break;
+    case LT:
+      left = -(left < right);
+      break;
+    case LE:
+      left = -(left <= right);
+      break;
+    case EQ:
+      left = -(left == right);
+      break;
+    case NE:
+      left = -(left != right);
+      break;
+    case GE:
+      left = -(left >= right);
+      break;
+    case GT:
+      left = -(left > right);
+      break;
+    case EQV:
+      left = -(!left == !right);
+      break;
+    case NEQV:
+      left = -(!left != !right);
+      break;
     case SELECT:
       if (*atToken >= tokens || token.TokenAt(*atToken).ToString() != ":") {
         *error = Message{token.GetTokenProvenanceRange(opAt),
@@ -958,8 +990,11 @@ static std::int64_t ExpressionValue(const TokenSequence &token,
         left = left != 0 ? right : third;
       }
       break;
-    case COMMA: left = right; break;
-    default: CRASH_NO_CASE;
+    case COMMA:
+      left = right;
+      break;
+    default:
+      CRASH_NO_CASE;
     }
   }
   return left;
@@ -1014,4 +1049,4 @@ bool Preprocessor::IsIfPredicateTrue(const TokenSequence &expr,
   }
   return result;
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/preprocessor.h b/flang/lib/Parser/preprocessor.h
index 9b1b019b8c29..977d480c2482 100644
--- a/flang/lib/Parser/preprocessor.h
+++ b/flang/lib/Parser/preprocessor.h
@@ -91,5 +91,5 @@ private:
   std::unordered_map<CharBlock, Definition> definitions_;
   std::stack<CanDeadElseAppear> ifStack_;
 };
-}
-#endif  // FORTRAN_PARSER_PREPROCESSOR_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PREPROCESSOR_H_
diff --git a/flang/lib/Parser/prescan.cpp b/flang/lib/Parser/prescan.cpp
index 1648a0297603..90b71925b389 100644
--- a/flang/lib/Parser/prescan.cpp
+++ b/flang/lib/Parser/prescan.cpp
@@ -27,18 +27,19 @@ static constexpr int maxPrescannerNesting{100};
 
 Prescanner::Prescanner(Messages &messages, CookedSource &cooked,
     Preprocessor &preprocessor, common::LanguageFeatureControl lfc)
-  : messages_{messages}, cooked_{cooked}, preprocessor_{preprocessor},
-    features_{lfc}, encoding_{cooked.allSources().encoding()} {}
+    : messages_{messages}, cooked_{cooked}, preprocessor_{preprocessor},
+      features_{lfc}, encoding_{cooked.allSources().encoding()} {}
 
 Prescanner::Prescanner(const Prescanner &that)
-  : messages_{that.messages_}, cooked_{that.cooked_},
-    preprocessor_{that.preprocessor_}, features_{that.features_},
-    inFixedForm_{that.inFixedForm_},
-    fixedFormColumnLimit_{that.fixedFormColumnLimit_},
-    encoding_{that.encoding_}, prescannerNesting_{that.prescannerNesting_ + 1},
-    skipLeadingAmpersand_{that.skipLeadingAmpersand_},
-    compilerDirectiveBloomFilter_{that.compilerDirectiveBloomFilter_},
-    compilerDirectiveSentinels_{that.compilerDirectiveSentinels_} {}
+    : messages_{that.messages_}, cooked_{that.cooked_},
+      preprocessor_{that.preprocessor_}, features_{that.features_},
+      inFixedForm_{that.inFixedForm_},
+      fixedFormColumnLimit_{that.fixedFormColumnLimit_},
+      encoding_{that.encoding_}, prescannerNesting_{that.prescannerNesting_ +
+                                     1},
+      skipLeadingAmpersand_{that.skipLeadingAmpersand_},
+      compilerDirectiveBloomFilter_{that.compilerDirectiveBloomFilter_},
+      compilerDirectiveSentinels_{that.compilerDirectiveSentinels_} {}
 
 static inline constexpr bool IsFixedFormCommentChar(char ch) {
   return ch == '!' || ch == '*' || ch == 'C' || ch == 'c';
@@ -93,7 +94,7 @@ void Prescanner::Statement() {
   LineClassification line{ClassifyLine(nextLine_)};
   switch (line.kind) {
   case LineClassification::Kind::Comment:
-    nextLine_ += line.payloadOffset;  // advance to '!' or newline
+    nextLine_ += line.payloadOffset; // advance to '!' or newline
     NextLine();
     return;
   case LineClassification::Kind::IncludeLine:
@@ -170,9 +171,10 @@ void Prescanner::Statement() {
     preprocessed->CloseToken();
     const char *ppd{preprocessed->ToCharBlock().begin()};
     LineClassification ppl{ClassifyLine(ppd)};
-    preprocessed->RemoveLastToken();  // remove the newline
+    preprocessed->RemoveLastToken(); // remove the newline
     switch (ppl.kind) {
-    case LineClassification::Kind::Comment: break;
+    case LineClassification::Kind::Comment:
+      break;
     case LineClassification::Kind::IncludeLine:
       FortranInclude(ppd + ppl.payloadOffset);
       break;
@@ -251,7 +253,7 @@ void Prescanner::LabelField(TokenSequence &token, int outCol) {
       break;
     }
     if (*at_ != ' ' &&
-        !(*at_ == '0' && column_ == 6)) {  // '0' in column 6 becomes space
+        !(*at_ == '0' && column_ == 6)) { // '0' in column 6 becomes space
       EmitChar(token, *at_);
       ++outCol;
     }
@@ -280,9 +282,9 @@ void Prescanner::SkipToEndOfLine() {
 
 bool Prescanner::MustSkipToEndOfLine() const {
   if (inFixedForm_ && column_ > fixedFormColumnLimit_ && !tabInCurrentLine_) {
-    return true;  // skip over ignored columns in right margin (73:80)
+    return true; // skip over ignored columns in right margin (73:80)
   } else if (*at_ == '!' && !inCharLiteral_) {
-    return true;  // inline comment goes to end of source line
+    return true; // inline comment goes to end of source line
   } else {
     return false;
   }
@@ -376,7 +378,7 @@ const char *Prescanner::SkipCComment(const char *p) const {
   p += 2;
   while (star != '*' || slash != '/') {
     if (p >= limit_) {
-      return nullptr;  // signifies an unterminated comment
+      return nullptr; // signifies an unterminated comment
     }
     star = slash;
     slash = *p++;
@@ -476,7 +478,7 @@ bool Prescanner::NextToken(TokenSequence &tokens) {
       }
       ExponentAndKind(tokens);
     } else if (nch == '.' && EmitCharAndAdvance(tokens, '.') == '.') {
-      EmitCharAndAdvance(tokens, '.');  // variadic macro definition ellipsis
+      EmitCharAndAdvance(tokens, '.'); // variadic macro definition ellipsis
     }
     preventHollerith_ = false;
   } else if (IsLegalInIdentifier(*at_)) {
@@ -582,7 +584,7 @@ void Prescanner::QuotedCharacterLiteral(
       // quote character in the literal (later).  There can be spaces between
       // the quotes in fixed form source.
       EmitChar(tokens, quote);
-      inCharLiteral_ = false;  // for cases like print *, '...'!comment
+      inCharLiteral_ = false; // for cases like print *, '...'!comment
       NextChar();
       if (InFixedFormSource()) {
         SkipSpaces();
@@ -649,7 +651,7 @@ bool Prescanner::PadOutCharacterLiteral(TokenSequence &tokens) {
       return false;
     }
     CHECK(column_ == 7);
-    --at_;  // point to column 6 of continuation line
+    --at_; // point to column 6 of continuation line
     column_ = 6;
   }
   return false;
@@ -657,7 +659,7 @@ bool Prescanner::PadOutCharacterLiteral(TokenSequence &tokens) {
 
 bool Prescanner::IsFixedFormCommentLine(const char *start) const {
   const char *p{start};
-  if (IsFixedFormCommentChar(*p) || *p == '%' ||  // VAX %list, %eject, &c.
+  if (IsFixedFormCommentChar(*p) || *p == '%' || // VAX %list, %eject, &c.
       ((*p == 'D' || *p == 'd') &&
           !features_.IsEnabled(LanguageFeature::OldDebugLines))) {
     return true;
@@ -670,7 +672,7 @@ bool Prescanner::IsFixedFormCommentLine(const char *start) const {
       anyTabs = true;
       ++p;
     } else if (*p == '0' && !anyTabs && p == start + 5) {
-      ++p;  // 0 in column 6 must treated as a space
+      ++p; // 0 in column 6 must treated as a space
     } else {
       break;
     }
@@ -867,7 +869,7 @@ const char *Prescanner::FixedFormContinuationLine(bool mightNeedSpace) {
     }
     if (col1 == '\t' && nextLine_[1] >= '1' && nextLine_[1] <= '9') {
       tabInCurrentLine_ = true;
-      return nextLine_ + 2;  // VAX extension
+      return nextLine_ + 2; // VAX extension
     }
     if (col1 == ' ' && nextLine_[1] == ' ' && nextLine_[2] == ' ' &&
         nextLine_[3] == ' ' && nextLine_[4] == ' ') {
@@ -882,7 +884,7 @@ const char *Prescanner::FixedFormContinuationLine(bool mightNeedSpace) {
       }
     }
   }
-  return nullptr;  // not a continuation line
+  return nullptr; // not a continuation line
 }
 
 const char *Prescanner::FreeFormContinuationLine(bool ampersand) {
@@ -1127,4 +1129,4 @@ void Prescanner::SourceFormChange(std::string &&dir) {
     inFixedForm_ = true;
   }
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/prescan.h b/flang/lib/Parser/prescan.h
index 94098048f23e..f2840c3bf771 100644
--- a/flang/lib/Parser/prescan.h
+++ b/flang/lib/Parser/prescan.h
@@ -64,7 +64,7 @@ public:
   TokenSequence TokenizePreprocessorDirective();
   Provenance GetCurrentProvenance() const { return GetProvenance(at_); }
 
-  template<typename... A> Message &Say(A &&... a) {
+  template <typename... A> Message &Say(A &&... a) {
     Message &m{messages_.Say(std::forward<A>(a)...)};
     std::optional<ProvenanceRange> range{m.GetProvenanceRange(cooked_)};
     CHECK(!range || cooked_.IsValid(*range));
@@ -76,19 +76,19 @@ private:
     enum class Kind {
       Comment,
       ConditionalCompilationDirective,
-      IncludeDirective,  // #include
-      DefinitionDirective,  // #define & #undef
+      IncludeDirective, // #include
+      DefinitionDirective, // #define & #undef
       PreprocessorDirective,
-      IncludeLine,  // Fortran INCLUDE
+      IncludeLine, // Fortran INCLUDE
       CompilerDirective,
       Source
     };
     LineClassification(Kind k, std::size_t po = 0, const char *s = nullptr)
-      : kind{k}, payloadOffset{po}, sentinel{s} {}
+        : kind{k}, payloadOffset{po}, sentinel{s} {}
     LineClassification(LineClassification &&) = default;
     Kind kind;
-    std::size_t payloadOffset;  // byte offset of content
-    const char *sentinel;  // if it's a compiler directive
+    std::size_t payloadOffset; // byte offset of content
+    const char *sentinel; // if it's a compiler directive
   };
 
   void BeginSourceLine(const char *at) {
@@ -187,15 +187,15 @@ private:
   int prescannerNesting_{0};
 
   Provenance startProvenance_;
-  const char *start_{nullptr};  // beginning of current source file content
-  const char *limit_{nullptr};  // first address after end of current source
-  const char *nextLine_{nullptr};  // next line to process; <= limit_
-  const char *directiveSentinel_{nullptr};  // current compiler directive
+  const char *start_{nullptr}; // beginning of current source file content
+  const char *limit_{nullptr}; // first address after end of current source
+  const char *nextLine_{nullptr}; // next line to process; <= limit_
+  const char *directiveSentinel_{nullptr}; // current compiler directive
 
   // This data members are state for processing the source line containing
   // "at_", which goes to up to the newline character before "nextLine_".
-  const char *at_{nullptr};  // next character to process; < nextLine_
-  int column_{1};  // card image column position of next character
+  const char *at_{nullptr}; // next character to process; < nextLine_
+  int column_{1}; // card image column position of next character
   bool tabInCurrentLine_{false};
   bool slashInCurrentLine_{false};
   bool preventHollerith_{false};
@@ -225,8 +225,8 @@ private:
   // To avoid probing the set of active compiler directive sentinel strings
   // on every comment line, they're checked first with a cheap Bloom filter.
   static const int prime1{1019}, prime2{1021};
-  std::bitset<prime2> compilerDirectiveBloomFilter_;  // 128 bytes
+  std::bitset<prime2> compilerDirectiveBloomFilter_; // 128 bytes
   std::unordered_set<std::string> compilerDirectiveSentinels_;
 };
-}
-#endif  // FORTRAN_PARSER_PRESCAN_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_PRESCAN_H_
diff --git a/flang/lib/Parser/program-parsers.cpp b/flang/lib/Parser/program-parsers.cpp
index 36a9d39d4512..e394e25631d3 100644
--- a/flang/lib/Parser/program-parsers.cpp
+++ b/flang/lib/Parser/program-parsers.cpp
@@ -263,7 +263,7 @@ TYPE_PARSER(construct<Rename>("OPERATOR (" >>
 // R1413 only-use-name -> use-name
 TYPE_PARSER(construct<Only>(Parser<Rename>{}) ||
     construct<Only>(indirect(genericSpec)) ||
-    construct<Only>(name))  // TODO: ambiguous, accepted by genericSpec
+    construct<Only>(name)) // TODO: ambiguous, accepted by genericSpec
 
 // R1416 submodule ->
 //         submodule-stmt [specification-part] [module-subprogram-part]
@@ -477,7 +477,7 @@ TYPE_CONTEXT_PARSER("FUNCTION statement"_en_US,
     construct<FunctionStmt>(many(prefixSpec), "FUNCTION" >> name,
         parenthesized(optionalList(name)), maybe(suffix)) ||
         extension<LanguageFeature::OmitFunctionDummies>(
-            construct<FunctionStmt>(  // PGI & Intel accept "FUNCTION F"
+            construct<FunctionStmt>( // PGI & Intel accept "FUNCTION F"
                 many(prefixSpec), "FUNCTION" >> name,
                 construct<std::list<Name>>(),
                 construct<std::optional<Suffix>>())))
@@ -556,4 +556,4 @@ TYPE_PARSER(construct<ContainsStmt>("CONTAINS"_tok))
 TYPE_CONTEXT_PARSER("statement function definition"_en_US,
     construct<StmtFunctionStmt>(
         name, parenthesized(optionalList(name)), "=" >> scalar(expr)))
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/provenance.cpp b/flang/lib/Parser/provenance.cpp
index 1a2a77cd1daf..73e0f7154b6b 100644
--- a/flang/lib/Parser/provenance.cpp
+++ b/flang/lib/Parser/provenance.cpp
@@ -281,24 +281,23 @@ void AllSources::EmitMessage(llvm::raw_ostream &o,
 const SourceFile *AllSources::GetSourceFile(
     Provenance at, std::size_t *offset) const {
   const Origin &origin{MapToOrigin(at)};
-  return std::visit(
-      common::visitors{
-          [&](const Inclusion &inc) {
-            if (offset) {
-              *offset = origin.covers.MemberOffset(at);
-            }
-            return &inc.source;
-          },
-          [&](const Macro &) {
-            return GetSourceFile(origin.replaces.start(), offset);
-          },
-          [offset](const CompilerInsertion &) {
-            if (offset) {
-              *offset = 0;
-            }
-            return static_cast<const SourceFile *>(nullptr);
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](const Inclusion &inc) {
+                          if (offset) {
+                            *offset = origin.covers.MemberOffset(at);
+                          }
+                          return &inc.source;
+                        },
+                        [&](const Macro &) {
+                          return GetSourceFile(origin.replaces.start(), offset);
+                        },
+                        [offset](const CompilerInsertion &) {
+                          if (offset) {
+                            *offset = 0;
+                          }
+                          return static_cast<const SourceFile *>(nullptr);
+                        },
+                    },
       origin.u);
 }
 
@@ -361,15 +360,15 @@ ProvenanceRange AllSources::IntersectionWithSourceFiles(
 }
 
 AllSources::Origin::Origin(ProvenanceRange r, const SourceFile &source)
-  : u{Inclusion{source}}, covers{r} {}
+    : u{Inclusion{source}}, covers{r} {}
 AllSources::Origin::Origin(ProvenanceRange r, const SourceFile &included,
     ProvenanceRange from, bool isModule)
-  : u{Inclusion{included, isModule}}, covers{r}, replaces{from} {}
+    : u{Inclusion{included, isModule}}, covers{r}, replaces{from} {}
 AllSources::Origin::Origin(ProvenanceRange r, ProvenanceRange def,
     ProvenanceRange use, const std::string &expansion)
-  : u{Macro{def, expansion}}, covers{r}, replaces{use} {}
+    : u{Macro{def, expansion}}, covers{r}, replaces{use} {}
 AllSources::Origin::Origin(ProvenanceRange r, const std::string &text)
-  : u{CompilerInsertion{text}}, covers{r} {}
+    : u{CompilerInsertion{text}}, covers{r} {}
 
 const char &AllSources::Origin::operator[](std::size_t n) const {
   return std::visit(
@@ -507,24 +506,23 @@ llvm::raw_ostream &AllSources::Dump(llvm::raw_ostream &o) const {
     o << "   ";
     DumpRange(o, m.covers);
     o << " -> ";
-    std::visit(
-        common::visitors{
-            [&](const Inclusion &inc) {
-              if (inc.isModule) {
-                o << "module ";
-              }
-              o << "file " << inc.source.path();
-            },
-            [&](const Macro &mac) { o << "macro " << mac.expansion; },
-            [&](const CompilerInsertion &ins) {
-              o << "compiler '" << ins.text << '\'';
-              if (ins.text.length() == 1) {
-                int ch = ins.text[0];
-                o << "(0x";
-                o.write_hex(ch & 0xff) << ")";
-              }
-            },
-        },
+    std::visit(common::visitors{
+                   [&](const Inclusion &inc) {
+                     if (inc.isModule) {
+                       o << "module ";
+                     }
+                     o << "file " << inc.source.path();
+                   },
+                   [&](const Macro &mac) { o << "macro " << mac.expansion; },
+                   [&](const CompilerInsertion &ins) {
+                     o << "compiler '" << ins.text << '\'';
+                     if (ins.text.length() == 1) {
+                       int ch = ins.text[0];
+                       o << "(0x";
+                       o.write_hex(ch & 0xff) << ")";
+                     }
+                   },
+               },
         m.u);
     if (IsValid(m.replaces)) {
       o << " replaces ";
@@ -544,4 +542,4 @@ llvm::raw_ostream &CookedSource::Dump(llvm::raw_ostream &o) const {
   invertedMap_.Dump(o);
   return o;
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/source.cpp b/flang/lib/Parser/source.cpp
index 6b1a9df3b731..376786e3923e 100644
--- a/flang/lib/Parser/source.cpp
+++ b/flang/lib/Parser/source.cpp
@@ -150,4 +150,4 @@ SourcePosition SourceFile::FindOffsetLineAndColumn(std::size_t at) const {
   return {*this, static_cast<int>(low + 1),
       static_cast<int>(at - lineStart_[low] + 1)};
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/stmt-parser.h b/flang/lib/Parser/stmt-parser.h
index ee26e50db119..058a3b6cc215 100644
--- a/flang/lib/Parser/stmt-parser.h
+++ b/flang/lib/Parser/stmt-parser.h
@@ -23,7 +23,8 @@ namespace Fortran::parser {
 // R611 label -> digit [digit]...
 constexpr auto label{space >> digitString64 / spaceCheck};
 
-template<typename PA> inline constexpr auto unterminatedStatement(const PA &p) {
+template <typename PA>
+inline constexpr auto unterminatedStatement(const PA &p) {
   return skipStuffBeforeStatement >>
       sourced(construct<Statement<typename PA::resultType>>(
           maybe(label), space >> p));
@@ -38,13 +39,13 @@ constexpr auto endOfStmt{
                  semicolons || endOfLine)};
 constexpr auto forceEndOfStmt{recovery(endOfStmt, SkipPast<'\n'>{})};
 
-template<typename PA> inline constexpr auto statement(const PA &p) {
+template <typename PA> inline constexpr auto statement(const PA &p) {
   return unterminatedStatement(p) / endOfStmt;
 }
 
 // unlabeledStatement() is basically statement() for those few situations
 // in Fortran where a statement cannot have a label.
-template<typename PA> inline constexpr auto unlabeledStatement(const PA &p) {
+template <typename PA> inline constexpr auto unlabeledStatement(const PA &p) {
   return space >>
       sourced(construct<UnlabeledStatement<typename PA::resultType>>(p));
 }
@@ -55,7 +56,7 @@ template<typename PA> inline constexpr auto unlabeledStatement(const PA &p) {
 // question could also be a legal prefix of some other statement that might
 // be valid at that point.  It only makes sense to use this within "some()"
 // or "many()" so as to not end the list of statements.
-template<typename PA> inline constexpr auto unambiguousStatement(const PA &p) {
+template <typename PA> inline constexpr auto unambiguousStatement(const PA &p) {
   return unterminatedStatement(p) / forceEndOfStmt;
 }
 
@@ -95,5 +96,5 @@ constexpr auto progUnitEndStmtErrorRecovery{
     (many(!"END"_tok >> SkipPast<'\n'>{}) >>
         ("END"_tok >> SkipTo<'\n'>{} || consumedAllInput)) >>
     missingOptionalName};
-}
-#endif  // FORTRAN_PARSER_STMT_PARSER_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_STMT_PARSER_H_
diff --git a/flang/lib/Parser/token-parsers.h b/flang/lib/Parser/token-parsers.h
index c34b9785b3fd..fdb0a3a09899 100644
--- a/flang/lib/Parser/token-parsers.h
+++ b/flang/lib/Parser/token-parsers.h
@@ -114,24 +114,24 @@ constexpr struct SpaceCheck {
 // when a string literal appears before the sequencing operator >> or
 // after the sequencing operator /.  The literal "..."_id parses a
 // token that cannot be a prefix of a longer identifier.
-template<bool MandatoryFreeFormSpace = false, bool MustBeComplete = false>
+template <bool MandatoryFreeFormSpace = false, bool MustBeComplete = false>
 class TokenStringMatch {
 public:
   using resultType = Success;
   constexpr TokenStringMatch(const TokenStringMatch &) = default;
   constexpr TokenStringMatch(const char *str, std::size_t n)
-    : str_{str}, bytes_{n} {}
+      : str_{str}, bytes_{n} {}
   explicit constexpr TokenStringMatch(const char *str) : str_{str} {}
   std::optional<Success> Parse(ParseState &state) const {
     space.Parse(state);
     const char *start{state.GetLocation()};
     const char *p{str_};
-    std::optional<const char *> at;  // initially empty
+    std::optional<const char *> at; // initially empty
     for (std::size_t j{0}; j < bytes_ && *p != '\0'; ++j, ++p) {
       bool spaceSkipping{*p == ' '};
       if (spaceSkipping) {
         if (j + 1 == bytes_ || p[1] == ' ' || p[1] == '\0') {
-          continue;  // redundant; ignore
+          continue; // redundant; ignore
         }
       }
       if (!at) {
@@ -192,25 +192,25 @@ constexpr TokenStringMatch<false, true> operator""_id(
   return {str, n};
 }
 
-template<class PA>
+template <class PA>
 inline constexpr std::enable_if_t<std::is_class_v<PA>,
     SequenceParser<TokenStringMatch<>, PA>>
 operator>>(const char *str, const PA &p) {
   return SequenceParser<TokenStringMatch<>, PA>{TokenStringMatch<>{str}, p};
 }
 
-template<class PA>
+template <class PA>
 inline constexpr std::enable_if_t<std::is_class_v<PA>,
     FollowParser<PA, TokenStringMatch<>>>
 operator/(const PA &p, const char *str) {
   return FollowParser<PA, TokenStringMatch<>>{p, TokenStringMatch<>{str}};
 }
 
-template<class PA> inline constexpr auto parenthesized(const PA &p) {
+template <class PA> inline constexpr auto parenthesized(const PA &p) {
   return "(" >> p / ")";
 }
 
-template<class PA> inline constexpr auto bracketed(const PA &p) {
+template <class PA> inline constexpr auto bracketed(const PA &p) {
   return "[" >> p / "]";
 }
 
@@ -243,7 +243,7 @@ struct CharLiteralChar {
   }
 };
 
-template<char quote> struct CharLiteral {
+template <char quote> struct CharLiteral {
   using resultType = std::string;
   static std::optional<std::string> Parse(ParseState &state) {
     std::string str;
@@ -274,9 +274,14 @@ struct BOZLiteral {
       switch (ch) {
       case 'b':
       case 'o':
-      case 'z': base = ch; return true;
-      case 'x': base = 'z'; return true;
-      default: return false;
+      case 'z':
+        base = ch;
+        return true;
+      case 'x':
+        base = 'z';
+        return true;
+      default:
+        return false;
       }
     }};
 
@@ -543,7 +548,7 @@ constexpr struct ConsumedAllInputParser {
   }
 } consumedAllInput;
 
-template<char goal> struct SkipPast {
+template <char goal> struct SkipPast {
   using resultType = Success;
   constexpr SkipPast() {}
   constexpr SkipPast(const SkipPast &) {}
@@ -557,7 +562,7 @@ template<char goal> struct SkipPast {
   }
 };
 
-template<char goal> struct SkipTo {
+template <char goal> struct SkipTo {
   using resultType = Success;
   constexpr SkipTo() {}
   constexpr SkipTo(const SkipTo &) {}
@@ -578,11 +583,11 @@ template<char goal> struct SkipTo {
 // not appear, and the doubled colons are optional.
 //   [[, xyz] ::]     is  optionalBeforeColons(xyz)
 //   [[, xyz]... ::]  is  optionalBeforeColons(nonemptyList(xyz))
-template<typename PA> inline constexpr auto optionalBeforeColons(const PA &p) {
+template <typename PA> inline constexpr auto optionalBeforeColons(const PA &p) {
   return "," >> construct<std::optional<typename PA::resultType>>(p) / "::" ||
       ("::"_tok || !","_tok) >> defaulted(cut >> maybe(p));
 }
-template<typename PA>
+template <typename PA>
 inline constexpr auto optionalListBeforeColons(const PA &p) {
   return "," >> nonemptyList(p) / "::" ||
       ("::"_tok || !","_tok) >> defaulted(cut >> nonemptyList(p));
@@ -657,5 +662,5 @@ constexpr auto logicalFALSE{
 constexpr auto rawHollerithLiteral{
     deprecated<LanguageFeature::Hollerith>(HollerithLiteral{})};
 
-}
-#endif  // FORTRAN_PARSER_TOKEN_PARSERS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_TOKEN_PARSERS_H_
diff --git a/flang/lib/Parser/token-sequence.cpp b/flang/lib/Parser/token-sequence.cpp
index 235a4a4d303f..ce94f2623501 100644
--- a/flang/lib/Parser/token-sequence.cpp
+++ b/flang/lib/Parser/token-sequence.cpp
@@ -53,7 +53,7 @@ std::size_t TokenSequence::SkipBlanks(std::size_t at) const {
       return at;
     }
   }
-  return tokens;  // even if at > tokens
+  return tokens; // even if at > tokens
 }
 
 void TokenSequence::RemoveLastToken() {
@@ -285,4 +285,4 @@ ProvenanceRange TokenSequence::GetIntervalProvenanceRange(
 ProvenanceRange TokenSequence::GetProvenanceRange() const {
   return GetIntervalProvenanceRange(0, start_.size());
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/token-sequence.h b/flang/lib/Parser/token-sequence.h
index b70134bd4b20..d73b3c20be6f 100644
--- a/flang/lib/Parser/token-sequence.h
+++ b/flang/lib/Parser/token-sequence.h
@@ -38,9 +38,9 @@ public:
     Put(that, at, count);
   }
   TokenSequence(TokenSequence &&that)
-    : start_{std::move(that.start_)}, nextStart_{that.nextStart_},
-      char_{std::move(that.char_)}, provenances_{std::move(that.provenances_)} {
-  }
+      : start_{std::move(that.start_)}, nextStart_{that.nextStart_},
+        char_{std::move(that.char_)}, provenances_{
+                                          std::move(that.provenances_)} {}
   TokenSequence(const std::string &s, Provenance p) { Put(s, p); }
 
   TokenSequence &operator=(const TokenSequence &that) {
@@ -125,5 +125,5 @@ private:
   std::vector<char> char_;
   OffsetToProvenanceMappings provenances_;
 };
-}
-#endif  // FORTRAN_PARSER_TOKEN_SEQUENCE_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_TOKEN_SEQUENCE_H_
diff --git a/flang/lib/Parser/tools.cpp b/flang/lib/Parser/tools.cpp
index 7fb73791b32a..98aa6897c6cd 100644
--- a/flang/lib/Parser/tools.cpp
+++ b/flang/lib/Parser/tools.cpp
@@ -91,4 +91,4 @@ const CoindexedNamedObject *GetCoindexedNamedObject(
       },
       allocateObject.u);
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/type-parser-implementation.h b/flang/lib/Parser/type-parser-implementation.h
index 1bea618f81b0..266b78dc2f1e 100644
--- a/flang/lib/Parser/type-parser-implementation.h
+++ b/flang/lib/Parser/type-parser-implementation.h
@@ -21,7 +21,7 @@
 // causes it to crash on "decltype(pexpr)" when pexpr's top-level
 // operator is an overridden || of parsing alternatives.
 #define TYPE_PARSER(pexpr) \
-  template<> \
+  template <> \
   auto Parser<typename decltype(attempt(pexpr))::resultType>::Parse( \
       ParseState &state) \
       ->std::optional<resultType> { \
diff --git a/flang/lib/Parser/type-parsers.h b/flang/lib/Parser/type-parsers.h
index 40e36a8c5a0c..c7a1bce781ff 100644
--- a/flang/lib/Parser/type-parsers.h
+++ b/flang/lib/Parser/type-parsers.h
@@ -20,7 +20,7 @@ namespace Fortran::parser {
 // This usage requires that their Parse() member functions be defined
 // separately, typically with a parsing expression wrapped up in an
 // TYPE_PARSER() macro call.
-template<typename A> struct Parser {
+template <typename A> struct Parser {
   using resultType = A;
   constexpr Parser() {}
   constexpr Parser(const Parser &) = default;
@@ -39,99 +39,99 @@ template<typename A> struct Parser {
 // of some special importance, so we instantiate them once here and
 // give them names rather than referencing them as anonymous Parser<T>{}
 // objects in the right-hand sides of productions.
-constexpr Parser<Program> program;  //  R501 - the "top level" production
-constexpr Parser<SpecificationPart> specificationPart;  //  R504
-constexpr Parser<ImplicitPart> implicitPart;  //  R505
-constexpr Parser<DeclarationConstruct> declarationConstruct;  //  R507
-constexpr Parser<SpecificationConstruct> specificationConstruct;  //  R508
-constexpr Parser<ExecutionPart> executionPart;  //  R509
-constexpr Parser<ExecutionPartConstruct> executionPartConstruct;  //  R510
-constexpr Parser<InternalSubprogramPart> internalSubprogramPart;  //  R511
-constexpr Parser<ActionStmt> actionStmt;  // R515
-constexpr Parser<Name> name;  // R603
-constexpr Parser<LiteralConstant> literalConstant;  // R605
-constexpr Parser<NamedConstant> namedConstant;  // R606
-constexpr Parser<TypeParamValue> typeParamValue;  // R701
-constexpr Parser<TypeSpec> typeSpec;  // R702
-constexpr Parser<DeclarationTypeSpec> declarationTypeSpec;  // R703
-constexpr Parser<IntrinsicTypeSpec> intrinsicTypeSpec;  // R704
-constexpr Parser<IntegerTypeSpec> integerTypeSpec;  // R705
-constexpr Parser<KindSelector> kindSelector;  // R706
-constexpr Parser<SignedIntLiteralConstant> signedIntLiteralConstant;  // R707
-constexpr Parser<IntLiteralConstant> intLiteralConstant;  // R708
-constexpr Parser<KindParam> kindParam;  // R709
-constexpr Parser<RealLiteralConstant> realLiteralConstant;  // R714
-constexpr Parser<CharLength> charLength;  // R723
-constexpr Parser<CharLiteralConstant> charLiteralConstant;  // R724
-constexpr Parser<Initialization> initialization;  // R743 & R805
-constexpr Parser<DerivedTypeSpec> derivedTypeSpec;  // R754
-constexpr Parser<TypeDeclarationStmt> typeDeclarationStmt;  // R801
-constexpr Parser<NullInit> nullInit;  // R806
-constexpr Parser<AccessSpec> accessSpec;  // R807
-constexpr Parser<LanguageBindingSpec> languageBindingSpec;  // R808, R1528
-constexpr Parser<EntityDecl> entityDecl;  // R803
-constexpr Parser<CoarraySpec> coarraySpec;  // R809
-constexpr Parser<ArraySpec> arraySpec;  // R815
-constexpr Parser<ExplicitShapeSpec> explicitShapeSpec;  // R816
-constexpr Parser<DeferredShapeSpecList> deferredShapeSpecList;  // R820
-constexpr Parser<AssumedImpliedSpec> assumedImpliedSpec;  // R821
-constexpr Parser<IntentSpec> intentSpec;  // R826
-constexpr Parser<DataStmt> dataStmt;  // R837
-constexpr Parser<DataImpliedDo> dataImpliedDo;  // R840
-constexpr Parser<ParameterStmt> parameterStmt;  // R851
+constexpr Parser<Program> program; //  R501 - the "top level" production
+constexpr Parser<SpecificationPart> specificationPart; //  R504
+constexpr Parser<ImplicitPart> implicitPart; //  R505
+constexpr Parser<DeclarationConstruct> declarationConstruct; //  R507
+constexpr Parser<SpecificationConstruct> specificationConstruct; //  R508
+constexpr Parser<ExecutionPart> executionPart; //  R509
+constexpr Parser<ExecutionPartConstruct> executionPartConstruct; //  R510
+constexpr Parser<InternalSubprogramPart> internalSubprogramPart; //  R511
+constexpr Parser<ActionStmt> actionStmt; // R515
+constexpr Parser<Name> name; // R603
+constexpr Parser<LiteralConstant> literalConstant; // R605
+constexpr Parser<NamedConstant> namedConstant; // R606
+constexpr Parser<TypeParamValue> typeParamValue; // R701
+constexpr Parser<TypeSpec> typeSpec; // R702
+constexpr Parser<DeclarationTypeSpec> declarationTypeSpec; // R703
+constexpr Parser<IntrinsicTypeSpec> intrinsicTypeSpec; // R704
+constexpr Parser<IntegerTypeSpec> integerTypeSpec; // R705
+constexpr Parser<KindSelector> kindSelector; // R706
+constexpr Parser<SignedIntLiteralConstant> signedIntLiteralConstant; // R707
+constexpr Parser<IntLiteralConstant> intLiteralConstant; // R708
+constexpr Parser<KindParam> kindParam; // R709
+constexpr Parser<RealLiteralConstant> realLiteralConstant; // R714
+constexpr Parser<CharLength> charLength; // R723
+constexpr Parser<CharLiteralConstant> charLiteralConstant; // R724
+constexpr Parser<Initialization> initialization; // R743 & R805
+constexpr Parser<DerivedTypeSpec> derivedTypeSpec; // R754
+constexpr Parser<TypeDeclarationStmt> typeDeclarationStmt; // R801
+constexpr Parser<NullInit> nullInit; // R806
+constexpr Parser<AccessSpec> accessSpec; // R807
+constexpr Parser<LanguageBindingSpec> languageBindingSpec; // R808, R1528
+constexpr Parser<EntityDecl> entityDecl; // R803
+constexpr Parser<CoarraySpec> coarraySpec; // R809
+constexpr Parser<ArraySpec> arraySpec; // R815
+constexpr Parser<ExplicitShapeSpec> explicitShapeSpec; // R816
+constexpr Parser<DeferredShapeSpecList> deferredShapeSpecList; // R820
+constexpr Parser<AssumedImpliedSpec> assumedImpliedSpec; // R821
+constexpr Parser<IntentSpec> intentSpec; // R826
+constexpr Parser<DataStmt> dataStmt; // R837
+constexpr Parser<DataImpliedDo> dataImpliedDo; // R840
+constexpr Parser<ParameterStmt> parameterStmt; // R851
 constexpr Parser<OldParameterStmt> oldParameterStmt;
-constexpr Parser<Designator> designator;  // R901
-constexpr Parser<Variable> variable;  // R902
-constexpr Parser<Substring> substring;  // R908
-constexpr Parser<DataRef> dataRef;  // R911, R914, R917
-constexpr Parser<StructureComponent> structureComponent;  // R913
-constexpr Parser<StatVariable> statVariable;  // R929
-constexpr Parser<StatOrErrmsg> statOrErrmsg;  // R942 & R1165
-constexpr Parser<DefinedOpName> definedOpName;  // R1003, R1023, R1414, & R1415
-constexpr Parser<Expr> expr;  // R1022
-constexpr Parser<SpecificationExpr> specificationExpr;  // R1028
-constexpr Parser<AssignmentStmt> assignmentStmt;  // R1032
-constexpr Parser<PointerAssignmentStmt> pointerAssignmentStmt;  // R1033
-constexpr Parser<WhereStmt> whereStmt;  // R1041, R1045, R1046
-constexpr Parser<WhereConstruct> whereConstruct;  // R1042
-constexpr Parser<WhereBodyConstruct> whereBodyConstruct;  // R1044
-constexpr Parser<ForallConstruct> forallConstruct;  // R1050
-constexpr Parser<ForallAssignmentStmt> forallAssignmentStmt;  // R1053
-constexpr Parser<ForallStmt> forallStmt;  // R1055
-constexpr Parser<Selector> selector;  // R1105
-constexpr Parser<EndSelectStmt> endSelectStmt;  // R1143 & R1151 & R1155
-constexpr Parser<LoopControl> loopControl;  // R1123
-constexpr Parser<ConcurrentHeader> concurrentHeader;  // R1125
-constexpr Parser<IoUnit> ioUnit;  // R1201, R1203
-constexpr Parser<FileUnitNumber> fileUnitNumber;  // R1202
-constexpr Parser<IoControlSpec> ioControlSpec;  // R1213, R1214
-constexpr Parser<Format> format;  // R1215
-constexpr Parser<InputItem> inputItem;  // R1216
-constexpr Parser<OutputItem> outputItem;  // R1217
-constexpr Parser<InputImpliedDo> inputImpliedDo;  // R1218, R1219
-constexpr Parser<OutputImpliedDo> outputImpliedDo;  // R1218, R1219
-constexpr Parser<PositionOrFlushSpec> positionOrFlushSpec;  // R1227 & R1229
-constexpr Parser<FormatStmt> formatStmt;  // R1301
-constexpr Parser<InterfaceBlock> interfaceBlock;  // R1501
-constexpr Parser<GenericSpec> genericSpec;  // R1508
-constexpr Parser<ProcInterface> procInterface;  // R1513
-constexpr Parser<ProcDecl> procDecl;  // R1515
-constexpr Parser<FunctionReference> functionReference;  // R1520
-constexpr Parser<ActualArgSpec> actualArgSpec;  // R1523
-constexpr Parser<PrefixSpec> prefixSpec;  // R1527
-constexpr Parser<FunctionSubprogram> functionSubprogram;  // R1529
-constexpr Parser<FunctionStmt> functionStmt;  // R1530
-constexpr Parser<Suffix> suffix;  // R1532
-constexpr Parser<EndFunctionStmt> endFunctionStmt;  // R1533
-constexpr Parser<SubroutineSubprogram> subroutineSubprogram;  // R1534
-constexpr Parser<SubroutineStmt> subroutineStmt;  // R1535
-constexpr Parser<DummyArg> dummyArg;  // R1536
-constexpr Parser<EndSubroutineStmt> endSubroutineStmt;  // R1537
-constexpr Parser<EntryStmt> entryStmt;  // R1541
-constexpr Parser<ContainsStmt> containsStmt;  // R1543
+constexpr Parser<Designator> designator; // R901
+constexpr Parser<Variable> variable; // R902
+constexpr Parser<Substring> substring; // R908
+constexpr Parser<DataRef> dataRef; // R911, R914, R917
+constexpr Parser<StructureComponent> structureComponent; // R913
+constexpr Parser<StatVariable> statVariable; // R929
+constexpr Parser<StatOrErrmsg> statOrErrmsg; // R942 & R1165
+constexpr Parser<DefinedOpName> definedOpName; // R1003, R1023, R1414, & R1415
+constexpr Parser<Expr> expr; // R1022
+constexpr Parser<SpecificationExpr> specificationExpr; // R1028
+constexpr Parser<AssignmentStmt> assignmentStmt; // R1032
+constexpr Parser<PointerAssignmentStmt> pointerAssignmentStmt; // R1033
+constexpr Parser<WhereStmt> whereStmt; // R1041, R1045, R1046
+constexpr Parser<WhereConstruct> whereConstruct; // R1042
+constexpr Parser<WhereBodyConstruct> whereBodyConstruct; // R1044
+constexpr Parser<ForallConstruct> forallConstruct; // R1050
+constexpr Parser<ForallAssignmentStmt> forallAssignmentStmt; // R1053
+constexpr Parser<ForallStmt> forallStmt; // R1055
+constexpr Parser<Selector> selector; // R1105
+constexpr Parser<EndSelectStmt> endSelectStmt; // R1143 & R1151 & R1155
+constexpr Parser<LoopControl> loopControl; // R1123
+constexpr Parser<ConcurrentHeader> concurrentHeader; // R1125
+constexpr Parser<IoUnit> ioUnit; // R1201, R1203
+constexpr Parser<FileUnitNumber> fileUnitNumber; // R1202
+constexpr Parser<IoControlSpec> ioControlSpec; // R1213, R1214
+constexpr Parser<Format> format; // R1215
+constexpr Parser<InputItem> inputItem; // R1216
+constexpr Parser<OutputItem> outputItem; // R1217
+constexpr Parser<InputImpliedDo> inputImpliedDo; // R1218, R1219
+constexpr Parser<OutputImpliedDo> outputImpliedDo; // R1218, R1219
+constexpr Parser<PositionOrFlushSpec> positionOrFlushSpec; // R1227 & R1229
+constexpr Parser<FormatStmt> formatStmt; // R1301
+constexpr Parser<InterfaceBlock> interfaceBlock; // R1501
+constexpr Parser<GenericSpec> genericSpec; // R1508
+constexpr Parser<ProcInterface> procInterface; // R1513
+constexpr Parser<ProcDecl> procDecl; // R1515
+constexpr Parser<FunctionReference> functionReference; // R1520
+constexpr Parser<ActualArgSpec> actualArgSpec; // R1523
+constexpr Parser<PrefixSpec> prefixSpec; // R1527
+constexpr Parser<FunctionSubprogram> functionSubprogram; // R1529
+constexpr Parser<FunctionStmt> functionStmt; // R1530
+constexpr Parser<Suffix> suffix; // R1532
+constexpr Parser<EndFunctionStmt> endFunctionStmt; // R1533
+constexpr Parser<SubroutineSubprogram> subroutineSubprogram; // R1534
+constexpr Parser<SubroutineStmt> subroutineStmt; // R1535
+constexpr Parser<DummyArg> dummyArg; // R1536
+constexpr Parser<EndSubroutineStmt> endSubroutineStmt; // R1537
+constexpr Parser<EntryStmt> entryStmt; // R1541
+constexpr Parser<ContainsStmt> containsStmt; // R1543
 constexpr Parser<CompilerDirective> compilerDirective;
 constexpr Parser<OpenMPConstruct> openmpConstruct;
 constexpr Parser<OpenMPDeclarativeConstruct> openmpDeclarativeConstruct;
 constexpr Parser<OmpEndLoopDirective> ompEndLoopDirective;
-}
-#endif  // FORTRAN_PARSER_TYPE_PARSERS_H_
+} // namespace Fortran::parser
+#endif // FORTRAN_PARSER_TYPE_PARSERS_H_
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
index 5a67bac118e0..c2b5c28767da 100644
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -29,31 +29,31 @@ public:
   UnparseVisitor(llvm::raw_ostream &out, int indentationAmount,
       Encoding encoding, bool capitalize, bool backslashEscapes,
       preStatementType *preStatement, AnalyzedObjectsAsFortran *asFortran)
-    : out_{out}, indentationAmount_{indentationAmount}, encoding_{encoding},
-      capitalizeKeywords_{capitalize}, backslashEscapes_{backslashEscapes},
-      preStatement_{preStatement}, asFortran_{asFortran} {}
+      : out_{out}, indentationAmount_{indentationAmount}, encoding_{encoding},
+        capitalizeKeywords_{capitalize}, backslashEscapes_{backslashEscapes},
+        preStatement_{preStatement}, asFortran_{asFortran} {}
 
   // In nearly all cases, this code avoids defining Boolean-valued Pre()
   // callbacks for the parse tree walking framework in favor of two void
   // functions, Before() and Unparse(), which imply true and false return
   // values for Pre() respectively.
-  template<typename T> void Before(const T &) {}
-  template<typename T> double Unparse(const T &);  // not void, never used
+  template <typename T> void Before(const T &) {}
+  template <typename T> double Unparse(const T &); // not void, never used
 
-  template<typename T> bool Pre(const T &x) {
+  template <typename T> bool Pre(const T &x) {
     if constexpr (std::is_void_v<decltype(Unparse(x))>) {
       // There is a local definition of Unparse() for this type.  It
       // overrides the parse tree walker's default Walk() over the descendents.
       Before(x);
       Unparse(x);
       Post(x);
-      return false;  // Walk() does not visit descendents
+      return false; // Walk() does not visit descendents
     } else {
       Before(x);
-      return true;  // there's no Unparse() defined here, Walk() the descendents
+      return true; // there's no Unparse() defined here, Walk() the descendents
     }
   }
-  template<typename T> void Post(const T &) {}
+  template <typename T> void Post(const T &) {}
 
   // Emit simple types as-is.
   void Unparse(const std::string &x) { Put(x); }
@@ -66,45 +66,70 @@ public:
   void Unparse(char x) { Put(x); }
 
   // Statement labels and ends of lines
-  template<typename T> void Before(const Statement<T> &x) {
+  template <typename T> void Before(const Statement<T> &x) {
     if (preStatement_) {
       (*preStatement_)(x.source, out_, indent_);
     }
     Walk(x.label, " ");
   }
-  template<typename T> void Post(const Statement<T> &) { Put('\n'); }
+  template <typename T> void Post(const Statement<T> &) { Put('\n'); }
 
   // The special-case formatting functions for these productions are
   // ordered to correspond roughly to their order of appearance in
   // the Fortran 2018 standard (and parse-tree.h).
 
-  void Unparse(const Program &x) {  // R501
-    Walk("", x.v, "\n");  // put blank lines between ProgramUnits
+  void Unparse(const Program &x) { // R501
+    Walk("", x.v, "\n"); // put blank lines between ProgramUnits
   }
 
-  void Unparse(const Name &x) {  // R603
+  void Unparse(const Name &x) { // R603
     Put(x.ToString());
   }
-  void Unparse(const DefinedOperator::IntrinsicOperator &x) {  // R608
+  void Unparse(const DefinedOperator::IntrinsicOperator &x) { // R608
     switch (x) {
-    case DefinedOperator::IntrinsicOperator::Power: Put("**"); break;
-    case DefinedOperator::IntrinsicOperator::Multiply: Put('*'); break;
-    case DefinedOperator::IntrinsicOperator::Divide: Put('/'); break;
-    case DefinedOperator::IntrinsicOperator::Add: Put('+'); break;
-    case DefinedOperator::IntrinsicOperator::Subtract: Put('-'); break;
-    case DefinedOperator::IntrinsicOperator::Concat: Put("//"); break;
-    case DefinedOperator::IntrinsicOperator::LT: Put('<'); break;
-    case DefinedOperator::IntrinsicOperator::LE: Put("<="); break;
-    case DefinedOperator::IntrinsicOperator::EQ: Put("=="); break;
-    case DefinedOperator::IntrinsicOperator::NE: Put("/="); break;
-    case DefinedOperator::IntrinsicOperator::GE: Put(">="); break;
-    case DefinedOperator::IntrinsicOperator::GT: Put('>'); break;
-    default: Put('.'), Word(DefinedOperator::EnumToString(x)), Put('.');
+    case DefinedOperator::IntrinsicOperator::Power:
+      Put("**");
+      break;
+    case DefinedOperator::IntrinsicOperator::Multiply:
+      Put('*');
+      break;
+    case DefinedOperator::IntrinsicOperator::Divide:
+      Put('/');
+      break;
+    case DefinedOperator::IntrinsicOperator::Add:
+      Put('+');
+      break;
+    case DefinedOperator::IntrinsicOperator::Subtract:
+      Put('-');
+      break;
+    case DefinedOperator::IntrinsicOperator::Concat:
+      Put("//");
+      break;
+    case DefinedOperator::IntrinsicOperator::LT:
+      Put('<');
+      break;
+    case DefinedOperator::IntrinsicOperator::LE:
+      Put("<=");
+      break;
+    case DefinedOperator::IntrinsicOperator::EQ:
+      Put("==");
+      break;
+    case DefinedOperator::IntrinsicOperator::NE:
+      Put("/=");
+      break;
+    case DefinedOperator::IntrinsicOperator::GE:
+      Put(">=");
+      break;
+    case DefinedOperator::IntrinsicOperator::GT:
+      Put('>');
+      break;
+    default:
+      Put('.'), Word(DefinedOperator::EnumToString(x)), Put('.');
     }
   }
-  void Post(const Star &) { Put('*'); }  // R701 &c.
-  void Post(const TypeParamValue::Deferred &) { Put(':'); }  // R701
-  void Unparse(const DeclarationTypeSpec::Type &x) {  // R703
+  void Post(const Star &) { Put('*'); } // R701 &c.
+  void Post(const TypeParamValue::Deferred &) { Put(':'); } // R701
+  void Unparse(const DeclarationTypeSpec::Type &x) { // R703
     Word("TYPE("), Walk(x.derived), Put(')');
   }
   void Unparse(const DeclarationTypeSpec::Class &x) {
@@ -115,7 +140,7 @@ public:
   void Unparse(const DeclarationTypeSpec::Record &x) {
     Word("RECORD/"), Walk(x.v), Put('/');
   }
-  void Before(const IntrinsicTypeSpec::Real &) {  // R704
+  void Before(const IntrinsicTypeSpec::Real &) { // R704
     Word("REAL");
   }
   void Before(const IntrinsicTypeSpec::Complex &) { Word("COMPLEX"); }
@@ -127,10 +152,10 @@ public:
   void Post(const IntrinsicTypeSpec::DoubleComplex &) {
     Word("DOUBLE COMPLEX");
   }
-  void Before(const IntegerTypeSpec &) {  // R705
+  void Before(const IntegerTypeSpec &) { // R705
     Word("INTEGER");
   }
-  void Unparse(const KindSelector &x) {  // R706
+  void Unparse(const KindSelector &x) { // R706
     std::visit(
         common::visitors{
             [&](const ScalarIntConstantExpr &y) {
@@ -140,38 +165,37 @@ public:
         },
         x.u);
   }
-  void Unparse(const SignedIntLiteralConstant &x) {  // R707
+  void Unparse(const SignedIntLiteralConstant &x) { // R707
     Put(std::get<CharBlock>(x.t).ToString());
     Walk("_", std::get<std::optional<KindParam>>(x.t));
   }
-  void Unparse(const IntLiteralConstant &x) {  // R708
+  void Unparse(const IntLiteralConstant &x) { // R708
     Put(std::get<CharBlock>(x.t).ToString());
     Walk("_", std::get<std::optional<KindParam>>(x.t));
   }
-  void Unparse(const Sign &x) {  // R712
+  void Unparse(const Sign &x) { // R712
     Put(x == Sign::Negative ? '-' : '+');
   }
-  void Unparse(const RealLiteralConstant &x) {  // R714, R715
+  void Unparse(const RealLiteralConstant &x) { // R714, R715
     Put(x.real.source.ToString()), Walk("_", x.kind);
   }
-  void Unparse(const ComplexLiteralConstant &x) {  // R718 - R720
+  void Unparse(const ComplexLiteralConstant &x) { // R718 - R720
     Put('('), Walk(x.t, ","), Put(')');
   }
-  void Unparse(const CharSelector::LengthAndKind &x) {  // R721
+  void Unparse(const CharSelector::LengthAndKind &x) { // R721
     Put('('), Word("KIND="), Walk(x.kind);
     Walk(", LEN=", x.length), Put(')');
   }
-  void Unparse(const LengthSelector &x) {  // R722
-    std::visit(
-        common::visitors{
-            [&](const TypeParamValue &y) {
-              Put('('), Word("LEN="), Walk(y), Put(')');
-            },
-            [&](const CharLength &y) { Put('*'), Walk(y); },
-        },
+  void Unparse(const LengthSelector &x) { // R722
+    std::visit(common::visitors{
+                   [&](const TypeParamValue &y) {
+                     Put('('), Word("LEN="), Walk(y), Put(')');
+                   },
+                   [&](const CharLength &y) { Put('*'), Walk(y); },
+               },
         x.u);
   }
-  void Unparse(const CharLength &x) {  // R723
+  void Unparse(const CharLength &x) { // R723
     std::visit(
         common::visitors{
             [&](const TypeParamValue &y) { Put('('), Walk(y), Put(')'); },
@@ -179,7 +203,7 @@ public:
         },
         x.u);
   }
-  void Unparse(const CharLiteralConstant &x) {  // R724
+  void Unparse(const CharLiteralConstant &x) { // R724
     const auto &str{std::get<std::string>(x.t)};
     if (const auto &k{std::get<std::optional<KindParam>>(x.t)}) {
       Walk(*k), Put('_');
@@ -197,39 +221,39 @@ public:
       }
     }
   }
-  void Unparse(const LogicalLiteralConstant &x) {  // R725
+  void Unparse(const LogicalLiteralConstant &x) { // R725
     Put(std::get<bool>(x.t) ? ".TRUE." : ".FALSE.");
     Walk("_", std::get<std::optional<KindParam>>(x.t));
   }
-  void Unparse(const DerivedTypeStmt &x) {  // R727
+  void Unparse(const DerivedTypeStmt &x) { // R727
     Word("TYPE"), Walk(", ", std::get<std::list<TypeAttrSpec>>(x.t), ", ");
     Put(" :: "), Walk(std::get<Name>(x.t));
     Walk("(", std::get<std::list<Name>>(x.t), ", ", ")");
     Indent();
   }
-  void Unparse(const Abstract &) {  // R728, &c.
+  void Unparse(const Abstract &) { // R728, &c.
     Word("ABSTRACT");
   }
   void Post(const TypeAttrSpec::BindC &) { Word("BIND(C)"); }
   void Unparse(const TypeAttrSpec::Extends &x) {
     Word("EXTENDS("), Walk(x.v), Put(')');
   }
-  void Unparse(const EndTypeStmt &x) {  // R730
+  void Unparse(const EndTypeStmt &x) { // R730
     Outdent(), Word("END TYPE"), Walk(" ", x.v);
   }
-  void Unparse(const SequenceStmt &) {  // R731
+  void Unparse(const SequenceStmt &) { // R731
     Word("SEQUENCE");
   }
-  void Unparse(const TypeParamDefStmt &x) {  // R732
+  void Unparse(const TypeParamDefStmt &x) { // R732
     Walk(std::get<IntegerTypeSpec>(x.t));
     Put(", "), Walk(std::get<common::TypeParamAttr>(x.t));
     Put(" :: "), Walk(std::get<std::list<TypeParamDecl>>(x.t), ", ");
   }
-  void Unparse(const TypeParamDecl &x) {  // R733
+  void Unparse(const TypeParamDecl &x) { // R733
     Walk(std::get<Name>(x.t));
     Walk("=", std::get<std::optional<ScalarIntConstantExpr>>(x.t));
   }
-  void Unparse(const DataComponentDefStmt &x) {  // R737
+  void Unparse(const DataComponentDefStmt &x) { // R737
     const auto &dts{std::get<DeclarationTypeSpec>(x.t)};
     const auto &attrs{std::get<std::list<ComponentAttrSpec>>(x.t)};
     const auto &decls{std::get<std::list<ComponentDecl>>(x.t)};
@@ -249,70 +273,66 @@ public:
     }
     Put(' '), Walk(decls, ", ");
   }
-  void Unparse(const Allocatable &) {  // R738
+  void Unparse(const Allocatable &) { // R738
     Word("ALLOCATABLE");
   }
   void Unparse(const Pointer &) { Word("POINTER"); }
   void Unparse(const Contiguous &) { Word("CONTIGUOUS"); }
   void Before(const ComponentAttrSpec &x) {
-    std::visit(
-        common::visitors{
-            [&](const CoarraySpec &) { Word("CODIMENSION["); },
-            [&](const ComponentArraySpec &) { Word("DIMENSION("); },
-            [](const auto &) {},
-        },
+    std::visit(common::visitors{
+                   [&](const CoarraySpec &) { Word("CODIMENSION["); },
+                   [&](const ComponentArraySpec &) { Word("DIMENSION("); },
+                   [](const auto &) {},
+               },
         x.u);
   }
   void Post(const ComponentAttrSpec &x) {
-    std::visit(
-        common::visitors{
-            [&](const CoarraySpec &) { Put(']'); },
-            [&](const ComponentArraySpec &) { Put(')'); },
-            [](const auto &) {},
-        },
+    std::visit(common::visitors{
+                   [&](const CoarraySpec &) { Put(']'); },
+                   [&](const ComponentArraySpec &) { Put(')'); },
+                   [](const auto &) {},
+               },
         x.u);
   }
-  void Unparse(const ComponentDecl &x) {  // R739
+  void Unparse(const ComponentDecl &x) { // R739
     Walk(std::get<ObjectName>(x.t));
     Walk("(", std::get<std::optional<ComponentArraySpec>>(x.t), ")");
     Walk("[", std::get<std::optional<CoarraySpec>>(x.t), "]");
     Walk("*", std::get<std::optional<CharLength>>(x.t));
     Walk(std::get<std::optional<Initialization>>(x.t));
   }
-  void Unparse(const ComponentArraySpec &x) {  // R740
-    std::visit(
-        common::visitors{
-            [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
-            [&](const DeferredShapeSpecList &y) { Walk(y); },
-        },
+  void Unparse(const ComponentArraySpec &x) { // R740
+    std::visit(common::visitors{
+                   [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
+                   [&](const DeferredShapeSpecList &y) { Walk(y); },
+               },
         x.u);
   }
-  void Unparse(const ProcComponentDefStmt &x) {  // R741
+  void Unparse(const ProcComponentDefStmt &x) { // R741
     Word("PROCEDURE(");
     Walk(std::get<std::optional<ProcInterface>>(x.t)), Put(')');
     Walk(", ", std::get<std::list<ProcComponentAttrSpec>>(x.t), ", ");
     Put(" :: "), Walk(std::get<std::list<ProcDecl>>(x.t), ", ");
   }
-  void Unparse(const NoPass &) {  // R742
+  void Unparse(const NoPass &) { // R742
     Word("NOPASS");
   }
   void Unparse(const Pass &x) { Word("PASS"), Walk("(", x.v, ")"); }
-  void Unparse(const Initialization &x) {  // R743 & R805
-    std::visit(
-        common::visitors{
-            [&](const ConstantExpr &y) { Put(" = "), Walk(y); },
-            [&](const NullInit &y) { Put(" => "), Walk(y); },
-            [&](const InitialDataTarget &y) { Put(" => "), Walk(y); },
-            [&](const std::list<common::Indirection<DataStmtValue>> &y) {
-              Walk("/", y, ", ", "/");
-            },
-        },
+  void Unparse(const Initialization &x) { // R743 & R805
+    std::visit(common::visitors{
+                   [&](const ConstantExpr &y) { Put(" = "), Walk(y); },
+                   [&](const NullInit &y) { Put(" => "), Walk(y); },
+                   [&](const InitialDataTarget &y) { Put(" => "), Walk(y); },
+                   [&](const std::list<common::Indirection<DataStmtValue>> &y) {
+                     Walk("/", y, ", ", "/");
+                   },
+               },
         x.u);
   }
-  void Unparse(const PrivateStmt &) {  // R745
+  void Unparse(const PrivateStmt &) { // R745
     Word("PRIVATE");
   }
-  void Unparse(const TypeBoundProcedureStmt::WithoutInterface &x) {  // R749
+  void Unparse(const TypeBoundProcedureStmt::WithoutInterface &x) { // R749
     Word("PROCEDURE"), Walk(", ", x.attributes, ", ");
     Put(" :: "), Walk(x.declarations, ", ");
   }
@@ -321,76 +341,76 @@ public:
     Walk(x.attributes);
     Put(" :: "), Walk(x.bindingNames, ", ");
   }
-  void Unparse(const TypeBoundProcDecl &x) {  // R750
+  void Unparse(const TypeBoundProcDecl &x) { // R750
     Walk(std::get<Name>(x.t));
     Walk(" => ", std::get<std::optional<Name>>(x.t));
   }
-  void Unparse(const TypeBoundGenericStmt &x) {  // R751
+  void Unparse(const TypeBoundGenericStmt &x) { // R751
     Word("GENERIC"), Walk(", ", std::get<std::optional<AccessSpec>>(x.t));
     Put(" :: "), Walk(std::get<common::Indirection<GenericSpec>>(x.t));
     Put(" => "), Walk(std::get<std::list<Name>>(x.t), ", ");
   }
-  void Post(const BindAttr::Deferred &) { Word("DEFERRED"); }  // R752
+  void Post(const BindAttr::Deferred &) { Word("DEFERRED"); } // R752
   void Post(const BindAttr::Non_Overridable &) { Word("NON_OVERRIDABLE"); }
-  void Unparse(const FinalProcedureStmt &x) {  // R753
+  void Unparse(const FinalProcedureStmt &x) { // R753
     Word("FINAL :: "), Walk(x.v, ", ");
   }
-  void Unparse(const DerivedTypeSpec &x) {  // R754
+  void Unparse(const DerivedTypeSpec &x) { // R754
     Walk(std::get<Name>(x.t));
     Walk("(", std::get<std::list<TypeParamSpec>>(x.t), ",", ")");
   }
-  void Unparse(const TypeParamSpec &x) {  // R755
+  void Unparse(const TypeParamSpec &x) { // R755
     Walk(std::get<std::optional<Keyword>>(x.t), "=");
     Walk(std::get<TypeParamValue>(x.t));
   }
-  void Unparse(const StructureConstructor &x) {  // R756
+  void Unparse(const StructureConstructor &x) { // R756
     Walk(std::get<DerivedTypeSpec>(x.t));
     Put('('), Walk(std::get<std::list<ComponentSpec>>(x.t), ", "), Put(')');
   }
-  void Unparse(const ComponentSpec &x) {  // R757
+  void Unparse(const ComponentSpec &x) { // R757
     Walk(std::get<std::optional<Keyword>>(x.t), "=");
     Walk(std::get<ComponentDataSource>(x.t));
   }
-  void Unparse(const EnumDefStmt &) {  // R760
+  void Unparse(const EnumDefStmt &) { // R760
     Word("ENUM, BIND(C)"), Indent();
   }
-  void Unparse(const EnumeratorDefStmt &x) {  // R761
+  void Unparse(const EnumeratorDefStmt &x) { // R761
     Word("ENUMERATOR :: "), Walk(x.v, ", ");
   }
-  void Unparse(const Enumerator &x) {  // R762
+  void Unparse(const Enumerator &x) { // R762
     Walk(std::get<NamedConstant>(x.t));
     Walk(" = ", std::get<std::optional<ScalarIntConstantExpr>>(x.t));
   }
-  void Post(const EndEnumStmt &) {  // R763
+  void Post(const EndEnumStmt &) { // R763
     Outdent(), Word("END ENUM");
   }
-  void Unparse(const BOZLiteralConstant &x) {  // R764 - R767
+  void Unparse(const BOZLiteralConstant &x) { // R764 - R767
     Put(x.v);
   }
-  void Unparse(const AcValue::Triplet &x) {  // R773
+  void Unparse(const AcValue::Triplet &x) { // R773
     Walk(std::get<0>(x.t)), Put(':'), Walk(std::get<1>(x.t));
     Walk(":", std::get<std::optional<ScalarIntExpr>>(x.t));
   }
-  void Unparse(const ArrayConstructor &x) {  // R769
+  void Unparse(const ArrayConstructor &x) { // R769
     Put('['), Walk(x.v), Put(']');
   }
-  void Unparse(const AcSpec &x) {  // R770
+  void Unparse(const AcSpec &x) { // R770
     Walk(x.type, "::"), Walk(x.values, ", ");
   }
-  template<typename A, typename B> void Unparse(const LoopBounds<A, B> &x) {
+  template <typename A, typename B> void Unparse(const LoopBounds<A, B> &x) {
     Walk(x.name), Put('='), Walk(x.lower), Put(','), Walk(x.upper);
     Walk(",", x.step);
   }
-  void Unparse(const AcImpliedDo &x) {  // R774
+  void Unparse(const AcImpliedDo &x) { // R774
     Put('('), Walk(std::get<std::list<AcValue>>(x.t), ", ");
     Put(", "), Walk(std::get<AcImpliedDoControl>(x.t)), Put(')');
   }
-  void Unparse(const AcImpliedDoControl &x) {  // R775
+  void Unparse(const AcImpliedDoControl &x) { // R775
     Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
     Walk(std::get<AcImpliedDoControl::Bounds>(x.t));
   }
 
-  void Unparse(const TypeDeclarationStmt &x) {  // R801
+  void Unparse(const TypeDeclarationStmt &x) { // R801
     const auto &dts{std::get<DeclarationTypeSpec>(x.t)};
     const auto &attrs{std::get<std::list<AttrSpec>>(x.t)};
     const auto &decls{std::get<std::list<EntityDecl>>(x.t)};
@@ -445,46 +465,43 @@ public:
     }
     Put(' '), Walk(std::get<std::list<EntityDecl>>(x.t), ", ");
   }
-  void Before(const AttrSpec &x) {  // R802
-    std::visit(
-        common::visitors{
-            [&](const CoarraySpec &) { Word("CODIMENSION["); },
-            [&](const ArraySpec &) { Word("DIMENSION("); },
-            [](const auto &) {},
-        },
+  void Before(const AttrSpec &x) { // R802
+    std::visit(common::visitors{
+                   [&](const CoarraySpec &) { Word("CODIMENSION["); },
+                   [&](const ArraySpec &) { Word("DIMENSION("); },
+                   [](const auto &) {},
+               },
         x.u);
   }
   void Post(const AttrSpec &x) {
-    std::visit(
-        common::visitors{
-            [&](const CoarraySpec &) { Put(']'); },
-            [&](const ArraySpec &) { Put(')'); },
-            [](const auto &) {},
-        },
+    std::visit(common::visitors{
+                   [&](const CoarraySpec &) { Put(']'); },
+                   [&](const ArraySpec &) { Put(')'); },
+                   [](const auto &) {},
+               },
         x.u);
   }
-  void Unparse(const EntityDecl &x) {  // R803
+  void Unparse(const EntityDecl &x) { // R803
     Walk(std::get<ObjectName>(x.t));
     Walk("(", std::get<std::optional<ArraySpec>>(x.t), ")");
     Walk("[", std::get<std::optional<CoarraySpec>>(x.t), "]");
     Walk("*", std::get<std::optional<CharLength>>(x.t));
     Walk(std::get<std::optional<Initialization>>(x.t));
   }
-  void Unparse(const NullInit &) {  // R806
+  void Unparse(const NullInit &) { // R806
     Word("NULL()");
   }
-  void Unparse(const LanguageBindingSpec &x) {  // R808 & R1528
+  void Unparse(const LanguageBindingSpec &x) { // R808 & R1528
     Word("BIND(C"), Walk(", NAME=", x.v), Put(')');
   }
-  void Unparse(const CoarraySpec &x) {  // R809
-    std::visit(
-        common::visitors{
-            [&](const DeferredCoshapeSpecList &y) { Walk(y); },
-            [&](const ExplicitCoshapeSpec &y) { Walk(y); },
-        },
+  void Unparse(const CoarraySpec &x) { // R809
+    std::visit(common::visitors{
+                   [&](const DeferredCoshapeSpecList &y) { Walk(y); },
+                   [&](const ExplicitCoshapeSpec &y) { Walk(y); },
+               },
         x.u);
   }
-  void Unparse(const DeferredCoshapeSpecList &x) {  // R810
+  void Unparse(const DeferredCoshapeSpecList &x) { // R810
     for (auto j{x.v}; j > 0; --j) {
       Put(':');
       if (j > 1) {
@@ -492,28 +509,27 @@ public:
       }
     }
   }
-  void Unparse(const ExplicitCoshapeSpec &x) {  // R811
+  void Unparse(const ExplicitCoshapeSpec &x) { // R811
     Walk(std::get<std::list<ExplicitShapeSpec>>(x.t), ",", ",");
     Walk(std::get<std::optional<SpecificationExpr>>(x.t), ":"), Put('*');
   }
-  void Unparse(const ExplicitShapeSpec &x) {  // R812 - R813 & R816 - R818
+  void Unparse(const ExplicitShapeSpec &x) { // R812 - R813 & R816 - R818
     Walk(std::get<std::optional<SpecificationExpr>>(x.t), ":");
     Walk(std::get<SpecificationExpr>(x.t));
   }
-  void Unparse(const ArraySpec &x) {  // R815
-    std::visit(
-        common::visitors{
-            [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
-            [&](const std::list<AssumedShapeSpec> &y) { Walk(y, ","); },
-            [&](const DeferredShapeSpecList &y) { Walk(y); },
-            [&](const AssumedSizeSpec &y) { Walk(y); },
-            [&](const ImpliedShapeSpec &y) { Walk(y); },
-            [&](const AssumedRankSpec &y) { Walk(y); },
-        },
+  void Unparse(const ArraySpec &x) { // R815
+    std::visit(common::visitors{
+                   [&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
+                   [&](const std::list<AssumedShapeSpec> &y) { Walk(y, ","); },
+                   [&](const DeferredShapeSpecList &y) { Walk(y); },
+                   [&](const AssumedSizeSpec &y) { Walk(y); },
+                   [&](const ImpliedShapeSpec &y) { Walk(y); },
+                   [&](const AssumedRankSpec &y) { Walk(y); },
+               },
         x.u);
   }
-  void Post(const AssumedShapeSpec &) { Put(':'); }  // R819
-  void Unparse(const DeferredShapeSpecList &x) {  // R820
+  void Post(const AssumedShapeSpec &) { Put(':'); } // R819
+  void Unparse(const DeferredShapeSpecList &x) { // R820
     for (auto j{x.v}; j > 0; --j) {
       Put(':');
       if (j > 1) {
@@ -521,18 +537,18 @@ public:
       }
     }
   }
-  void Unparse(const AssumedImpliedSpec &x) {  // R821
+  void Unparse(const AssumedImpliedSpec &x) { // R821
     Walk(x.v, ":");
     Put('*');
   }
-  void Unparse(const AssumedSizeSpec &x) {  // R822
+  void Unparse(const AssumedSizeSpec &x) { // R822
     Walk(std::get<std::list<ExplicitShapeSpec>>(x.t), ",", ",");
     Walk(std::get<AssumedImpliedSpec>(x.t));
   }
-  void Unparse(const ImpliedShapeSpec &x) {  // R823
+  void Unparse(const ImpliedShapeSpec &x) { // R823
     Walk(x.v, ",");
   }
-  void Post(const AssumedRankSpec &) { Put(".."); }  // R825
+  void Post(const AssumedRankSpec &) { Put(".."); } // R825
   void Post(const Asynchronous &) { Word("ASYNCHRONOUS"); }
   void Post(const External &) { Word("EXTERNAL"); }
   void Post(const Intrinsic &) { Word("INTRINSIC"); }
@@ -543,147 +559,152 @@ public:
   void Post(const Target &) { Word("TARGET"); }
   void Post(const Value &) { Word("VALUE"); }
   void Post(const Volatile &) { Word("VOLATILE"); }
-  void Unparse(const IntentSpec &x) {  // R826
+  void Unparse(const IntentSpec &x) { // R826
     Word("INTENT("), Walk(x.v), Put(")");
   }
-  void Unparse(const AccessStmt &x) {  // R827
+  void Unparse(const AccessStmt &x) { // R827
     Walk(std::get<AccessSpec>(x.t));
     Walk(" :: ", std::get<std::list<AccessId>>(x.t), ", ");
   }
-  void Unparse(const AllocatableStmt &x) {  // R829
+  void Unparse(const AllocatableStmt &x) { // R829
     Word("ALLOCATABLE :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ObjectDecl &x) {  // R830 & R860
+  void Unparse(const ObjectDecl &x) { // R830 & R860
     Walk(std::get<ObjectName>(x.t));
     Walk("(", std::get<std::optional<ArraySpec>>(x.t), ")");
     Walk("[", std::get<std::optional<CoarraySpec>>(x.t), "]");
   }
-  void Unparse(const AsynchronousStmt &x) {  // R831
+  void Unparse(const AsynchronousStmt &x) { // R831
     Word("ASYNCHRONOUS :: "), Walk(x.v, ", ");
   }
-  void Unparse(const BindStmt &x) {  // R832
+  void Unparse(const BindStmt &x) { // R832
     Walk(x.t, " :: ");
   }
-  void Unparse(const BindEntity &x) {  // R833
+  void Unparse(const BindEntity &x) { // R833
     bool isCommon{std::get<BindEntity::Kind>(x.t) == BindEntity::Kind::Common};
     const char *slash{isCommon ? "/" : ""};
     Put(slash), Walk(std::get<Name>(x.t)), Put(slash);
   }
-  void Unparse(const CodimensionStmt &x) {  // R834
+  void Unparse(const CodimensionStmt &x) { // R834
     Word("CODIMENSION :: "), Walk(x.v, ", ");
   }
-  void Unparse(const CodimensionDecl &x) {  // R835
+  void Unparse(const CodimensionDecl &x) { // R835
     Walk(std::get<Name>(x.t));
     Put('['), Walk(std::get<CoarraySpec>(x.t)), Put(']');
   }
-  void Unparse(const ContiguousStmt &x) {  // R836
+  void Unparse(const ContiguousStmt &x) { // R836
     Word("CONTIGUOUS :: "), Walk(x.v, ", ");
   }
-  void Unparse(const DataStmt &x) {  // R837
+  void Unparse(const DataStmt &x) { // R837
     Word("DATA "), Walk(x.v, ", ");
   }
-  void Unparse(const DataStmtSet &x) {  // R838
+  void Unparse(const DataStmtSet &x) { // R838
     Walk(std::get<std::list<DataStmtObject>>(x.t), ", ");
     Put('/'), Walk(std::get<std::list<DataStmtValue>>(x.t), ", "), Put('/');
   }
-  void Unparse(const DataImpliedDo &x) {  // R840, R842
+  void Unparse(const DataImpliedDo &x) { // R840, R842
     Put('('), Walk(std::get<std::list<DataIDoObject>>(x.t), ", "), Put(',');
     Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
     Walk(std::get<DataImpliedDo::Bounds>(x.t)), Put(')');
   }
-  void Unparse(const DataStmtValue &x) {  // R843
+  void Unparse(const DataStmtValue &x) { // R843
     Walk(std::get<std::optional<DataStmtRepeat>>(x.t), "*");
     Walk(std::get<DataStmtConstant>(x.t));
   }
-  void Unparse(const DimensionStmt &x) {  // R848
+  void Unparse(const DimensionStmt &x) { // R848
     Word("DIMENSION :: "), Walk(x.v, ", ");
   }
   void Unparse(const DimensionStmt::Declaration &x) {
     Walk(std::get<Name>(x.t));
     Put('('), Walk(std::get<ArraySpec>(x.t)), Put(')');
   }
-  void Unparse(const IntentStmt &x) {  // R849
+  void Unparse(const IntentStmt &x) { // R849
     Walk(x.t, " :: ");
   }
-  void Unparse(const OptionalStmt &x) {  // R850
+  void Unparse(const OptionalStmt &x) { // R850
     Word("OPTIONAL :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ParameterStmt &x) {  // R851
+  void Unparse(const ParameterStmt &x) { // R851
     Word("PARAMETER("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const NamedConstantDef &x) {  // R852
+  void Unparse(const NamedConstantDef &x) { // R852
     Walk(x.t, "=");
   }
-  void Unparse(const PointerStmt &x) {  // R853
+  void Unparse(const PointerStmt &x) { // R853
     Word("POINTER :: "), Walk(x.v, ", ");
   }
-  void Unparse(const PointerDecl &x) {  // R854
+  void Unparse(const PointerDecl &x) { // R854
     Walk(std::get<Name>(x.t));
     Walk("(", std::get<std::optional<DeferredShapeSpecList>>(x.t), ")");
   }
-  void Unparse(const ProtectedStmt &x) {  // R855
+  void Unparse(const ProtectedStmt &x) { // R855
     Word("PROTECTED :: "), Walk(x.v, ", ");
   }
-  void Unparse(const SaveStmt &x) {  // R856
+  void Unparse(const SaveStmt &x) { // R856
     Word("SAVE"), Walk(" :: ", x.v, ", ");
   }
-  void Unparse(const SavedEntity &x) {  // R857, R858
+  void Unparse(const SavedEntity &x) { // R857, R858
     bool isCommon{
         std::get<SavedEntity::Kind>(x.t) == SavedEntity::Kind::Common};
     const char *slash{isCommon ? "/" : ""};
     Put(slash), Walk(std::get<Name>(x.t)), Put(slash);
   }
-  void Unparse(const TargetStmt &x) {  // R859
+  void Unparse(const TargetStmt &x) { // R859
     Word("TARGET :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ValueStmt &x) {  // R861
+  void Unparse(const ValueStmt &x) { // R861
     Word("VALUE :: "), Walk(x.v, ", ");
   }
-  void Unparse(const VolatileStmt &x) {  // R862
+  void Unparse(const VolatileStmt &x) { // R862
     Word("VOLATILE :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ImplicitStmt &x) {  // R863
+  void Unparse(const ImplicitStmt &x) { // R863
     Word("IMPLICIT ");
-    std::visit(
-        common::visitors{
-            [&](const std::list<ImplicitSpec> &y) { Walk(y, ", "); },
-            [&](const std::list<ImplicitStmt::ImplicitNoneNameSpec> &y) {
-              Word("NONE"), Walk(" (", y, ", ", ")");
-            },
-        },
+    std::visit(common::visitors{
+                   [&](const std::list<ImplicitSpec> &y) { Walk(y, ", "); },
+                   [&](const std::list<ImplicitStmt::ImplicitNoneNameSpec> &y) {
+                     Word("NONE"), Walk(" (", y, ", ", ")");
+                   },
+               },
         x.u);
   }
-  void Unparse(const ImplicitSpec &x) {  // R864
+  void Unparse(const ImplicitSpec &x) { // R864
     Walk(std::get<DeclarationTypeSpec>(x.t));
     Put('('), Walk(std::get<std::list<LetterSpec>>(x.t), ", "), Put(')');
   }
-  void Unparse(const LetterSpec &x) {  // R865
+  void Unparse(const LetterSpec &x) { // R865
     Put(*std::get<const char *>(x.t));
     auto second{std::get<std::optional<const char *>>(x.t)};
     if (second) {
       Put('-'), Put(**second);
     }
   }
-  void Unparse(const ImportStmt &x) {  // R867
+  void Unparse(const ImportStmt &x) { // R867
     Word("IMPORT");
     switch (x.kind) {
-    case common::ImportKind::Default: Walk(" :: ", x.names, ", "); break;
+    case common::ImportKind::Default:
+      Walk(" :: ", x.names, ", ");
+      break;
     case common::ImportKind::Only:
       Put(", "), Word("ONLY: ");
       Walk(x.names, ", ");
       break;
-    case common::ImportKind::None: Word(", NONE"); break;
-    case common::ImportKind::All: Word(", ALL"); break;
+    case common::ImportKind::None:
+      Word(", NONE");
+      break;
+    case common::ImportKind::All:
+      Word(", ALL");
+      break;
     }
   }
-  void Unparse(const NamelistStmt &x) {  // R868
+  void Unparse(const NamelistStmt &x) { // R868
     Word("NAMELIST"), Walk(x.v, ", ");
   }
   void Unparse(const NamelistStmt::Group &x) {
     Put('/'), Walk(std::get<Name>(x.t)), Put('/');
     Walk(std::get<std::list<Name>>(x.t), ", ");
   }
-  void Unparse(const EquivalenceStmt &x) {  // R870, R871
+  void Unparse(const EquivalenceStmt &x) { // R870, R871
     Word("EQUIVALENCE");
     const char *separator{" "};
     for (const std::list<EquivalenceObject> &y : x.v) {
@@ -691,11 +712,11 @@ public:
       separator = ", ";
     }
   }
-  void Unparse(const CommonStmt &x) {  // R873
+  void Unparse(const CommonStmt &x) { // R873
     Word("COMMON ");
     Walk(x.blocks);
   }
-  void Unparse(const CommonBlockObject &x) {  // R874
+  void Unparse(const CommonBlockObject &x) { // R874
     Walk(std::get<Name>(x.t));
     Walk("(", std::get<std::optional<ArraySpec>>(x.t), ")");
   }
@@ -704,7 +725,7 @@ public:
     Walk(std::get<std::list<CommonBlockObject>>(x.t));
   }
 
-  void Unparse(const Substring &x) {  // R908, R909
+  void Unparse(const Substring &x) { // R908, R909
     Walk(std::get<DataRef>(x.t));
     Put('('), Walk(std::get<SubstringRange>(x.t)), Put(')');
   }
@@ -712,15 +733,15 @@ public:
     Walk(std::get<CharLiteralConstant>(x.t));
     Put('('), Walk(std::get<SubstringRange>(x.t)), Put(')');
   }
-  void Unparse(const SubstringRange &x) {  // R910
+  void Unparse(const SubstringRange &x) { // R910
     Walk(x.t, ":");
   }
-  void Unparse(const PartRef &x) {  // R912
+  void Unparse(const PartRef &x) { // R912
     Walk(x.name);
     Walk("(", x.subscripts, ",", ")");
     Walk(x.imageSelector);
   }
-  void Unparse(const StructureComponent &x) {  // R913
+  void Unparse(const StructureComponent &x) { // R913
     Walk(x.base);
     if (structureComponents_.find(x.component.source) !=
         structureComponents_.end()) {
@@ -730,19 +751,19 @@ public:
     }
     Walk(x.component);
   }
-  void Unparse(const ArrayElement &x) {  // R917
+  void Unparse(const ArrayElement &x) { // R917
     Walk(x.base);
     Put('('), Walk(x.subscripts, ","), Put(')');
   }
-  void Unparse(const SubscriptTriplet &x) {  // R921
+  void Unparse(const SubscriptTriplet &x) { // R921
     Walk(std::get<0>(x.t)), Put(':'), Walk(std::get<1>(x.t));
     Walk(":", std::get<2>(x.t));
   }
-  void Unparse(const ImageSelector &x) {  // R924
+  void Unparse(const ImageSelector &x) { // R924
     Put('['), Walk(std::get<std::list<Cosubscript>>(x.t), ",");
     Walk(",", std::get<std::list<ImageSelectorSpec>>(x.t), ","), Put(']');
   }
-  void Before(const ImageSelectorSpec::Stat &) {  // R926
+  void Before(const ImageSelectorSpec::Stat &) { // R926
     Word("STAT=");
   }
   void Before(const ImageSelectorSpec::Team_Number &) { Word("TEAM_NUMBER="); }
@@ -751,48 +772,46 @@ public:
       Word("TEAM=");
     }
   }
-  void Unparse(const AllocateStmt &x) {  // R927
+  void Unparse(const AllocateStmt &x) { // R927
     Word("ALLOCATE(");
     Walk(std::get<std::optional<TypeSpec>>(x.t), "::");
     Walk(std::get<std::list<Allocation>>(x.t), ", ");
     Walk(", ", std::get<std::list<AllocOpt>>(x.t), ", "), Put(')');
   }
-  void Before(const AllocOpt &x) {  // R928, R931
-    std::visit(
-        common::visitors{
-            [&](const AllocOpt::Mold &) { Word("MOLD="); },
-            [&](const AllocOpt::Source &) { Word("SOURCE="); },
-            [](const StatOrErrmsg &) {},
-        },
+  void Before(const AllocOpt &x) { // R928, R931
+    std::visit(common::visitors{
+                   [&](const AllocOpt::Mold &) { Word("MOLD="); },
+                   [&](const AllocOpt::Source &) { Word("SOURCE="); },
+                   [](const StatOrErrmsg &) {},
+               },
         x.u);
   }
-  void Unparse(const Allocation &x) {  // R932
+  void Unparse(const Allocation &x) { // R932
     Walk(std::get<AllocateObject>(x.t));
     Walk("(", std::get<std::list<AllocateShapeSpec>>(x.t), ",", ")");
     Walk("[", std::get<std::optional<AllocateCoarraySpec>>(x.t), "]");
   }
-  void Unparse(const AllocateShapeSpec &x) {  // R934 & R938
+  void Unparse(const AllocateShapeSpec &x) { // R934 & R938
     Walk(std::get<std::optional<BoundExpr>>(x.t), ":");
     Walk(std::get<BoundExpr>(x.t));
   }
-  void Unparse(const AllocateCoarraySpec &x) {  // R937
+  void Unparse(const AllocateCoarraySpec &x) { // R937
     Walk(std::get<std::list<AllocateCoshapeSpec>>(x.t), ",", ",");
     Walk(std::get<std::optional<BoundExpr>>(x.t), ":"), Put('*');
   }
-  void Unparse(const NullifyStmt &x) {  // R939
+  void Unparse(const NullifyStmt &x) { // R939
     Word("NULLIFY("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const DeallocateStmt &x) {  // R941
+  void Unparse(const DeallocateStmt &x) { // R941
     Word("DEALLOCATE(");
     Walk(std::get<std::list<AllocateObject>>(x.t), ", ");
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
-  void Before(const StatOrErrmsg &x) {  // R942 & R1165
-    std::visit(
-        common::visitors{
-            [&](const StatVariable &) { Word("STAT="); },
-            [&](const MsgVariable &) { Word("ERRMSG="); },
-        },
+  void Before(const StatOrErrmsg &x) { // R942 & R1165
+    std::visit(common::visitors{
+                   [&](const StatVariable &) { Word("STAT="); },
+                   [&](const MsgVariable &) { Word("ERRMSG="); },
+               },
         x.u);
   }
 
@@ -833,14 +852,14 @@ public:
     Put('('), Walk(x.t, ","), Put(')');
   }
   void Unparse(const Expr::DefinedBinary &x) {
-    Walk(std::get<1>(x.t));  // left
+    Walk(std::get<1>(x.t)); // left
     Walk(std::get<DefinedOpName>(x.t));
-    Walk(std::get<2>(x.t));  // right
+    Walk(std::get<2>(x.t)); // right
   }
-  void Unparse(const DefinedOpName &x) {  // R1003, R1023, R1414, & R1415
+  void Unparse(const DefinedOpName &x) { // R1003, R1023, R1414, & R1415
     Walk(x.v);
   }
-  void Unparse(const AssignmentStmt &x) {  // R1032
+  void Unparse(const AssignmentStmt &x) { // R1032
     if (asFortran_ && x.typedAssignment.get()) {
       Put(' ');
       asFortran_->assignment(out_, *x.typedAssignment);
@@ -849,7 +868,7 @@ public:
       Walk(x.t, " = ");
     }
   }
-  void Unparse(const PointerAssignmentStmt &x) {  // R1033, R1034, R1038
+  void Unparse(const PointerAssignmentStmt &x) { // R1033, R1034, R1038
     if (asFortran_ && x.typedAssignment.get()) {
       Put(' ');
       asFortran_->assignment(out_, *x.typedAssignment);
@@ -867,119 +886,118 @@ public:
       Put(" => "), Walk(std::get<Expr>(x.t));
     }
   }
-  void Post(const BoundsSpec &) {  // R1035
+  void Post(const BoundsSpec &) { // R1035
     Put(':');
   }
-  void Unparse(const BoundsRemapping &x) {  // R1036
+  void Unparse(const BoundsRemapping &x) { // R1036
     Walk(x.t, ":");
   }
-  void Unparse(const WhereStmt &x) {  // R1041, R1045, R1046
+  void Unparse(const WhereStmt &x) { // R1041, R1045, R1046
     Word("WHERE ("), Walk(x.t, ") ");
   }
-  void Unparse(const WhereConstructStmt &x) {  // R1043
+  void Unparse(const WhereConstructStmt &x) { // R1043
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("WHERE ("), Walk(std::get<LogicalExpr>(x.t)), Put(')');
     Indent();
   }
-  void Unparse(const MaskedElsewhereStmt &x) {  // R1047
+  void Unparse(const MaskedElsewhereStmt &x) { // R1047
     Outdent();
     Word("ELSEWHERE ("), Walk(std::get<LogicalExpr>(x.t)), Put(')');
     Walk(" ", std::get<std::optional<Name>>(x.t));
     Indent();
   }
-  void Unparse(const ElsewhereStmt &x) {  // R1048
+  void Unparse(const ElsewhereStmt &x) { // R1048
     Outdent(), Word("ELSEWHERE"), Walk(" ", x.v), Indent();
   }
-  void Unparse(const EndWhereStmt &x) {  // R1049
+  void Unparse(const EndWhereStmt &x) { // R1049
     Outdent(), Word("END WHERE"), Walk(" ", x.v);
   }
-  void Unparse(const ForallConstructStmt &x) {  // R1051
+  void Unparse(const ForallConstructStmt &x) { // R1051
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("FORALL"), Walk(std::get<common::Indirection<ConcurrentHeader>>(x.t));
     Indent();
   }
-  void Unparse(const EndForallStmt &x) {  // R1054
+  void Unparse(const EndForallStmt &x) { // R1054
     Outdent(), Word("END FORALL"), Walk(" ", x.v);
   }
-  void Before(const ForallStmt &) {  // R1055
+  void Before(const ForallStmt &) { // R1055
     Word("FORALL");
   }
 
-  void Unparse(const AssociateStmt &x) {  // R1103
+  void Unparse(const AssociateStmt &x) { // R1103
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("ASSOCIATE (");
     Walk(std::get<std::list<Association>>(x.t), ", "), Put(')'), Indent();
   }
-  void Unparse(const Association &x) {  // R1104
+  void Unparse(const Association &x) { // R1104
     Walk(x.t, " => ");
   }
-  void Unparse(const EndAssociateStmt &x) {  // R1106
+  void Unparse(const EndAssociateStmt &x) { // R1106
     Outdent(), Word("END ASSOCIATE"), Walk(" ", x.v);
   }
-  void Unparse(const BlockStmt &x) {  // R1108
+  void Unparse(const BlockStmt &x) { // R1108
     Walk(x.v, ": "), Word("BLOCK"), Indent();
   }
-  void Unparse(const EndBlockStmt &x) {  // R1110
+  void Unparse(const EndBlockStmt &x) { // R1110
     Outdent(), Word("END BLOCK"), Walk(" ", x.v);
   }
-  void Unparse(const ChangeTeamStmt &x) {  // R1112
+  void Unparse(const ChangeTeamStmt &x) { // R1112
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("CHANGE TEAM ("), Walk(std::get<TeamValue>(x.t));
     Walk(", ", std::get<std::list<CoarrayAssociation>>(x.t), ", ");
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
     Indent();
   }
-  void Unparse(const CoarrayAssociation &x) {  // R1113
+  void Unparse(const CoarrayAssociation &x) { // R1113
     Walk(x.t, " => ");
   }
-  void Unparse(const EndChangeTeamStmt &x) {  // R1114
+  void Unparse(const EndChangeTeamStmt &x) { // R1114
     Outdent(), Word("END TEAM (");
     Walk(std::get<std::list<StatOrErrmsg>>(x.t), ", ");
     Put(')'), Walk(" ", std::get<std::optional<Name>>(x.t));
   }
-  void Unparse(const CriticalStmt &x) {  // R1117
+  void Unparse(const CriticalStmt &x) { // R1117
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("CRITICAL ("), Walk(std::get<std::list<StatOrErrmsg>>(x.t), ", ");
     Put(')'), Indent();
   }
-  void Unparse(const EndCriticalStmt &x) {  // R1118
+  void Unparse(const EndCriticalStmt &x) { // R1118
     Outdent(), Word("END CRITICAL"), Walk(" ", x.v);
   }
-  void Unparse(const DoConstruct &x) {  // R1119, R1120
+  void Unparse(const DoConstruct &x) { // R1119, R1120
     Walk(std::get<Statement<NonLabelDoStmt>>(x.t));
     Indent(), Walk(std::get<Block>(x.t), ""), Outdent();
     Walk(std::get<Statement<EndDoStmt>>(x.t));
   }
-  void Unparse(const LabelDoStmt &x) {  // R1121
+  void Unparse(const LabelDoStmt &x) { // R1121
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("DO "), Walk(std::get<Label>(x.t));
     Walk(" ", std::get<std::optional<LoopControl>>(x.t));
   }
-  void Unparse(const NonLabelDoStmt &x) {  // R1122
+  void Unparse(const NonLabelDoStmt &x) { // R1122
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("DO "), Walk(std::get<std::optional<LoopControl>>(x.t));
   }
-  void Unparse(const LoopControl &x) {  // R1123
-    std::visit(
-        common::visitors{
-            [&](const ScalarLogicalExpr &y) {
-              Word("WHILE ("), Walk(y), Put(')');
-            },
-            [&](const auto &y) { Walk(y); },
-        },
+  void Unparse(const LoopControl &x) { // R1123
+    std::visit(common::visitors{
+                   [&](const ScalarLogicalExpr &y) {
+                     Word("WHILE ("), Walk(y), Put(')');
+                   },
+                   [&](const auto &y) { Walk(y); },
+               },
         x.u);
   }
-  void Unparse(const ConcurrentHeader &x) {  // R1125
+  void Unparse(const ConcurrentHeader &x) { // R1125
     Put('('), Walk(std::get<std::optional<IntegerTypeSpec>>(x.t), "::");
     Walk(std::get<std::list<ConcurrentControl>>(x.t), ", ");
     Walk(", ", std::get<std::optional<ScalarLogicalExpr>>(x.t)), Put(')');
   }
-  void Unparse(const ConcurrentControl &x) {  // R1126 - R1128
+  void Unparse(const ConcurrentControl &x) { // R1126 - R1128
     Walk(std::get<Name>(x.t)), Put('='), Walk(std::get<1>(x.t));
     Put(':'), Walk(std::get<2>(x.t));
     Walk(":", std::get<std::optional<ScalarIntExpr>>(x.t));
   }
-  void Before(const LoopControl::Concurrent &) {  // R1129
+  void Before(const LoopControl::Concurrent &) { // R1129
     Word("CONCURRENT");
   }
   void Unparse(const LocalitySpec::Local &x) {
@@ -992,80 +1010,78 @@ public:
     Word("SHARED("), Walk(x.v, ", "), Put(')');
   }
   void Post(const LocalitySpec::DefaultNone &) { Word("DEFAULT(NONE)"); }
-  void Unparse(const EndDoStmt &x) {  // R1132
+  void Unparse(const EndDoStmt &x) { // R1132
     Word("END DO"), Walk(" ", x.v);
   }
-  void Unparse(const CycleStmt &x) {  // R1133
+  void Unparse(const CycleStmt &x) { // R1133
     Word("CYCLE"), Walk(" ", x.v);
   }
-  void Unparse(const IfThenStmt &x) {  // R1135
+  void Unparse(const IfThenStmt &x) { // R1135
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("IF ("), Walk(std::get<ScalarLogicalExpr>(x.t));
     Put(") "), Word("THEN"), Indent();
   }
-  void Unparse(const ElseIfStmt &x) {  // R1136
+  void Unparse(const ElseIfStmt &x) { // R1136
     Outdent(), Word("ELSE IF (");
     Walk(std::get<ScalarLogicalExpr>(x.t)), Put(") "), Word("THEN");
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
-  void Unparse(const ElseStmt &x) {  // R1137
+  void Unparse(const ElseStmt &x) { // R1137
     Outdent(), Word("ELSE"), Walk(" ", x.v), Indent();
   }
-  void Unparse(const EndIfStmt &x) {  // R1138
+  void Unparse(const EndIfStmt &x) { // R1138
     Outdent(), Word("END IF"), Walk(" ", x.v);
   }
-  void Unparse(const IfStmt &x) {  // R1139
+  void Unparse(const IfStmt &x) { // R1139
     Word("IF ("), Walk(x.t, ") ");
   }
-  void Unparse(const SelectCaseStmt &x) {  // R1141, R1144
+  void Unparse(const SelectCaseStmt &x) { // R1141, R1144
     Walk(std::get<std::optional<Name>>(x.t), ": ");
     Word("SELECT CASE (");
     Walk(std::get<Scalar<Expr>>(x.t)), Put(')'), Indent();
   }
-  void Unparse(const CaseStmt &x) {  // R1142
+  void Unparse(const CaseStmt &x) { // R1142
     Outdent(), Word("CASE "), Walk(std::get<CaseSelector>(x.t));
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
-  void Unparse(const EndSelectStmt &x) {  // R1143 & R1151 & R1155
+  void Unparse(const EndSelectStmt &x) { // R1143 & R1151 & R1155
     Outdent(), Word("END SELECT"), Walk(" ", x.v);
   }
-  void Unparse(const CaseSelector &x) {  // R1145
-    std::visit(
-        common::visitors{
-            [&](const std::list<CaseValueRange> &y) {
-              Put('('), Walk(y), Put(')');
-            },
-            [&](const Default &) { Word("DEFAULT"); },
-        },
+  void Unparse(const CaseSelector &x) { // R1145
+    std::visit(common::visitors{
+                   [&](const std::list<CaseValueRange> &y) {
+                     Put('('), Walk(y), Put(')');
+                   },
+                   [&](const Default &) { Word("DEFAULT"); },
+               },
         x.u);
   }
-  void Unparse(const CaseValueRange::Range &x) {  // R1146
+  void Unparse(const CaseValueRange::Range &x) { // R1146
     Walk(x.lower), Put(':'), Walk(x.upper);
   }
-  void Unparse(const SelectRankStmt &x) {  // R1149
+  void Unparse(const SelectRankStmt &x) { // R1149
     Walk(std::get<0>(x.t), ": ");
     Word("SELECT RANK ("), Walk(std::get<1>(x.t), " => ");
     Walk(std::get<Selector>(x.t)), Put(')'), Indent();
   }
-  void Unparse(const SelectRankCaseStmt &x) {  // R1150
+  void Unparse(const SelectRankCaseStmt &x) { // R1150
     Outdent(), Word("RANK ");
-    std::visit(
-        common::visitors{
-            [&](const ScalarIntConstantExpr &y) {
-              Put('('), Walk(y), Put(')');
-            },
-            [&](const Star &) { Put("(*)"); },
-            [&](const Default &) { Word("DEFAULT"); },
-        },
+    std::visit(common::visitors{
+                   [&](const ScalarIntConstantExpr &y) {
+                     Put('('), Walk(y), Put(')');
+                   },
+                   [&](const Star &) { Put("(*)"); },
+                   [&](const Default &) { Word("DEFAULT"); },
+               },
         std::get<SelectRankCaseStmt::Rank>(x.t).u);
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
-  void Unparse(const SelectTypeStmt &x) {  // R1153
+  void Unparse(const SelectTypeStmt &x) { // R1153
     Walk(std::get<0>(x.t), ": ");
     Word("SELECT TYPE ("), Walk(std::get<1>(x.t), " => ");
     Walk(std::get<Selector>(x.t)), Put(')'), Indent();
   }
-  void Unparse(const TypeGuardStmt &x) {  // R1154
+  void Unparse(const TypeGuardStmt &x) { // R1154
     Outdent(), Walk(std::get<TypeGuardStmt::Guard>(x.t));
     Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
   }
@@ -1080,80 +1096,78 @@ public:
         },
         x.u);
   }
-  void Unparse(const ExitStmt &x) {  // R1156
+  void Unparse(const ExitStmt &x) { // R1156
     Word("EXIT"), Walk(" ", x.v);
   }
-  void Before(const GotoStmt &) {  // R1157
+  void Before(const GotoStmt &) { // R1157
     Word("GO TO ");
   }
-  void Unparse(const ComputedGotoStmt &x) {  // R1158
+  void Unparse(const ComputedGotoStmt &x) { // R1158
     Word("GO TO ("), Walk(x.t, "), ");
   }
-  void Unparse(const ContinueStmt &) {  // R1159
+  void Unparse(const ContinueStmt &) { // R1159
     Word("CONTINUE");
   }
-  void Unparse(const StopStmt &x) {  // R1160, R1161
+  void Unparse(const StopStmt &x) { // R1160, R1161
     if (std::get<StopStmt::Kind>(x.t) == StopStmt::Kind::ErrorStop) {
       Word("ERROR ");
     }
     Word("STOP"), Walk(" ", std::get<std::optional<StopCode>>(x.t));
     Walk(", QUIET=", std::get<std::optional<ScalarLogicalExpr>>(x.t));
   }
-  void Unparse(const FailImageStmt &) {  // R1163
+  void Unparse(const FailImageStmt &) { // R1163
     Word("FAIL IMAGE");
   }
-  void Unparse(const SyncAllStmt &x) {  // R1164
+  void Unparse(const SyncAllStmt &x) { // R1164
     Word("SYNC ALL ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const SyncImagesStmt &x) {  // R1166
+  void Unparse(const SyncImagesStmt &x) { // R1166
     Word("SYNC IMAGES (");
     Walk(std::get<SyncImagesStmt::ImageSet>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
-  void Unparse(const SyncMemoryStmt &x) {  // R1168
+  void Unparse(const SyncMemoryStmt &x) { // R1168
     Word("SYNC MEMORY ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const SyncTeamStmt &x) {  // R1169
+  void Unparse(const SyncTeamStmt &x) { // R1169
     Word("SYNC TEAM ("), Walk(std::get<TeamValue>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
-  void Unparse(const EventPostStmt &x) {  // R1170
+  void Unparse(const EventPostStmt &x) { // R1170
     Word("EVENT POST ("), Walk(std::get<EventVariable>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
   }
-  void Before(const EventWaitStmt::EventWaitSpec &x) {  // R1173, R1174
-    std::visit(
-        common::visitors{
-            [&](const ScalarIntExpr &) { Word("UNTIL_COUNT="); },
-            [](const StatOrErrmsg &) {},
-        },
+  void Before(const EventWaitStmt::EventWaitSpec &x) { // R1173, R1174
+    std::visit(common::visitors{
+                   [&](const ScalarIntExpr &) { Word("UNTIL_COUNT="); },
+                   [](const StatOrErrmsg &) {},
+               },
         x.u);
   }
-  void Unparse(const EventWaitStmt &x) {  // R1170
+  void Unparse(const EventWaitStmt &x) { // R1170
     Word("EVENT WAIT ("), Walk(std::get<EventVariable>(x.t));
     Walk(", ", std::get<std::list<EventWaitStmt::EventWaitSpec>>(x.t), ", ");
     Put(')');
   }
-  void Unparse(const FormTeamStmt &x) {  // R1175, R1177
+  void Unparse(const FormTeamStmt &x) { // R1175, R1177
     Word("FORM TEAM ("), Walk(std::get<ScalarIntExpr>(x.t));
     Put(','), Walk(std::get<TeamVariable>(x.t));
     Walk(", ", std::get<std::list<FormTeamStmt::FormTeamSpec>>(x.t), ", ");
     Put(')');
   }
-  void Before(const FormTeamStmt::FormTeamSpec &x) {  // R1176, R1178
-    std::visit(
-        common::visitors{
-            [&](const ScalarIntExpr &) { Word("NEW_INDEX="); },
-            [](const StatOrErrmsg &) {},
-        },
+  void Before(const FormTeamStmt::FormTeamSpec &x) { // R1176, R1178
+    std::visit(common::visitors{
+                   [&](const ScalarIntExpr &) { Word("NEW_INDEX="); },
+                   [](const StatOrErrmsg &) {},
+               },
         x.u);
   }
-  void Unparse(const LockStmt &x) {  // R1179
+  void Unparse(const LockStmt &x) { // R1179
     Word("LOCK ("), Walk(std::get<LockVariable>(x.t));
     Walk(", ", std::get<std::list<LockStmt::LockStat>>(x.t), ", ");
     Put(')');
   }
-  void Before(const LockStmt::LockStat &x) {  // R1180
+  void Before(const LockStmt::LockStat &x) { // R1180
     std::visit(
         common::visitors{
             [&](const ScalarLogicalVariable &) { Word("ACQUIRED_LOCK="); },
@@ -1161,72 +1175,70 @@ public:
         },
         x.u);
   }
-  void Unparse(const UnlockStmt &x) {  // R1181
+  void Unparse(const UnlockStmt &x) { // R1181
     Word("UNLOCK ("), Walk(std::get<LockVariable>(x.t));
     Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", ");
     Put(')');
   }
 
-  void Unparse(const OpenStmt &x) {  // R1204
+  void Unparse(const OpenStmt &x) { // R1204
     Word("OPEN ("), Walk(x.v, ", "), Put(')');
   }
-  bool Pre(const ConnectSpec &x) {  // R1205
-    return std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) {
-              Word("UNIT=");
-              return true;
-            },
-            [&](const FileNameExpr &) {
-              Word("FILE=");
-              return true;
-            },
-            [&](const ConnectSpec::CharExpr &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const MsgVariable &) {
-              Word("IOMSG=");
-              return true;
-            },
-            [&](const StatVariable &) {
-              Word("IOSTAT=");
-              return true;
-            },
-            [&](const ConnectSpec::Recl &) {
-              Word("RECL=");
-              return true;
-            },
-            [&](const ConnectSpec::Newunit &) {
-              Word("NEWUNIT=");
-              return true;
-            },
-            [&](const ErrLabel &) {
-              Word("ERR=");
-              return true;
-            },
-            [&](const StatusExpr &) {
-              Word("STATUS=");
-              return true;
-            },
-        },
+  bool Pre(const ConnectSpec &x) { // R1205
+    return std::visit(common::visitors{
+                          [&](const FileUnitNumber &) {
+                            Word("UNIT=");
+                            return true;
+                          },
+                          [&](const FileNameExpr &) {
+                            Word("FILE=");
+                            return true;
+                          },
+                          [&](const ConnectSpec::CharExpr &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const MsgVariable &) {
+                            Word("IOMSG=");
+                            return true;
+                          },
+                          [&](const StatVariable &) {
+                            Word("IOSTAT=");
+                            return true;
+                          },
+                          [&](const ConnectSpec::Recl &) {
+                            Word("RECL=");
+                            return true;
+                          },
+                          [&](const ConnectSpec::Newunit &) {
+                            Word("NEWUNIT=");
+                            return true;
+                          },
+                          [&](const ErrLabel &) {
+                            Word("ERR=");
+                            return true;
+                          },
+                          [&](const StatusExpr &) {
+                            Word("STATUS=");
+                            return true;
+                          },
+                      },
         x.u);
   }
-  void Unparse(const CloseStmt &x) {  // R1208
+  void Unparse(const CloseStmt &x) { // R1208
     Word("CLOSE ("), Walk(x.v, ", "), Put(')');
   }
-  void Before(const CloseStmt::CloseSpec &x) {  // R1209
-    std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) { Word("UNIT="); },
-            [&](const StatVariable &) { Word("IOSTAT="); },
-            [&](const MsgVariable &) { Word("IOMSG="); },
-            [&](const ErrLabel &) { Word("ERR="); },
-            [&](const StatusExpr &) { Word("STATUS="); },
-        },
+  void Before(const CloseStmt::CloseSpec &x) { // R1209
+    std::visit(common::visitors{
+                   [&](const FileUnitNumber &) { Word("UNIT="); },
+                   [&](const StatVariable &) { Word("IOSTAT="); },
+                   [&](const MsgVariable &) { Word("IOMSG="); },
+                   [&](const ErrLabel &) { Word("ERR="); },
+                   [&](const StatusExpr &) { Word("STATUS="); },
+               },
         x.u);
   }
-  void Unparse(const ReadStmt &x) {  // R1210
+  void Unparse(const ReadStmt &x) { // R1210
     Word("READ ");
     if (x.iounit) {
       Put('('), Walk(x.iounit);
@@ -1245,7 +1257,7 @@ public:
     }
     Walk(" ", x.items, ", ");
   }
-  void Unparse(const WriteStmt &x) {  // R1211
+  void Unparse(const WriteStmt &x) { // R1211
     Word("WRITE (");
     if (x.iounit) {
       Walk(x.iounit);
@@ -1258,119 +1270,116 @@ public:
     }
     Put(')'), Walk(" ", x.items, ", ");
   }
-  void Unparse(const PrintStmt &x) {  // R1212
+  void Unparse(const PrintStmt &x) { // R1212
     Word("PRINT "), Walk(std::get<Format>(x.t));
     Walk(", ", std::get<std::list<OutputItem>>(x.t), ", ");
   }
-  bool Pre(const IoControlSpec &x) {  // R1213
-    return std::visit(
-        common::visitors{
-            [&](const IoUnit &) {
-              Word("UNIT=");
-              return true;
-            },
-            [&](const Format &) {
-              Word("FMT=");
-              return true;
-            },
-            [&](const Name &) {
-              Word("NML=");
-              return true;
-            },
-            [&](const IoControlSpec::CharExpr &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const IoControlSpec::Asynchronous &) {
-              Word("ASYNCHRONOUS=");
-              return true;
-            },
-            [&](const EndLabel &) {
-              Word("END=");
-              return true;
-            },
-            [&](const EorLabel &) {
-              Word("EOR=");
-              return true;
-            },
-            [&](const ErrLabel &) {
-              Word("ERR=");
-              return true;
-            },
-            [&](const IdVariable &) {
-              Word("ID=");
-              return true;
-            },
-            [&](const MsgVariable &) {
-              Word("IOMSG=");
-              return true;
-            },
-            [&](const StatVariable &) {
-              Word("IOSTAT=");
-              return true;
-            },
-            [&](const IoControlSpec::Pos &) {
-              Word("POS=");
-              return true;
-            },
-            [&](const IoControlSpec::Rec &) {
-              Word("REC=");
-              return true;
-            },
-            [&](const IoControlSpec::Size &) {
-              Word("SIZE=");
-              return true;
-            },
-        },
+  bool Pre(const IoControlSpec &x) { // R1213
+    return std::visit(common::visitors{
+                          [&](const IoUnit &) {
+                            Word("UNIT=");
+                            return true;
+                          },
+                          [&](const Format &) {
+                            Word("FMT=");
+                            return true;
+                          },
+                          [&](const Name &) {
+                            Word("NML=");
+                            return true;
+                          },
+                          [&](const IoControlSpec::CharExpr &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const IoControlSpec::Asynchronous &) {
+                            Word("ASYNCHRONOUS=");
+                            return true;
+                          },
+                          [&](const EndLabel &) {
+                            Word("END=");
+                            return true;
+                          },
+                          [&](const EorLabel &) {
+                            Word("EOR=");
+                            return true;
+                          },
+                          [&](const ErrLabel &) {
+                            Word("ERR=");
+                            return true;
+                          },
+                          [&](const IdVariable &) {
+                            Word("ID=");
+                            return true;
+                          },
+                          [&](const MsgVariable &) {
+                            Word("IOMSG=");
+                            return true;
+                          },
+                          [&](const StatVariable &) {
+                            Word("IOSTAT=");
+                            return true;
+                          },
+                          [&](const IoControlSpec::Pos &) {
+                            Word("POS=");
+                            return true;
+                          },
+                          [&](const IoControlSpec::Rec &) {
+                            Word("REC=");
+                            return true;
+                          },
+                          [&](const IoControlSpec::Size &) {
+                            Word("SIZE=");
+                            return true;
+                          },
+                      },
         x.u);
   }
-  void Unparse(const InputImpliedDo &x) {  // R1218
+  void Unparse(const InputImpliedDo &x) { // R1218
     Put('('), Walk(std::get<std::list<InputItem>>(x.t), ", "), Put(", ");
     Walk(std::get<IoImpliedDoControl>(x.t)), Put(')');
   }
-  void Unparse(const OutputImpliedDo &x) {  // R1219
+  void Unparse(const OutputImpliedDo &x) { // R1219
     Put('('), Walk(std::get<std::list<OutputItem>>(x.t), ", "), Put(", ");
     Walk(std::get<IoImpliedDoControl>(x.t)), Put(')');
   }
-  void Unparse(const WaitStmt &x) {  // R1222
+  void Unparse(const WaitStmt &x) { // R1222
     Word("WAIT ("), Walk(x.v, ", "), Put(')');
   }
-  void Before(const WaitSpec &x) {  // R1223
-    std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) { Word("UNIT="); },
-            [&](const EndLabel &) { Word("END="); },
-            [&](const EorLabel &) { Word("EOR="); },
-            [&](const ErrLabel &) { Word("ERR="); },
-            [&](const IdExpr &) { Word("ID="); },
-            [&](const MsgVariable &) { Word("IOMSG="); },
-            [&](const StatVariable &) { Word("IOSTAT="); },
-        },
+  void Before(const WaitSpec &x) { // R1223
+    std::visit(common::visitors{
+                   [&](const FileUnitNumber &) { Word("UNIT="); },
+                   [&](const EndLabel &) { Word("END="); },
+                   [&](const EorLabel &) { Word("EOR="); },
+                   [&](const ErrLabel &) { Word("ERR="); },
+                   [&](const IdExpr &) { Word("ID="); },
+                   [&](const MsgVariable &) { Word("IOMSG="); },
+                   [&](const StatVariable &) { Word("IOSTAT="); },
+               },
         x.u);
   }
-  void Unparse(const BackspaceStmt &x) {  // R1224
+  void Unparse(const BackspaceStmt &x) { // R1224
     Word("BACKSPACE ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const EndfileStmt &x) {  // R1225
+  void Unparse(const EndfileStmt &x) { // R1225
     Word("ENDFILE ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const RewindStmt &x) {  // R1226
+  void Unparse(const RewindStmt &x) { // R1226
     Word("REWIND ("), Walk(x.v, ", "), Put(')');
   }
-  void Before(const PositionOrFlushSpec &x) {  // R1227 & R1229
-    std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) { Word("UNIT="); },
-            [&](const MsgVariable &) { Word("IOMSG="); },
-            [&](const StatVariable &) { Word("IOSTAT="); },
-            [&](const ErrLabel &) { Word("ERR="); },
-        },
+  void Before(const PositionOrFlushSpec &x) { // R1227 & R1229
+    std::visit(common::visitors{
+                   [&](const FileUnitNumber &) { Word("UNIT="); },
+                   [&](const MsgVariable &) { Word("IOMSG="); },
+                   [&](const StatVariable &) { Word("IOSTAT="); },
+                   [&](const ErrLabel &) { Word("ERR="); },
+               },
         x.u);
   }
-  void Unparse(const FlushStmt &x) {  // R1228
+  void Unparse(const FlushStmt &x) { // R1228
     Word("FLUSH ("), Walk(x.v, ", "), Put(')');
   }
-  void Unparse(const InquireStmt &x) {  // R1230
+  void Unparse(const InquireStmt &x) { // R1230
     Word("INQUIRE (");
     std::visit(
         common::visitors{
@@ -1381,67 +1390,67 @@ public:
         },
         x.u);
   }
-  bool Pre(const InquireSpec &x) {  // R1231
-    return std::visit(
-        common::visitors{
-            [&](const FileUnitNumber &) {
-              Word("UNIT=");
-              return true;
-            },
-            [&](const FileNameExpr &) {
-              Word("FILE=");
-              return true;
-            },
-            [&](const InquireSpec::CharVar &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const InquireSpec::IntVar &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const InquireSpec::LogVar &y) {
-              Walk(y.t, "=");
-              return false;
-            },
-            [&](const IdExpr &) {
-              Word("ID=");
-              return true;
-            },
-            [&](const ErrLabel &) {
-              Word("ERR=");
-              return true;
-            },
-        },
+  bool Pre(const InquireSpec &x) { // R1231
+    return std::visit(common::visitors{
+                          [&](const FileUnitNumber &) {
+                            Word("UNIT=");
+                            return true;
+                          },
+                          [&](const FileNameExpr &) {
+                            Word("FILE=");
+                            return true;
+                          },
+                          [&](const InquireSpec::CharVar &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const InquireSpec::IntVar &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const InquireSpec::LogVar &y) {
+                            Walk(y.t, "=");
+                            return false;
+                          },
+                          [&](const IdExpr &) {
+                            Word("ID=");
+                            return true;
+                          },
+                          [&](const ErrLabel &) {
+                            Word("ERR=");
+                            return true;
+                          },
+                      },
         x.u);
   }
 
-  void Before(const FormatStmt &) {  // R1301
+  void Before(const FormatStmt &) { // R1301
     Word("FORMAT");
   }
-  void Unparse(const format::FormatSpecification &x) {  // R1302, R1303, R1305
+  void Unparse(const format::FormatSpecification &x) { // R1302, R1303, R1305
     Put('('), Walk("", x.items, ",", x.unlimitedItems.empty() ? "" : ",");
     Walk("*(", x.unlimitedItems, ",", ")"), Put(')');
   }
-  void Unparse(const format::FormatItem &x) {  // R1304, R1306, R1321
+  void Unparse(const format::FormatItem &x) { // R1304, R1306, R1321
     if (x.repeatCount) {
       Walk(*x.repeatCount);
     }
-    std::visit(
-        common::visitors{
-            [&](const std::string &y) { PutNormalized(y); },
-            [&](const std::list<format::FormatItem> &y) {
-              Walk("(", y, ",", ")");
-            },
-            [&](const auto &y) { Walk(y); },
-        },
+    std::visit(common::visitors{
+                   [&](const std::string &y) { PutNormalized(y); },
+                   [&](const std::list<format::FormatItem> &y) {
+                     Walk("(", y, ",", ")");
+                   },
+                   [&](const auto &y) { Walk(y); },
+               },
         x.u);
   }
   void Unparse(
-      const format::IntrinsicTypeDataEditDesc &x) {  // R1307(1/2) - R1311
+      const format::IntrinsicTypeDataEditDesc &x) { // R1307(1/2) - R1311
     switch (x.kind) {
 #define FMT(x) \
-  case format::IntrinsicTypeDataEditDesc::Kind::x: Put(#x); break
+  case format::IntrinsicTypeDataEditDesc::Kind::x: \
+    Put(#x); \
+    break
       FMT(I);
       FMT(B);
       FMT(O);
@@ -1459,14 +1468,14 @@ public:
     }
     Walk(x.width), Walk(".", x.digits), Walk("E", x.exponentWidth);
   }
-  void Unparse(const format::DerivedTypeDataEditDesc &x) {  // R1307(2/2), R1312
+  void Unparse(const format::DerivedTypeDataEditDesc &x) { // R1307(2/2), R1312
     Word("DT");
     if (!x.type.empty()) {
       Put('"'), Put(x.type), Put('"');
     }
     Walk("(", x.parameters, ",", ")");
   }
-  void Unparse(const format::ControlEditDesc &x) {  // R1313, R1315-R1320
+  void Unparse(const format::ControlEditDesc &x) { // R1313, R1315-R1320
     switch (x.kind) {
     case format::ControlEditDesc::Kind::T:
       Word("T");
@@ -1492,13 +1501,17 @@ public:
       }
       Put('/');
       break;
-    case format::ControlEditDesc::Kind::Colon: Put(':'); break;
+    case format::ControlEditDesc::Kind::Colon:
+      Put(':');
+      break;
     case format::ControlEditDesc::Kind::P:
       Walk(x.count);
       Word("P");
       break;
 #define FMT(x) \
-  case format::ControlEditDesc::Kind::x: Put(#x); break
+  case format::ControlEditDesc::Kind::x: \
+    Put(#x); \
+    break
       FMT(SS);
       FMT(SP);
       FMT(S);
@@ -1513,78 +1526,79 @@ public:
       FMT(DC);
       FMT(DP);
 #undef FMT
-    case format::ControlEditDesc::Kind::Dollar: Put('$'); break;
-    case format::ControlEditDesc::Kind::Backslash: Put('\\'); break;
+    case format::ControlEditDesc::Kind::Dollar:
+      Put('$');
+      break;
+    case format::ControlEditDesc::Kind::Backslash:
+      Put('\\');
+      break;
     }
   }
 
-  void Before(const MainProgram &x) {  // R1401
+  void Before(const MainProgram &x) { // R1401
     if (!std::get<std::optional<Statement<ProgramStmt>>>(x.t)) {
       Indent();
     }
   }
-  void Before(const ProgramStmt &) {  // R1402
+  void Before(const ProgramStmt &) { // R1402
     Word("PROGRAM "), Indent();
   }
-  void Unparse(const EndProgramStmt &x) {  // R1403
+  void Unparse(const EndProgramStmt &x) { // R1403
     EndSubprogram("PROGRAM", x.v);
   }
-  void Before(const ModuleStmt &) {  // R1405
+  void Before(const ModuleStmt &) { // R1405
     Word("MODULE "), Indent();
   }
-  void Unparse(const EndModuleStmt &x) {  // R1406
+  void Unparse(const EndModuleStmt &x) { // R1406
     EndSubprogram("MODULE", x.v);
   }
-  void Unparse(const UseStmt &x) {  // R1409
+  void Unparse(const UseStmt &x) { // R1409
     Word("USE"), Walk(", ", x.nature), Put(" :: "), Walk(x.moduleName);
-    std::visit(
-        common::visitors{
-            [&](const std::list<Rename> &y) { Walk(", ", y, ", "); },
-            [&](const std::list<Only> &y) { Walk(", ONLY: ", y, ", "); },
-        },
+    std::visit(common::visitors{
+                   [&](const std::list<Rename> &y) { Walk(", ", y, ", "); },
+                   [&](const std::list<Only> &y) { Walk(", ONLY: ", y, ", "); },
+               },
         x.u);
   }
-  void Unparse(const Rename &x) {  // R1411
-    std::visit(
-        common::visitors{
-            [&](const Rename::Names &y) { Walk(y.t, " => "); },
-            [&](const Rename::Operators &y) {
-              Word("OPERATOR("), Walk(y.t, ") => OPERATOR("), Put(")");
-            },
-        },
+  void Unparse(const Rename &x) { // R1411
+    std::visit(common::visitors{
+                   [&](const Rename::Names &y) { Walk(y.t, " => "); },
+                   [&](const Rename::Operators &y) {
+                     Word("OPERATOR("), Walk(y.t, ") => OPERATOR("), Put(")");
+                   },
+               },
         x.u);
   }
-  void Unparse(const SubmoduleStmt &x) {  // R1417
+  void Unparse(const SubmoduleStmt &x) { // R1417
     Word("SUBMODULE ("), WalkTupleElements(x.t, ")"), Indent();
   }
-  void Unparse(const ParentIdentifier &x) {  // R1418
+  void Unparse(const ParentIdentifier &x) { // R1418
     Walk(std::get<Name>(x.t)), Walk(":", std::get<std::optional<Name>>(x.t));
   }
-  void Unparse(const EndSubmoduleStmt &x) {  // R1419
+  void Unparse(const EndSubmoduleStmt &x) { // R1419
     EndSubprogram("SUBMODULE", x.v);
   }
-  void Unparse(const BlockDataStmt &x) {  // R1421
+  void Unparse(const BlockDataStmt &x) { // R1421
     Word("BLOCK DATA"), Walk(" ", x.v), Indent();
   }
-  void Unparse(const EndBlockDataStmt &x) {  // R1422
+  void Unparse(const EndBlockDataStmt &x) { // R1422
     EndSubprogram("BLOCK DATA", x.v);
   }
 
-  void Unparse(const InterfaceStmt &x) {  // R1503
-    std::visit(
-        common::visitors{
-            [&](const std::optional<GenericSpec> &y) {
-              Word("INTERFACE"), Walk(" ", y);
-            },
-            [&](const Abstract &) { Word("ABSTRACT INTERFACE"); },
-        },
+  void Unparse(const InterfaceStmt &x) { // R1503
+    std::visit(common::visitors{
+                   [&](const std::optional<GenericSpec> &y) {
+                     Word("INTERFACE"), Walk(" ", y);
+                   },
+                   [&](const Abstract &) { Word("ABSTRACT INTERFACE"); },
+               },
         x.u);
     Indent();
   }
-  void Unparse(const EndInterfaceStmt &x) {  // R1504
+  void Unparse(const EndInterfaceStmt &x) { // R1504
     Outdent(), Word("END INTERFACE"), Walk(" ", x.v);
   }
-  void Unparse(const ProcedureStmt &x) {  // R1506
+  void Unparse(const ProcedureStmt &x) { // R1506
     if (std::get<ProcedureStmt::Kind>(x.t) ==
         ProcedureStmt::Kind::ModuleProcedure) {
       Word("MODULE ");
@@ -1592,7 +1606,7 @@ public:
     Word("PROCEDURE :: ");
     Walk(std::get<std::list<Name>>(x.t), ", ");
   }
-  void Before(const GenericSpec &x) {  // R1508, R1509
+  void Before(const GenericSpec &x) { // R1508, R1509
     std::visit(
         common::visitors{
             [&](const DefinedOperator &) { Word("OPERATOR("); },
@@ -1614,38 +1628,37 @@ public:
         x.u);
   }
   void Post(const GenericSpec &x) {
-    std::visit(
-        common::visitors{
-            [&](const DefinedOperator &) { Put(')'); },
-            [](const auto &) {},
-        },
+    std::visit(common::visitors{
+                   [&](const DefinedOperator &) { Put(')'); },
+                   [](const auto &) {},
+               },
         x.u);
   }
-  void Unparse(const GenericStmt &x) {  // R1510
+  void Unparse(const GenericStmt &x) { // R1510
     Word("GENERIC"), Walk(", ", std::get<std::optional<AccessSpec>>(x.t));
     Put(" :: "), Walk(std::get<GenericSpec>(x.t)), Put(" => ");
     Walk(std::get<std::list<Name>>(x.t), ", ");
   }
-  void Unparse(const ExternalStmt &x) {  // R1511
+  void Unparse(const ExternalStmt &x) { // R1511
     Word("EXTERNAL :: "), Walk(x.v, ", ");
   }
-  void Unparse(const ProcedureDeclarationStmt &x) {  // R1512
+  void Unparse(const ProcedureDeclarationStmt &x) { // R1512
     Word("PROCEDURE("), Walk(std::get<std::optional<ProcInterface>>(x.t));
     Put(')'), Walk(", ", std::get<std::list<ProcAttrSpec>>(x.t), ", ");
     Put(" :: "), Walk(std::get<std::list<ProcDecl>>(x.t), ", ");
   }
-  void Unparse(const ProcDecl &x) {  // R1515
+  void Unparse(const ProcDecl &x) { // R1515
     Walk(std::get<Name>(x.t));
     Walk(" => ", std::get<std::optional<ProcPointerInit>>(x.t));
   }
-  void Unparse(const IntrinsicStmt &x) {  // R1519
+  void Unparse(const IntrinsicStmt &x) { // R1519
     Word("INTRINSIC :: "), Walk(x.v, ", ");
   }
-  void Unparse(const FunctionReference &x) {  // R1520
+  void Unparse(const FunctionReference &x) { // R1520
     Walk(std::get<ProcedureDesignator>(x.v.t));
     Put('('), Walk(std::get<std::list<ActualArgSpec>>(x.v.t), ", "), Put(')');
   }
-  void Unparse(const CallStmt &x) {  // R1521
+  void Unparse(const CallStmt &x) { // R1521
     if (asFortran_ && x.typedCall.get()) {
       Put(' ');
       asFortran_->call(out_, *x.typedCall);
@@ -1656,39 +1669,39 @@ public:
       Word("CALL "), Walk(pd);
       if (args.empty()) {
         if (std::holds_alternative<ProcComponentRef>(pd.u)) {
-          Put("()");  // pgf90 crashes on CALL to tbp without parentheses
+          Put("()"); // pgf90 crashes on CALL to tbp without parentheses
         }
       } else {
         Walk("(", args, ", ", ")");
       }
     }
   }
-  void Unparse(const ActualArgSpec &x) {  // R1523
+  void Unparse(const ActualArgSpec &x) { // R1523
     Walk(std::get<std::optional<Keyword>>(x.t), "=");
     Walk(std::get<ActualArg>(x.t));
   }
-  void Unparse(const ActualArg::PercentRef &x) {  // R1524
+  void Unparse(const ActualArg::PercentRef &x) { // R1524
     Word("%REF("), Walk(x.v), Put(')');
   }
   void Unparse(const ActualArg::PercentVal &x) {
     Word("%VAL("), Walk(x.v), Put(')');
   }
-  void Before(const AltReturnSpec &) {  // R1525
+  void Before(const AltReturnSpec &) { // R1525
     Put('*');
   }
-  void Post(const PrefixSpec::Elemental) { Word("ELEMENTAL"); }  // R1527
+  void Post(const PrefixSpec::Elemental) { Word("ELEMENTAL"); } // R1527
   void Post(const PrefixSpec::Impure) { Word("IMPURE"); }
   void Post(const PrefixSpec::Module) { Word("MODULE"); }
   void Post(const PrefixSpec::Non_Recursive) { Word("NON_RECURSIVE"); }
   void Post(const PrefixSpec::Pure) { Word("PURE"); }
   void Post(const PrefixSpec::Recursive) { Word("RECURSIVE"); }
-  void Unparse(const FunctionStmt &x) {  // R1530
+  void Unparse(const FunctionStmt &x) { // R1530
     Walk("", std::get<std::list<PrefixSpec>>(x.t), " ", " ");
     Word("FUNCTION "), Walk(std::get<Name>(x.t)), Put("(");
     Walk(std::get<std::list<Name>>(x.t), ", "), Put(')');
     Walk(" ", std::get<std::optional<Suffix>>(x.t)), Indent();
   }
-  void Unparse(const Suffix &x) {  // R1532
+  void Unparse(const Suffix &x) { // R1532
     if (x.resultName) {
       Word("RESULT("), Walk(x.resultName), Put(')');
       Walk(" ", x.binding);
@@ -1696,10 +1709,10 @@ public:
       Walk(x.binding);
     }
   }
-  void Unparse(const EndFunctionStmt &x) {  // R1533
+  void Unparse(const EndFunctionStmt &x) { // R1533
     EndSubprogram("FUNCTION", x.v);
   }
-  void Unparse(const SubroutineStmt &x) {  // R1535
+  void Unparse(const SubroutineStmt &x) { // R1535
     Walk("", std::get<std::list<PrefixSpec>>(x.t), " ", " ");
     Word("SUBROUTINE "), Walk(std::get<Name>(x.t));
     const auto &args{std::get<std::list<DummyArg>>(x.t)};
@@ -1712,29 +1725,29 @@ public:
     }
     Indent();
   }
-  void Unparse(const EndSubroutineStmt &x) {  // R1537
+  void Unparse(const EndSubroutineStmt &x) { // R1537
     EndSubprogram("SUBROUTINE", x.v);
   }
-  void Before(const MpSubprogramStmt &) {  // R1539
+  void Before(const MpSubprogramStmt &) { // R1539
     Word("MODULE PROCEDURE "), Indent();
   }
-  void Unparse(const EndMpSubprogramStmt &x) {  // R1540
+  void Unparse(const EndMpSubprogramStmt &x) { // R1540
     EndSubprogram("PROCEDURE", x.v);
   }
-  void Unparse(const EntryStmt &x) {  // R1541
+  void Unparse(const EntryStmt &x) { // R1541
     Word("ENTRY "), Walk(std::get<Name>(x.t)), Put("(");
     Walk(std::get<std::list<DummyArg>>(x.t), ", "), Put(")");
     Walk(" ", std::get<std::optional<Suffix>>(x.t));
   }
-  void Unparse(const ReturnStmt &x) {  // R1542
+  void Unparse(const ReturnStmt &x) { // R1542
     Word("RETURN"), Walk(" ", x.v);
   }
-  void Unparse(const ContainsStmt &) {  // R1543
+  void Unparse(const ContainsStmt &) { // R1543
     Outdent();
     Word("CONTAINS");
     Indent();
   }
-  void Unparse(const StmtFunctionStmt &x) {  // R1544
+  void Unparse(const StmtFunctionStmt &x) { // R1544
     Walk(std::get<Name>(x.t)), Put('(');
     Walk(std::get<std::list<Name>>(x.t), ", "), Put(") = ");
     Walk(std::get<Scalar<Expr>>(x.t));
@@ -1745,7 +1758,7 @@ public:
     std::visit(
         common::visitors{
             [&](const std::list<CompilerDirective::IgnoreTKR> &tkr) {
-              Word("!DIR$ IGNORE_TKR");  // emitted even if tkr list is empty
+              Word("!DIR$ IGNORE_TKR"); // emitted even if tkr list is empty
               Walk(" ", tkr, ", ");
             },
             [&](const std::list<Name> &names) { Walk("!DIR$ ", names, " "); },
@@ -1766,11 +1779,10 @@ public:
   }
   // OpenMP Clauses & Directives
   void Unparse(const OmpObject &x) {
-    std::visit(
-        common::visitors{
-            [&](const Designator &y) { Walk(y); },
-            [&](const Name &y) { Put("/"), Walk(y), Put("/"); },
-        },
+    std::visit(common::visitors{
+                   [&](const Designator &y) { Walk(y); },
+                   [&](const Name &y) { Put("/"), Walk(y), Put("/"); },
+               },
         x.u);
   }
   void Unparse(const OmpMapType::Always &) { Word("ALWAYS,"); }
@@ -1836,23 +1848,22 @@ public:
     Put(")");
   }
   bool Pre(const OmpDependClause &x) {
-    return std::visit(
-        common::visitors{
-            [&](const OmpDependClause::Source &) {
-              Word("DEPEND(SOURCE)");
-              return false;
-            },
-            [&](const OmpDependClause::Sink &y) {
-              Word("DEPEND(SINK:");
-              Walk(y.v);
-              Put(")");
-              return false;
-            },
-            [&](const OmpDependClause::InOut &) {
-              Word("DEPEND");
-              return true;
-            },
-        },
+    return std::visit(common::visitors{
+                          [&](const OmpDependClause::Source &) {
+                            Word("DEPEND(SOURCE)");
+                            return false;
+                          },
+                          [&](const OmpDependClause::Sink &y) {
+                            Word("DEPEND(SINK:");
+                            Walk(y.v);
+                            Put(")");
+                            return false;
+                          },
+                          [&](const OmpDependClause::InOut &) {
+                            Word("DEPEND");
+                            return true;
+                          },
+                      },
         x.u);
   }
   bool Pre(const OmpDefaultClause &) {
@@ -2006,7 +2017,9 @@ public:
   }
   void Unparse(const OmpLoopDirective &x) {
     switch (x.v) {
-    case OmpLoopDirective::Directive::Distribute: Word("DISTRIBUTE "); break;
+    case OmpLoopDirective::Directive::Distribute:
+      Word("DISTRIBUTE ");
+      break;
     case OmpLoopDirective::Directive::DistributeParallelDo:
       Word("DISTRIBUTE PARALLEL DO ");
       break;
@@ -2016,13 +2029,21 @@ public:
     case OmpLoopDirective::Directive::DistributeSimd:
       Word("DISTRIBUTE SIMD ");
       break;
-    case OmpLoopDirective::Directive::Do: Word("DO "); break;
-    case OmpLoopDirective::Directive::DoSimd: Word("Do SIMD "); break;
-    case OmpLoopDirective::Directive::ParallelDo: Word("PARALLEL DO "); break;
+    case OmpLoopDirective::Directive::Do:
+      Word("DO ");
+      break;
+    case OmpLoopDirective::Directive::DoSimd:
+      Word("Do SIMD ");
+      break;
+    case OmpLoopDirective::Directive::ParallelDo:
+      Word("PARALLEL DO ");
+      break;
     case OmpLoopDirective::Directive::ParallelDoSimd:
       Word("PARALLEL DO SIMD ");
       break;
-    case OmpLoopDirective::Directive::Simd: Word("SIMD "); break;
+    case OmpLoopDirective::Directive::Simd:
+      Word("SIMD ");
+      break;
     case OmpLoopDirective::Directive::TargetParallelDo:
       Word("TARGET PARALLEL DO ");
       break;
@@ -2041,8 +2062,12 @@ public:
     case OmpLoopDirective::Directive::TargetTeamsDistributeSimd:
       Word("TARGET TEAMS DISTRIBUTE SIMD ");
       break;
-    case OmpLoopDirective::Directive::TargetSimd: Word("TARGET SIMD "); break;
-    case OmpLoopDirective::Directive::Taskloop: Word("TASKLOOP "); break;
+    case OmpLoopDirective::Directive::TargetSimd:
+      Word("TARGET SIMD ");
+      break;
+    case OmpLoopDirective::Directive::Taskloop:
+      Word("TASKLOOP ");
+      break;
     case OmpLoopDirective::Directive::TaskloopSimd:
       Word("TASKLOOP SIMD ");
       break;
@@ -2088,30 +2113,52 @@ public:
   }
   void Unparse(const OmpBlockDirective &x) {
     switch (x.v) {
-    case OmpBlockDirective::Directive::Master: Word("MASTER"); break;
-    case OmpBlockDirective::Directive::Ordered: Word("ORDERED "); break;
+    case OmpBlockDirective::Directive::Master:
+      Word("MASTER");
+      break;
+    case OmpBlockDirective::Directive::Ordered:
+      Word("ORDERED ");
+      break;
     case OmpBlockDirective::Directive::ParallelWorkshare:
       Word("PARALLEL WORKSHARE ");
       break;
-    case OmpBlockDirective::Directive::Parallel: Word("PARALLEL "); break;
-    case OmpBlockDirective::Directive::Single: Word("SINGLE "); break;
-    case OmpBlockDirective::Directive::TargetData: Word("TARGET DATA "); break;
+    case OmpBlockDirective::Directive::Parallel:
+      Word("PARALLEL ");
+      break;
+    case OmpBlockDirective::Directive::Single:
+      Word("SINGLE ");
+      break;
+    case OmpBlockDirective::Directive::TargetData:
+      Word("TARGET DATA ");
+      break;
     case OmpBlockDirective::Directive::TargetParallel:
       Word("TARGET PARALLEL ");
       break;
     case OmpBlockDirective::Directive::TargetTeams:
       Word("TARGET TEAMS ");
       break;
-    case OmpBlockDirective::Directive::Target: Word("TARGET "); break;
-    case OmpBlockDirective::Directive::Taskgroup: Word("TASKGROUP "); break;
-    case OmpBlockDirective::Directive::Task: Word("TASK "); break;
-    case OmpBlockDirective::Directive::Teams: Word("TEAMS "); break;
-    case OmpBlockDirective::Directive::Workshare: Word("WORKSHARE "); break;
+    case OmpBlockDirective::Directive::Target:
+      Word("TARGET ");
+      break;
+    case OmpBlockDirective::Directive::Taskgroup:
+      Word("TASKGROUP ");
+      break;
+    case OmpBlockDirective::Directive::Task:
+      Word("TASK ");
+      break;
+    case OmpBlockDirective::Directive::Teams:
+      Word("TEAMS ");
+      break;
+    case OmpBlockDirective::Directive::Workshare:
+      Word("WORKSHARE ");
+      break;
     }
   }
   void Unparse(const OmpMemoryClause &x) {
     switch (x.v) {
-    case OmpMemoryClause::MemoryOrder::SeqCst: Word("SEQ_CST"); break;
+    case OmpMemoryClause::MemoryOrder::SeqCst:
+      Word("SEQ_CST");
+      break;
     }
   }
   void Unparse(const OmpMemoryClauseList &x) { Walk(" ", x.v, " "); }
@@ -2233,29 +2280,28 @@ public:
   bool Pre(const OpenMPDeclarativeConstruct &x) {
     BeginOpenMP();
     Word("!$OMP ");
-    return std::visit(
-        common::visitors{
-            [&](const OpenMPDeclareReductionConstruct &) {
-              Word("DECLARE REDUCTION ");
-              return true;
-            },
-            [&](const OpenMPDeclareSimdConstruct &y) {
-              Word("DECLARE SIMD ");
-              Walk("(", std::get<std::optional<Name>>(y.t), ")");
-              Walk(std::get<OmpClauseList>(y.t));
-              Put("\n");
-              EndOpenMP();
-              return false;
-            },
-            [&](const OpenMPDeclareTargetConstruct &) {
-              Word("DECLARE TARGET ");
-              return true;
-            },
-            [&](const OpenMPThreadprivate &) {
-              Word("THREADPRIVATE (");
-              return true;
-            },
-        },
+    return std::visit(common::visitors{
+                          [&](const OpenMPDeclareReductionConstruct &) {
+                            Word("DECLARE REDUCTION ");
+                            return true;
+                          },
+                          [&](const OpenMPDeclareSimdConstruct &y) {
+                            Word("DECLARE SIMD ");
+                            Walk("(", std::get<std::optional<Name>>(y.t), ")");
+                            Walk(std::get<OmpClauseList>(y.t));
+                            Put("\n");
+                            EndOpenMP();
+                            return false;
+                          },
+                          [&](const OpenMPDeclareTargetConstruct &) {
+                            Word("DECLARE TARGET ");
+                            return true;
+                          },
+                          [&](const OpenMPThreadprivate &) {
+                            Word("THREADPRIVATE (");
+                            return true;
+                          },
+                      },
         x.u);
   }
   void Post(const OpenMPDeclarativeConstruct &) {
@@ -2268,7 +2314,9 @@ public:
   }
   void Unparse(const OmpSectionsDirective &x) {
     switch (x.v) {
-    case OmpSectionsDirective::Directive::Sections: Word("SECTIONS "); break;
+    case OmpSectionsDirective::Directive::Sections:
+      Word("SECTIONS ");
+      break;
     case OmpSectionsDirective::Directive::ParallelSections:
       Word("PARALLEL SECTIONS ");
       break;
@@ -2280,7 +2328,7 @@ public:
       Word("!$OMP SECTION");
       Put("\n");
       EndOpenMP();
-      Walk(y, "");  // y is Block
+      Walk(y, ""); // y is Block
     }
   }
   void Unparse(const OpenMPSectionsConstruct &x) {
@@ -2372,7 +2420,7 @@ public:
   }
   void Unparse(const StructureStmt &x) {
     Word("STRUCTURE ");
-    if (std::get<bool>(x.t)) {  // slashes around name
+    if (std::get<bool>(x.t)) { // slashes around name
       Put('/'), Walk(std::get<Name>(x.t)), Put('/');
       Walk(" ", std::get<std::list<EntityDecl>>(x.t), ", ");
     } else {
@@ -2409,29 +2457,28 @@ public:
 
 #define WALK_NESTED_ENUM(CLASS, ENUM) \
   void Unparse(const CLASS::ENUM &x) { Word(CLASS::EnumToString(x)); }
-  WALK_NESTED_ENUM(AccessSpec, Kind)  // R807
-  WALK_NESTED_ENUM(common, TypeParamAttr)  // R734
-  WALK_NESTED_ENUM(IntentSpec, Intent)  // R826
-  WALK_NESTED_ENUM(ImplicitStmt, ImplicitNoneNameSpec)  // R866
-  WALK_NESTED_ENUM(ConnectSpec::CharExpr, Kind)  // R1205
+  WALK_NESTED_ENUM(AccessSpec, Kind) // R807
+  WALK_NESTED_ENUM(common, TypeParamAttr) // R734
+  WALK_NESTED_ENUM(IntentSpec, Intent) // R826
+  WALK_NESTED_ENUM(ImplicitStmt, ImplicitNoneNameSpec) // R866
+  WALK_NESTED_ENUM(ConnectSpec::CharExpr, Kind) // R1205
   WALK_NESTED_ENUM(IoControlSpec::CharExpr, Kind)
   WALK_NESTED_ENUM(InquireSpec::CharVar, Kind)
   WALK_NESTED_ENUM(InquireSpec::IntVar, Kind)
   WALK_NESTED_ENUM(InquireSpec::LogVar, Kind)
-  WALK_NESTED_ENUM(ProcedureStmt, Kind)  // R1506
-  WALK_NESTED_ENUM(UseStmt, ModuleNature)  // R1410
-  WALK_NESTED_ENUM(OmpProcBindClause, Type)  // OMP PROC_BIND
-  WALK_NESTED_ENUM(OmpDefaultClause, Type)  // OMP DEFAULT
-  WALK_NESTED_ENUM(OmpDefaultmapClause, ImplicitBehavior)  // OMP DEFAULTMAP
-  WALK_NESTED_ENUM(OmpDefaultmapClause, VariableCategory)  // OMP DEFAULTMAP
-  WALK_NESTED_ENUM(OmpScheduleModifierType, ModType)  // OMP schedule-modifier
-  WALK_NESTED_ENUM(OmpLinearModifier, Type)  // OMP linear-modifier
-  WALK_NESTED_ENUM(OmpDependenceType, Type)  // OMP dependence-type
-  WALK_NESTED_ENUM(OmpMapType, Type)  // OMP map-type
-  WALK_NESTED_ENUM(OmpScheduleClause, ScheduleType)  // OMP schedule-type
-  WALK_NESTED_ENUM(
-      OmpIfClause, DirectiveNameModifier)  // OMP directive-modifier
-  WALK_NESTED_ENUM(OmpCancelType, Type)  // OMP cancel-type
+  WALK_NESTED_ENUM(ProcedureStmt, Kind) // R1506
+  WALK_NESTED_ENUM(UseStmt, ModuleNature) // R1410
+  WALK_NESTED_ENUM(OmpProcBindClause, Type) // OMP PROC_BIND
+  WALK_NESTED_ENUM(OmpDefaultClause, Type) // OMP DEFAULT
+  WALK_NESTED_ENUM(OmpDefaultmapClause, ImplicitBehavior) // OMP DEFAULTMAP
+  WALK_NESTED_ENUM(OmpDefaultmapClause, VariableCategory) // OMP DEFAULTMAP
+  WALK_NESTED_ENUM(OmpScheduleModifierType, ModType) // OMP schedule-modifier
+  WALK_NESTED_ENUM(OmpLinearModifier, Type) // OMP linear-modifier
+  WALK_NESTED_ENUM(OmpDependenceType, Type) // OMP dependence-type
+  WALK_NESTED_ENUM(OmpMapType, Type) // OMP map-type
+  WALK_NESTED_ENUM(OmpScheduleClause, ScheduleType) // OMP schedule-type
+  WALK_NESTED_ENUM(OmpIfClause, DirectiveNameModifier) // OMP directive-modifier
+  WALK_NESTED_ENUM(OmpCancelType, Type) // OMP cancel-type
 #undef WALK_NESTED_ENUM
 
   void Done() const { CHECK(indent_ == 0); }
@@ -2453,27 +2500,27 @@ private:
   void EndOpenMP() { openmpDirective_ = false; }
 
   // Call back to the traversal framework.
-  template<typename T> void Walk(const T &x) {
+  template <typename T> void Walk(const T &x) {
     Fortran::parser::Walk(x, *this);
   }
 
   // Traverse a std::optional<> value.  Emit a prefix and/or a suffix string
   // only when it contains a value.
-  template<typename A>
+  template <typename A>
   void Walk(
       const char *prefix, const std::optional<A> &x, const char *suffix = "") {
     if (x) {
       Word(prefix), Walk(*x), Word(suffix);
     }
   }
-  template<typename A>
+  template <typename A>
   void Walk(const std::optional<A> &x, const char *suffix = "") {
     return Walk("", x, suffix);
   }
 
   // Traverse a std::list<>.  Separate the elements with an optional string.
   // Emit a prefix and/or a suffix string only when the list is not empty.
-  template<typename A>
+  template <typename A>
   void Walk(const char *prefix, const std::list<A> &list,
       const char *comma = ", ", const char *suffix = "") {
     if (!list.empty()) {
@@ -2485,24 +2532,24 @@ private:
       Word(suffix);
     }
   }
-  template<typename A>
+  template <typename A>
   void Walk(const std::list<A> &list, const char *comma = ", ",
       const char *suffix = "") {
     return Walk("", list, comma, suffix);
   }
 
   // Traverse a std::tuple<>, with an optional separator.
-  template<std::size_t J = 0, typename T>
+  template <std::size_t J = 0, typename T>
   void WalkTupleElements(const T &tuple, const char *separator) {
     if (J > 0 && J < std::tuple_size_v<T>) {
-      Word(separator);  // this usage dodges "unused parameter" warning
+      Word(separator); // this usage dodges "unused parameter" warning
     }
     if constexpr (J < std::tuple_size_v<T>) {
       Walk(std::get<J>(tuple));
       WalkTupleElements<J + 1>(tuple, separator);
     }
   }
-  template<typename... A>
+  template <typename... A>
   void Walk(const std::tuple<A...> &tuple, const char *separator = "") {
     WalkTupleElements(tuple, separator);
   }
@@ -2602,4 +2649,4 @@ void Unparse(llvm::raw_ostream &out, const Program &program, Encoding encoding,
   Walk(program, visitor);
   visitor.Done();
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Parser/user-state.cpp b/flang/lib/Parser/user-state.cpp
index 1140d40214eb..f0bc36cb6bdc 100644
--- a/flang/lib/Parser/user-state.cpp
+++ b/flang/lib/Parser/user-state.cpp
@@ -87,4 +87,4 @@ std::optional<DataComponentDefStmt> StructureComponents::Parse(
   }
   return defs;
 }
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Semantics/assignment.h b/flang/lib/Semantics/assignment.h
index ab8b4bfca1a5..65345ab7912a 100644
--- a/flang/lib/Semantics/assignment.h
+++ b/flang/lib/Semantics/assignment.h
@@ -21,7 +21,7 @@ struct MaskedElsewhereStmt;
 struct PointerAssignmentStmt;
 struct WhereConstructStmt;
 struct WhereStmt;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -53,8 +53,8 @@ private:
   common::Indirection<AssignmentContext> context_;
 };
 
-}
+} // namespace Fortran::semantics
 
 extern template class Fortran::common::Indirection<
     Fortran::semantics::AssignmentContext>;
-#endif  // FORTRAN_SEMANTICS_ASSIGNMENT_H_
+#endif // FORTRAN_SEMANTICS_ASSIGNMENT_H_
diff --git a/flang/lib/Semantics/attr.cpp b/flang/lib/Semantics/attr.cpp
index e041a8f511c3..b9b0f327352d 100644
--- a/flang/lib/Semantics/attr.cpp
+++ b/flang/lib/Semantics/attr.cpp
@@ -21,11 +21,16 @@ void Attrs::CheckValid(const Attrs &allowed) const {
 
 std::string AttrToString(Attr attr) {
   switch (attr) {
-  case Attr::BIND_C: return "BIND(C)";
-  case Attr::INTENT_IN: return "INTENT(IN)";
-  case Attr::INTENT_INOUT: return "INTENT(INOUT)";
-  case Attr::INTENT_OUT: return "INTENT(OUT)";
-  default: return EnumToString(attr);
+  case Attr::BIND_C:
+    return "BIND(C)";
+  case Attr::INTENT_IN:
+    return "INTENT(IN)";
+  case Attr::INTENT_INOUT:
+    return "INTENT(INOUT)";
+  case Attr::INTENT_OUT:
+    return "INTENT(OUT)";
+  default:
+    return EnumToString(attr);
   }
 }
 
@@ -48,4 +53,4 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const Attrs &attrs) {
   }
   return o;
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/canonicalize-do.cpp b/flang/lib/Semantics/canonicalize-do.cpp
index b50c0ff974af..8d27d6344423 100644
--- a/flang/lib/Semantics/canonicalize-do.cpp
+++ b/flang/lib/Semantics/canonicalize-do.cpp
@@ -18,8 +18,8 @@ class CanonicalizationOfDoLoops {
   };
 
 public:
-  template<typename T> bool Pre(T &) { return true; }
-  template<typename T> void Post(T &) {}
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
   void Post(Block &block) {
     std::vector<LabelInfo> stack;
     for (auto i{block.begin()}, end{block.end()}; i != end; ++i) {
@@ -30,62 +30,58 @@ public:
                 // Labels on end-stmt of constructs are accepted by f18 as an
                 // extension.
                 [&](common::Indirection<AssociateConstruct> &associate) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndAssociateStmt>>(
-                          associate.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndAssociateStmt>>(associate.value().t));
                 },
                 [&](common::Indirection<BlockConstruct> &blockConstruct) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndBlockStmt>>(
-                          blockConstruct.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndBlockStmt>>(blockConstruct.value().t));
                 },
                 [&](common::Indirection<ChangeTeamConstruct> &changeTeam) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndChangeTeamStmt>>(
-                          changeTeam.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndChangeTeamStmt>>(changeTeam.value().t));
                 },
                 [&](common::Indirection<CriticalConstruct> &critical) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndCriticalStmt>>(critical.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndCriticalStmt>>(critical.value().t));
                 },
                 [&](common::Indirection<DoConstruct> &doConstruct) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndDoStmt>>(doConstruct.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndDoStmt>>(doConstruct.value().t));
                 },
                 [&](common::Indirection<IfConstruct> &ifConstruct) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndIfStmt>>(ifConstruct.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndIfStmt>>(ifConstruct.value().t));
                 },
                 [&](common::Indirection<CaseConstruct> &caseConstruct) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndSelectStmt>>(
-                          caseConstruct.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndSelectStmt>>(caseConstruct.value().t));
                 },
                 [&](common::Indirection<SelectRankConstruct> &selectRank) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndSelectStmt>>(selectRank.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndSelectStmt>>(selectRank.value().t));
                 },
                 [&](common::Indirection<SelectTypeConstruct> &selectType) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndSelectStmt>>(selectType.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndSelectStmt>>(selectType.value().t));
                 },
                 [&](common::Indirection<ForallConstruct> &forall) {
-                  CanonicalizeIfMatch(block, stack, i,
-                      std::get<Statement<EndForallStmt>>(forall.value().t));
+          CanonicalizeIfMatch(block, stack, i,
+              std::get<Statement<EndForallStmt>>(forall.value().t));
                 },
                 [&](common::Indirection<WhereConstruct> &where) {
                   CanonicalizeIfMatch(block, stack, i,
                       std::get<Statement<EndWhereStmt>>(where.value().t));
                 },
                 [&](Statement<common::Indirection<LabelDoStmt>> &labelDoStmt) {
-                  auto &label{std::get<Label>(labelDoStmt.statement.value().t)};
-                  stack.push_back(LabelInfo{i, label});
+          auto &label{std::get<Label>(labelDoStmt.statement.value().t)};
+          stack.push_back(LabelInfo{i, label});
                 },
                 [&](Statement<common::Indirection<EndDoStmt>> &endDoStmt) {
-                  CanonicalizeIfMatch(block, stack, i, endDoStmt);
+          CanonicalizeIfMatch(block, stack, i, endDoStmt);
                 },
                 [&](Statement<ActionStmt> &actionStmt) {
-                  CanonicalizeIfMatch(block, stack, i, actionStmt);
+          CanonicalizeIfMatch(block, stack, i, actionStmt);
                 },
             },
             executableConstruct->u);
@@ -94,7 +90,7 @@ public:
   }
 
 private:
-  template<typename T>
+  template <typename T>
   void CanonicalizeIfMatch(Block &originalBlock, std::vector<LabelInfo> &stack,
       Block::iterator &i, Statement<T> &statement) {
     if (!stack.empty() && statement.label &&
@@ -140,4 +136,4 @@ bool CanonicalizeDo(Program &program) {
   return true;
 }
 
-}
+} // namespace Fortran::parser
diff --git a/flang/lib/Semantics/canonicalize-do.h b/flang/lib/Semantics/canonicalize-do.h
index 9de5b52c5ed8..bbdad8cedc23 100644
--- a/flang/lib/Semantics/canonicalize-do.h
+++ b/flang/lib/Semantics/canonicalize-do.h
@@ -14,6 +14,6 @@
 namespace Fortran::parser {
 struct Program;
 bool CanonicalizeDo(Program &program);
-}
+} // namespace Fortran::parser
 
-#endif  // FORTRAN_SEMANTICS_CANONICALIZE_DO_H_
+#endif // FORTRAN_SEMANTICS_CANONICALIZE_DO_H_
diff --git a/flang/lib/Semantics/canonicalize-omp.cpp b/flang/lib/Semantics/canonicalize-omp.cpp
index 9588b037aef0..dc8a2a4d93af 100644
--- a/flang/lib/Semantics/canonicalize-omp.cpp
+++ b/flang/lib/Semantics/canonicalize-omp.cpp
@@ -22,8 +22,8 @@ using namespace parser::literals;
 
 class CanonicalizationOfOmp {
 public:
-  template<typename T> bool Pre(T &) { return true; }
-  template<typename T> void Post(T &) {}
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
   CanonicalizationOfOmp(parser::Messages &messages) : messages_{messages} {}
 
   void Post(parser::Block &block) {
@@ -43,11 +43,11 @@ public:
             "loop construct"_err_en_US,
             parser::ToUpperCaseLetters(dir.source.ToString()));
       }
-    }  // Block list
+    } // Block list
   }
 
 private:
-  template<typename T> T *GetConstructIf(parser::ExecutionPartConstruct &x) {
+  template <typename T> T *GetConstructIf(parser::ExecutionPartConstruct &x) {
     if (auto *y{std::get_if<parser::ExecutableConstruct>(&x.u)}) {
       if (auto *z{std::get_if<common::Indirection<T>>(&y->u)}) {
         return &z->value();
@@ -98,7 +98,7 @@ private:
               "DO loop after the %s directive must have loop control"_err_en_US,
               parser::ToUpperCaseLetters(dir.source.ToString()));
         }
-        return;  // found do-loop
+        return; // found do-loop
       }
     }
     messages_.Say(dir.source,
@@ -114,4 +114,4 @@ bool CanonicalizeOmp(parser::Messages &messages, parser::Program &program) {
   Walk(program, omp);
   return !messages.AnyFatalError();
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/canonicalize-omp.h b/flang/lib/Semantics/canonicalize-omp.h
index 6531851a6675..c45d6bbbf906 100644
--- a/flang/lib/Semantics/canonicalize-omp.h
+++ b/flang/lib/Semantics/canonicalize-omp.h
@@ -12,10 +12,10 @@
 namespace Fortran::parser {
 struct Program;
 class Messages;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 bool CanonicalizeOmp(parser::Messages &messages, parser::Program &program);
 }
 
-#endif  // FORTRAN_SEMANTICS_CANONICALIZE_OMP_H_
+#endif // FORTRAN_SEMANTICS_CANONICALIZE_OMP_H_
diff --git a/flang/lib/Semantics/check-allocate.cpp b/flang/lib/Semantics/check-allocate.cpp
index fdba6151d343..456d5949a3a2 100644
--- a/flang/lib/Semantics/check-allocate.cpp
+++ b/flang/lib/Semantics/check-allocate.cpp
@@ -24,7 +24,7 @@ struct AllocateCheckerInfo {
   std::optional<evaluate::DynamicType> sourceExprType;
   std::optional<parser::CharBlock> sourceExprLoc;
   std::optional<parser::CharBlock> typeSpecLoc;
-  int sourceExprRank{0};  // only valid if gotMold || gotSource
+  int sourceExprRank{0}; // only valid if gotMold || gotSource
   bool gotStat{false};
   bool gotMsg{false};
   bool gotTypeSpec{false};
@@ -36,16 +36,16 @@ class AllocationCheckerHelper {
 public:
   AllocationCheckerHelper(
       const parser::Allocation &alloc, AllocateCheckerInfo &info)
-    : allocateInfo_{info}, allocateObject_{std::get<parser::AllocateObject>(
-                               alloc.t)},
-      name_{parser::GetLastName(allocateObject_)},
-      symbol_{name_.symbol ? &name_.symbol->GetUltimate() : nullptr},
-      type_{symbol_ ? symbol_->GetType() : nullptr},
-      allocateShapeSpecRank_{ShapeSpecRank(alloc)}, rank_{symbol_
-                                                            ? symbol_->Rank()
-                                                            : 0},
-      allocateCoarraySpecRank_{CoarraySpecRank(alloc)},
-      corank_{symbol_ ? symbol_->Corank() : 0} {}
+      : allocateInfo_{info}, allocateObject_{std::get<parser::AllocateObject>(
+                                 alloc.t)},
+        name_{parser::GetLastName(allocateObject_)},
+        symbol_{name_.symbol ? &name_.symbol->GetUltimate() : nullptr},
+        type_{symbol_ ? symbol_->GetType() : nullptr},
+        allocateShapeSpecRank_{ShapeSpecRank(alloc)}, rank_{symbol_
+                                                              ? symbol_->Rank()
+                                                              : 0},
+        allocateCoarraySpecRank_{CoarraySpecRank(alloc)},
+        corank_{symbol_ ? symbol_->Corank() : 0} {}
 
   bool RunChecks(SemanticsContext &context);
 
@@ -102,7 +102,7 @@ private:
 static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
     const parser::AllocateStmt &allocateStmt, SemanticsContext &context) {
   AllocateCheckerInfo info;
-  bool stopCheckingAllocate{false};  // for errors that would lead to ambiguity
+  bool stopCheckingAllocate{false}; // for errors that would lead to ambiguity
   if (const auto &typeSpec{
           std::get<std::optional<parser::TypeSpec>>(allocateStmt.t)}) {
     info.typeSpec = typeSpec->declTypeSpec;
@@ -134,14 +134,14 @@ static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
               std::visit(
                   common::visitors{
                       [&](const parser::StatVariable &) {
-                        if (info.gotStat) {  // C943
+                        if (info.gotStat) { // C943
                           context.Say(
                               "STAT may not be duplicated in a ALLOCATE statement"_err_en_US);
                         }
                         info.gotStat = true;
                       },
                       [&](const parser::MsgVariable &) {
-                        if (info.gotMsg) {  // C943
+                        if (info.gotMsg) { // C943
                           context.Say(
                               "ERRMSG may not be duplicated in a ALLOCATE statement"_err_en_US);
                         }
@@ -151,12 +151,12 @@ static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
                   statOrErr.u);
             },
             [&](const parser::AllocOpt::Source &source) {
-              if (info.gotSource) {  // C943
+              if (info.gotSource) { // C943
                 context.Say(
                     "SOURCE may not be duplicated in a ALLOCATE statement"_err_en_US);
                 stopCheckingAllocate = true;
               }
-              if (info.gotMold || info.gotTypeSpec) {  // C944
+              if (info.gotMold || info.gotTypeSpec) { // C944
                 context.Say(
                     "At most one of source-expr and type-spec may appear in a ALLOCATE statement"_err_en_US);
                 stopCheckingAllocate = true;
@@ -165,12 +165,12 @@ static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
               info.gotSource = true;
             },
             [&](const parser::AllocOpt::Mold &mold) {
-              if (info.gotMold) {  // C943
+              if (info.gotMold) { // C943
                 context.Say(
                     "MOLD may not be duplicated in a ALLOCATE statement"_err_en_US);
                 stopCheckingAllocate = true;
               }
-              if (info.gotSource || info.gotTypeSpec) {  // C944
+              if (info.gotSource || info.gotTypeSpec) { // C944
                 context.Say(
                     "At most one of source-expr and type-spec may appear in a ALLOCATE statement"_err_en_US);
                 stopCheckingAllocate = true;
@@ -227,7 +227,7 @@ static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
           }
         }
       }
-      if (info.gotSource) {  // C1594(6) - SOURCE= restrictions when pure
+      if (info.gotSource) { // C1594(6) - SOURCE= restrictions when pure
         const Scope &scope{context.FindScope(at)};
         if (FindPureProcedureContaining(scope)) {
           parser::ContextualMessages messages{at, &context.messages()};
@@ -341,7 +341,7 @@ static bool HaveSameAssumedTypeParameters(
     // type1 or do not exist in type1
     return type1AssumedParametersCount == type2AssumedParametersCount;
   }
-  return true;  // other intrinsic types have no length type parameters
+  return true; // other intrinsic types have no length type parameters
 }
 
 static std::optional<std::int64_t> GetTypeParameterInt64Value(
@@ -409,7 +409,7 @@ bool AllocationCheckerHelper::RunChecks(SemanticsContext &context) {
     CHECK(context.AnyFatalError());
     return false;
   }
-  if (!IsVariableName(*symbol_)) {  // C932 pre-requisite
+  if (!IsVariableName(*symbol_)) { // C932 pre-requisite
     context.Say(name_.source,
         "Name in ALLOCATE statement must be a variable name"_err_en_US);
     return false;
@@ -422,7 +422,7 @@ bool AllocationCheckerHelper::RunChecks(SemanticsContext &context) {
     return false;
   }
   GatherAllocationBasicInfo();
-  if (!IsAllocatableOrPointer(*symbol_)) {  // C932
+  if (!IsAllocatableOrPointer(*symbol_)) { // C932
     context.Say(name_.source,
         "Entity in ALLOCATE statement must have the ALLOCATABLE or POINTER attribute"_err_en_US);
     return false;
@@ -596,7 +596,7 @@ bool AllocationCheckerHelper::RunCoarrayRelatedChecks(
         return false;
       }
     }
-  } else {  // Not a coarray
+  } else { // Not a coarray
     if (hasAllocateCoarraySpec()) {
       // C941
       context.Say(name_.source,
@@ -622,4 +622,4 @@ void AllocateChecker::Leave(const parser::AllocateStmt &allocateStmt) {
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-allocate.h b/flang/lib/Semantics/check-allocate.h
index 2d7405d3e21d..e3f7f07bca5b 100644
--- a/flang/lib/Semantics/check-allocate.h
+++ b/flang/lib/Semantics/check-allocate.h
@@ -24,5 +24,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_ALLOCATE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_ALLOCATE_H_
diff --git a/flang/lib/Semantics/check-arithmeticif.cpp b/flang/lib/Semantics/check-arithmeticif.cpp
index efa711319333..e8ce6aab60c9 100644
--- a/flang/lib/Semantics/check-arithmeticif.cpp
+++ b/flang/lib/Semantics/check-arithmeticif.cpp
@@ -42,4 +42,4 @@ void ArithmeticIfStmtChecker::Leave(
   // statements and in the same inclusive scope.
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-arithmeticif.h b/flang/lib/Semantics/check-arithmeticif.h
index f1b50e10d7d4..1d156763e551 100644
--- a/flang/lib/Semantics/check-arithmeticif.h
+++ b/flang/lib/Semantics/check-arithmeticif.h
@@ -24,5 +24,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_ARITHMETICIF_STMT_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_ARITHMETICIF_STMT_H_
diff --git a/flang/lib/Semantics/check-call.cpp b/flang/lib/Semantics/check-call.cpp
index 88997874bb97..163944533eac 100644
--- a/flang/lib/Semantics/check-call.cpp
+++ b/flang/lib/Semantics/check-call.cpp
@@ -182,13 +182,13 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       dummy.attrs.test(characteristics::DummyDataObject::Attr::Value)};
 
   if (actualIsPolymorphic && dummyIsPolymorphic &&
-      actualIsCoindexed) {  // 15.5.2.4(2)
+      actualIsCoindexed) { // 15.5.2.4(2)
     messages.Say(
         "Coindexed polymorphic object may not be associated with a polymorphic %s"_err_en_US,
         dummyName);
   }
   if (actualIsPolymorphic && !dummyIsPolymorphic &&
-      actualIsAssumedSize) {  // 15.5.2.4(2)
+      actualIsAssumedSize) { // 15.5.2.4(2)
     messages.Say(
         "Assumed-size polymorphic array may not be associated with a monomorphic %s"_err_en_US,
         dummyName);
@@ -202,7 +202,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       actualFirstSymbol && actualFirstSymbol->attrs().test(Attr::VOLATILE)};
   if (const auto *derived{evaluate::GetDerivedTypeSpec(actualType.type())}) {
     if (dummy.type.type().IsAssumedType()) {
-      if (!derived->parameters().empty()) {  // 15.5.2.4(2)
+      if (!derived->parameters().empty()) { // 15.5.2.4(2)
         messages.Say(
             "Actual argument associated with TYPE(*) %s may not have a parameterized derived type"_err_en_US,
             dummyName);
@@ -210,7 +210,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       if (const Symbol *
           tbp{FindImmediateComponent(*derived, [](const Symbol &symbol) {
             return symbol.has<ProcBindingDetails>();
-          })}) {  // 15.5.2.4(2)
+          })}) { // 15.5.2.4(2)
         evaluate::SayWithDeclaration(messages, *tbp,
             "Actual argument associated with TYPE(*) %s may not have type-bound procedure '%s'"_err_en_US,
             dummyName, tbp->name());
@@ -218,7 +218,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       if (const Symbol *
           finalizer{FindImmediateComponent(*derived, [](const Symbol &symbol) {
             return symbol.has<FinalProcDetails>();
-          })}) {  // 15.5.2.4(2)
+          })}) { // 15.5.2.4(2)
         evaluate::SayWithDeclaration(messages, *finalizer,
             "Actual argument associated with TYPE(*) %s may not have FINAL subroutine '%s'"_err_en_US,
             dummyName, finalizer->name());
@@ -227,13 +227,13 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
     if (actualIsCoindexed) {
       if (dummy.intent != common::Intent::In && !dummyIsValue) {
         if (auto bad{
-                FindAllocatableUltimateComponent(*derived)}) {  // 15.5.2.4(6)
+                FindAllocatableUltimateComponent(*derived)}) { // 15.5.2.4(6)
           evaluate::SayWithDeclaration(messages, *bad,
               "Coindexed actual argument with ALLOCATABLE ultimate component '%s' must be associated with a %s with VALUE or INTENT(IN) attributes"_err_en_US,
               bad.BuildResultDesignatorName(), dummyName);
         }
       }
-      if (auto coarrayRef{evaluate::ExtractCoarrayRef(actual)}) {  // C1537
+      if (auto coarrayRef{evaluate::ExtractCoarrayRef(actual)}) { // C1537
         const Symbol &coarray{coarrayRef->GetLastSymbol()};
         if (const DeclTypeSpec * type{coarray.GetType()}) {
           if (const DerivedTypeSpec * derived{type->AsDerived()}) {
@@ -246,7 +246,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
         }
       }
     }
-    if (actualIsVolatile != dummyIsVolatile) {  // 15.5.2.4(22)
+    if (actualIsVolatile != dummyIsVolatile) { // 15.5.2.4(22)
       if (auto bad{semantics::FindCoarrayUltimateComponent(*derived)}) {
         evaluate::SayWithDeclaration(messages, *bad,
             "VOLATILE attribute must match for %s when actual argument has a coarray ultimate component '%s'"_err_en_US,
@@ -310,7 +310,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
   }
   if (actualLastObject && actualLastObject->IsCoarray() &&
       IsAllocatable(*actualLastSymbol) &&
-      dummy.intent == common::Intent::Out) {  // C846
+      dummy.intent == common::Intent::Out) { // C846
     messages.Say(
         "ALLOCATABLE coarray '%s' may not be associated with INTENT(OUT) %s"_err_en_US,
         actualLastSymbol->name(), dummyName);
@@ -328,7 +328,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
     reason = "VOLATILE";
   }
   if (reason && scope) {
-    bool vectorSubscriptIsOk{isElemental || dummyIsValue};  // 15.5.2.4(21)
+    bool vectorSubscriptIsOk{isElemental || dummyIsValue}; // 15.5.2.4(21)
     if (auto why{WhyNotModifiable(
             messages.at(), actual, *scope, vectorSubscriptIsOk)}) {
       if (auto *msg{messages.Say(
@@ -351,7 +351,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
       characteristics::TypeAndShape::Attr::AssumedShape)};
   if ((actualIsAsynchronous || actualIsVolatile) &&
       (dummyIsAsynchronous || dummyIsVolatile) && !dummyIsValue) {
-    if (actualIsCoindexed) {  // C1538
+    if (actualIsCoindexed) { // C1538
       messages.Say(
           "Coindexed ASYNCHRONOUS or VOLATILE actual argument may not be associated with %s with ASYNCHRONOUS or VOLATILE attributes unless VALUE"_err_en_US,
           dummyName);
@@ -359,7 +359,7 @@ static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
     if (actualRank > 0 && !actualIsContiguous) {
       if (dummyIsContiguous ||
           !(dummyIsAssumedShape || dummyIsAssumedRank ||
-              (actualIsPointer && dummyIsPointer))) {  // C1539 & C1540
+              (actualIsPointer && dummyIsPointer))) { // C1539 & C1540
         messages.Say(
             "ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous %s"_err_en_US,
             dummyName);
@@ -509,11 +509,11 @@ static void CheckProcedureArg(evaluate::ActualArgument &arg,
           argInterface.attrs.reset(characteristics::Procedure::Attr::Elemental);
         } else if (argInterface.attrs.test(
                        characteristics::Procedure::Attr::Elemental)) {
-          if (argProcSymbol) {  // C1533
+          if (argProcSymbol) { // C1533
             evaluate::SayWithDeclaration(messages, *argProcSymbol,
                 "Non-intrinsic ELEMENTAL procedure '%s' may not be passed as an actual argument"_err_en_US,
                 argProcSymbol->name());
-            return;  // avoid piling on with checks below
+            return; // avoid piling on with checks below
           } else {
             argInterface.attrs.reset(
                 characteristics::Procedure::Attr::NullPointer);
@@ -529,7 +529,7 @@ static void CheckProcedureArg(evaluate::ActualArgument &arg,
                 "Actual argument procedure has interface incompatible with %s"_err_en_US,
                 dummyName);
           }
-        } else {  // 15.5.2.9(2,3)
+        } else { // 15.5.2.9(2,3)
           if (interface.IsSubroutine() && argInterface.IsFunction()) {
             messages.Say(
                 "Actual argument associated with procedure %s is a function but must be a subroutine"_err_en_US,
@@ -567,7 +567,7 @@ static void CheckProcedureArg(evaluate::ActualArgument &arg,
               "Actual argument associated with procedure pointer %s must be a POINTER unless INTENT(IN)"_err_en_US,
               dummyName);
         }
-      } else {  // 15.5.2.9(4) -- dummy procedure is not POINTER
+      } else { // 15.5.2.9(4) -- dummy procedure is not POINTER
         if (!argProcDesignator) {
           messages.Say(
               "Actual argument associated with non-POINTER procedure %s must be a procedure (and not a procedure pointer)"_err_en_US,
@@ -618,7 +618,7 @@ static void CheckExplicitInterfaceArg(evaluate::ActualArgument &arg,
               } else if (const auto *details{
                              assumed.detailsIf<ObjectEntityDetails>()}) {
                 if (!(details->IsAssumedShape() || details->IsAssumedRank())) {
-                  messages.Say(  // C711
+                  messages.Say( // C711
                       "Assumed-type '%s' must be either assumed shape or assumed rank to be associated with assumed-type %s"_err_en_US,
                       assumed.name(), dummyName);
                 }
@@ -753,4 +753,4 @@ void CheckArguments(const characteristics::Procedure &proc,
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-call.h b/flang/lib/Semantics/check-call.h
index 08bed15cb7ec..be503e49e5cc 100644
--- a/flang/lib/Semantics/check-call.h
+++ b/flang/lib/Semantics/check-call.h
@@ -16,7 +16,7 @@
 namespace Fortran::parser {
 class Messages;
 class ContextualMessages;
-}
+} // namespace Fortran::parser
 namespace Fortran::evaluate::characteristics {
 struct Procedure;
 }
@@ -44,5 +44,5 @@ parser::Messages CheckExplicitInterface(
 // Checks actual arguments for the purpose of resolving a generic interface.
 bool CheckInterfaceForGeneric(const evaluate::characteristics::Procedure &,
     evaluate::ActualArguments &, const evaluate::FoldingContext &);
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/flang/lib/Semantics/check-case.cpp b/flang/lib/Semantics/check-case.cpp
index c0f957a83728..3f1586dfd8fd 100644
--- a/flang/lib/Semantics/check-case.cpp
+++ b/flang/lib/Semantics/check-case.cpp
@@ -100,26 +100,25 @@ private:
 
   using PairOfValues = std::pair<std::optional<Value>, std::optional<Value>>;
   PairOfValues ComputeBounds(const parser::CaseValueRange &range) {
-    return std::visit(
-        common::visitors{
-            [&](const parser::CaseValue &x) {
-              auto value{GetValue(x)};
-              return PairOfValues{value, value};
-            },
-            [&](const parser::CaseValueRange::Range &x) {
-              std::optional<Value> lo, hi;
-              if (x.lower) {
-                lo = GetValue(*x.lower);
-              }
-              if (x.upper) {
-                hi = GetValue(*x.upper);
-              }
-              if ((x.lower && !lo) || (x.upper && !hi)) {
-                return PairOfValues{}; // error case
-              }
-              return PairOfValues{std::move(lo), std::move(hi)};
-            },
-        },
+    return std::visit(common::visitors{
+                          [&](const parser::CaseValue &x) {
+                            auto value{GetValue(x)};
+                            return PairOfValues{value, value};
+                          },
+                          [&](const parser::CaseValueRange::Range &x) {
+                            std::optional<Value> lo, hi;
+                            if (x.lower) {
+                              lo = GetValue(*x.lower);
+                            }
+                            if (x.upper) {
+                              hi = GetValue(*x.upper);
+                            }
+                            if ((x.lower && !lo) || (x.upper && !hi)) {
+                              return PairOfValues{}; // error case
+                            }
+                            return PairOfValues{std::move(lo), std::move(hi)};
+                          },
+                      },
         range.u);
   }
 
diff --git a/flang/lib/Semantics/check-coarray.cpp b/flang/lib/Semantics/check-coarray.cpp
index f070ebc61695..a9d649ffff47 100644
--- a/flang/lib/Semantics/check-coarray.cpp
+++ b/flang/lib/Semantics/check-coarray.cpp
@@ -21,12 +21,12 @@ class CriticalBodyEnforce {
 public:
   CriticalBodyEnforce(
       SemanticsContext &context, parser::CharBlock criticalSourcePosition)
-    : context_{context}, criticalSourcePosition_{criticalSourcePosition} {}
+      : context_{context}, criticalSourcePosition_{criticalSourcePosition} {}
   std::set<parser::Label> labels() { return labels_; }
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
 
-  template<typename T> bool Pre(const parser::Statement<T> &statement) {
+  template <typename T> bool Pre(const parser::Statement<T> &statement) {
     currentStatementSourcePosition_ = statement.source;
     if (statement.label.has_value()) {
       labels_.insert(*statement.label);
@@ -62,11 +62,11 @@ private:
   parser::CharBlock criticalSourcePosition_;
 };
 
-template<typename T>
+template <typename T>
 static void CheckTeamType(SemanticsContext &context, const T &x) {
   if (const auto *expr{GetExpr(x)}) {
     if (!IsTeamType(evaluate::GetDerivedTypeSpec(expr->GetType()))) {
-      context.Say(parser::FindSourceLocation(x),  // C1114
+      context.Say(parser::FindSourceLocation(x), // C1114
           "Team value must be of type TEAM_TYPE from module ISO_FORTRAN_ENV"_err_en_US);
     }
   }
@@ -118,10 +118,10 @@ void CoarrayChecker::CheckNamesAreDistinct(
     const auto &selector{std::get<parser::Selector>(assoc.t)};
     const auto &declName{std::get<parser::Name>(decl.t)};
     if (context_.HasError(declName)) {
-      continue;  // already reported an error about this name
+      continue; // already reported an error about this name
     }
     if (auto *prev{getPreviousUse(declName)}) {
-      Say2(declName.source,  // C1113
+      Say2(declName.source, // C1113
           "Coarray '%s' was already used as a selector or coarray in this statement"_err_en_US,
           *prev, "Previous use of '%s'"_en_US);
     }
@@ -129,7 +129,7 @@ void CoarrayChecker::CheckNamesAreDistinct(
     const parser::Name *name{parser::Unwrap<parser::Name>(selector)};
     if (name) {
       if (auto *prev{getPreviousUse(*name)}) {
-        Say2(name->source,  // C1113, C1115
+        Say2(name->source, // C1113, C1115
             "Selector '%s' was already used as a selector or coarray in this statement"_err_en_US,
             *prev, "Previous use of '%s'"_en_US);
       }
@@ -143,4 +143,4 @@ void CoarrayChecker::Say2(const parser::CharBlock &name1,
   context_.Say(name1, std::move(msg1), name1)
       .Attach(name2, std::move(msg2), name2);
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-coarray.h b/flang/lib/Semantics/check-coarray.h
index dd34f0ae3641..2e91c7b259d6 100644
--- a/flang/lib/Semantics/check-coarray.h
+++ b/flang/lib/Semantics/check-coarray.h
@@ -21,7 +21,7 @@ struct FormTeamStmt;
 struct ImageSelectorSpec;
 struct SyncTeamStmt;
 struct TeamValue;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -42,5 +42,5 @@ private:
   void Say2(const parser::CharBlock &, parser::MessageFixedText &&,
       const parser::CharBlock &, parser::MessageFixedText &&);
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_COARRAY_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_COARRAY_H_
diff --git a/flang/lib/Semantics/check-data.cpp b/flang/lib/Semantics/check-data.cpp
index e7d599eeebe5..6178eb7360ca 100644
--- a/flang/lib/Semantics/check-data.cpp
+++ b/flang/lib/Semantics/check-data.cpp
@@ -18,7 +18,7 @@ void DataChecker::Leave(const parser::DataStmtConstant &dataConst) {
       const parser::Expr &parsedExpr{
           std::get<parser::ComponentDataSource>(component.t).v.value()};
       if (const auto *expr{GetExpr(parsedExpr)}) {
-        if (!evaluate::IsConstantExpr(*expr)) {  // C884
+        if (!evaluate::IsConstantExpr(*expr)) { // C884
           context_.Say(parsedExpr.source,
               "Structure constructor in data value must be a constant expression"_err_en_US);
         }
@@ -38,7 +38,7 @@ void DataChecker::Leave(const parser::DataStmtRepeat &dataRepeat) {
         auto expr{
             evaluate::Fold(context_.foldingContext(), std::move(checked))};
         if (auto i64{ToInt64(expr)}) {
-          if (*i64 < 0) {  // C882
+          if (*i64 < 0) { // C882
             context_.Say(designator->source,
                 "Repeat count for data value must not be negative"_err_en_US);
           }
@@ -47,4 +47,4 @@ void DataChecker::Leave(const parser::DataStmtRepeat &dataRepeat) {
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-data.h b/flang/lib/Semantics/check-data.h
index 80b8edc7f713..5d66c8e74e55 100644
--- a/flang/lib/Semantics/check-data.h
+++ b/flang/lib/Semantics/check-data.h
@@ -24,5 +24,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_DATA_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_DATA_H_
diff --git a/flang/lib/Semantics/check-deallocate.cpp b/flang/lib/Semantics/check-deallocate.cpp
index 646251427db8..92e197bbb322 100644
--- a/flang/lib/Semantics/check-deallocate.cpp
+++ b/flang/lib/Semantics/check-deallocate.cpp
@@ -26,7 +26,7 @@ void DeallocateChecker::Leave(const parser::DeallocateStmt &deallocateStmt) {
               } else if (!IsVariableName(*symbol)) {
                 context_.Say(name.source,
                     "name in DEALLOCATE statement must be a variable name"_err_en_US);
-              } else if (!IsAllocatableOrPointer(*symbol)) {  // C932
+              } else if (!IsAllocatableOrPointer(*symbol)) { // C932
                 context_.Say(name.source,
                     "name in DEALLOCATE statement must have the ALLOCATABLE or POINTER attribute"_err_en_US);
               } else {
@@ -37,7 +37,7 @@ void DeallocateChecker::Leave(const parser::DeallocateStmt &deallocateStmt) {
               evaluate::ExpressionAnalyzer analyzer{context_};
               if (MaybeExpr checked{analyzer.Analyze(structureComponent)}) {
                 if (!IsAllocatableOrPointer(
-                        *structureComponent.component.symbol)) {  // C932
+                        *structureComponent.component.symbol)) { // C932
                   context_.Say(structureComponent.component.source,
                       "component in DEALLOCATE statement must have the ALLOCATABLE or POINTER attribute"_err_en_US);
                 }
@@ -69,4 +69,4 @@ void DeallocateChecker::Leave(const parser::DeallocateStmt &deallocateStmt) {
         deallocOpt.u);
   }
 }
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-deallocate.h b/flang/lib/Semantics/check-deallocate.h
index f47283a22c29..6aafb87a7479 100644
--- a/flang/lib/Semantics/check-deallocate.h
+++ b/flang/lib/Semantics/check-deallocate.h
@@ -24,5 +24,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_DEALLOCATE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_DEALLOCATE_H_
diff --git a/flang/lib/Semantics/check-declarations.cpp b/flang/lib/Semantics/check-declarations.cpp
index cb6888610b28..15dd78270e5d 100644
--- a/flang/lib/Semantics/check-declarations.cpp
+++ b/flang/lib/Semantics/check-declarations.cpp
@@ -44,7 +44,7 @@ public:
   void Check(const Scope &);
 
 private:
-  template<typename A> void CheckSpecExpr(const A &x) {
+  template <typename A> void CheckSpecExpr(const A &x) {
     if (symbolBeingChecked_ && IsSaved(*symbolBeingChecked_)) {
       if (!evaluate::IsConstantExpr(x)) {
         messages_.Say(
@@ -55,12 +55,12 @@ private:
       evaluate::CheckSpecificationExpr(x, messages_, DEREF(scope_));
     }
   }
-  template<typename A> void CheckSpecExpr(const std::optional<A> &x) {
+  template <typename A> void CheckSpecExpr(const std::optional<A> &x) {
     if (x) {
       CheckSpecExpr(*x);
     }
   }
-  template<typename A> void CheckSpecExpr(A &x) {
+  template <typename A> void CheckSpecExpr(A &x) {
     x = Fold(foldingContext_, std::move(x));
     const A &constx{x};
     CheckSpecExpr(constx);
@@ -102,7 +102,7 @@ private:
   bool InFunction() const {
     return innermostSymbol_ && IsFunction(*innermostSymbol_);
   }
-  template<typename... A>
+  template <typename... A>
   void SayWithDeclaration(const Symbol &symbol, A &&... x) {
     if (parser::Message * msg{messages_.Say(std::forward<A>(x)...)}) {
       if (messages_.at().begin() != symbol.name().begin()) {
@@ -124,7 +124,7 @@ private:
 
 void CheckHelper::Check(const ParamValue &value, bool canBeAssumed) {
   if (value.isAssumed()) {
-    if (!canBeAssumed) {  // C795, C721, C726
+    if (!canBeAssumed) { // C795, C721, C726
       messages_.Say(
           "An assumed (*) type parameter may be used only for a (non-statement"
           " function) dummy argument, associate name, named constant, or"
@@ -165,7 +165,7 @@ void CheckHelper::Check(const Symbol &symbol) {
     CheckVolatile(symbol, isAssociated, derived);
   }
   if (isAssociated) {
-    return;  // only care about checking VOLATILE on associated symbols
+    return; // only care about checking VOLATILE on associated symbols
   }
   if (IsPointer(symbol)) {
     CheckPointer(symbol);
@@ -208,28 +208,28 @@ void CheckHelper::Check(const Symbol &symbol) {
       }
     }
   }
-  if (type) {  // Section 7.2, paragraph 7
+  if (type) { // Section 7.2, paragraph 7
     bool canHaveAssumedParameter{IsNamedConstant(symbol) ||
-        (IsAssumedLengthCharacter(symbol) &&  // C722
+        (IsAssumedLengthCharacter(symbol) && // C722
             IsExternal(symbol)) ||
         symbol.test(Symbol::Flag::ParentComp)};
-    if (!IsStmtFunctionDummy(symbol)) {  // C726
+    if (!IsStmtFunctionDummy(symbol)) { // C726
       if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
         canHaveAssumedParameter |= object->isDummy() ||
             (object->isFuncResult() &&
                 type->category() == DeclTypeSpec::Character) ||
-            IsStmtFunctionResult(symbol);  // Avoids multiple messages
+            IsStmtFunctionResult(symbol); // Avoids multiple messages
       } else {
         canHaveAssumedParameter |= symbol.has<AssocEntityDetails>();
       }
     }
     Check(*type, canHaveAssumedParameter);
     if (InPure() && InFunction() && IsFunctionResult(symbol)) {
-      if (derived && HasImpureFinal(*derived)) {  // C1584
+      if (derived && HasImpureFinal(*derived)) { // C1584
         messages_.Say(
             "Result of pure function may not have an impure FINAL subroutine"_err_en_US);
       }
-      if (type->IsPolymorphic() && IsAllocatable(symbol)) {  // C1585
+      if (type->IsPolymorphic() && IsAllocatable(symbol)) { // C1585
         messages_.Say(
             "Result of pure function may not be both polymorphic and ALLOCATABLE"_err_en_US);
       }
@@ -242,7 +242,7 @@ void CheckHelper::Check(const Symbol &symbol) {
       }
     }
   }
-  if (IsAssumedLengthCharacter(symbol) && IsExternal(symbol)) {  // C723
+  if (IsAssumedLengthCharacter(symbol) && IsExternal(symbol)) { // C723
     if (symbol.attrs().test(Attr::RECURSIVE)) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot be RECURSIVE"_err_en_US);
@@ -270,7 +270,7 @@ void CheckHelper::Check(const Symbol &symbol) {
     CheckValue(symbol, derived);
   }
   if (symbol.attrs().test(Attr::CONTIGUOUS) && IsPointer(symbol) &&
-      symbol.Rank() == 0) {  // C830
+      symbol.Rank() == 0) { // C830
     messages_.Say("CONTIGUOUS POINTER must be an array"_err_en_US);
   }
   if (IsDummy(symbol)) {
@@ -286,7 +286,7 @@ void CheckHelper::Check(const Symbol &symbol) {
 }
 
 void CheckHelper::CheckValue(
-    const Symbol &symbol, const DerivedTypeSpec *derived) {  // C863 - C865
+    const Symbol &symbol, const DerivedTypeSpec *derived) { // C863 - C865
   if (!IsDummy(symbol)) {
     messages_.Say(
         "VALUE attribute may apply only to a dummy argument"_err_en_US);
@@ -330,7 +330,7 @@ void CheckHelper::CheckValue(
   }
 }
 
-void CheckHelper::CheckAssumedTypeEntity(  // C709
+void CheckHelper::CheckAssumedTypeEntity( // C709
     const Symbol &symbol, const ObjectEntityDetails &details) {
   if (const DeclTypeSpec * type{symbol.GetType()};
       type && type->category() == DeclTypeSpec::TypeStar) {
@@ -377,7 +377,7 @@ void CheckHelper::CheckAssumedTypeEntity(  // C709
 void CheckHelper::CheckObjectEntity(
     const Symbol &symbol, const ObjectEntityDetails &details) {
   CHECK(!symbolBeingChecked_);
-  symbolBeingChecked_ = &symbol;  // for specification expr checks
+  symbolBeingChecked_ = &symbol; // for specification expr checks
   CheckArraySpec(symbol, details.shape());
   Check(details.shape());
   Check(details.coshape());
@@ -385,12 +385,12 @@ void CheckHelper::CheckObjectEntity(
   symbolBeingChecked_ = nullptr;
   if (!details.coshape().empty()) {
     if (IsAllocatable(symbol)) {
-      if (!details.coshape().IsDeferredShape()) {  // C827
+      if (!details.coshape().IsDeferredShape()) { // C827
         messages_.Say(
             "ALLOCATABLE coarray must have a deferred coshape"_err_en_US);
       }
     } else {
-      if (!details.coshape().IsAssumedSize()) {  // C828
+      if (!details.coshape().IsAssumedSize()) { // C828
         messages_.Say(
             "Non-ALLOCATABLE coarray must have an explicit coshape"_err_en_US);
       }
@@ -400,40 +400,40 @@ void CheckHelper::CheckObjectEntity(
     if (symbol.attrs().test(Attr::INTENT_OUT)) {
       if (FindUltimateComponent(symbol, [](const Symbol &x) {
             return IsCoarray(x) && IsAllocatable(x);
-          })) {  // C846
+          })) { // C846
         messages_.Say(
             "An INTENT(OUT) dummy argument may not be, or contain, an ALLOCATABLE coarray"_err_en_US);
       }
-      if (IsOrContainsEventOrLockComponent(symbol)) {  // C847
+      if (IsOrContainsEventOrLockComponent(symbol)) { // C847
         messages_.Say(
             "An INTENT(OUT) dummy argument may not be, or contain, EVENT_TYPE or LOCK_TYPE"_err_en_US);
       }
     }
     if (InPure() && !IsPointer(symbol) && !IsIntentIn(symbol) &&
         !symbol.attrs().test(Attr::VALUE)) {
-      if (InFunction()) {  // C1583
+      if (InFunction()) { // C1583
         messages_.Say(
             "non-POINTER dummy argument of pure function must be INTENT(IN) or VALUE"_err_en_US);
       } else if (IsIntentOut(symbol)) {
         if (const DeclTypeSpec * type{details.type()}) {
-          if (type && type->IsPolymorphic()) {  // C1588
+          if (type && type->IsPolymorphic()) { // C1588
             messages_.Say(
                 "An INTENT(OUT) dummy argument of a pure subroutine may not be polymorphic"_err_en_US);
           } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
             if (FindUltimateComponent(*derived, [](const Symbol &x) {
                   const DeclTypeSpec *type{x.GetType()};
                   return type && type->IsPolymorphic();
-                })) {  // C1588
+                })) { // C1588
               messages_.Say(
                   "An INTENT(OUT) dummy argument of a pure subroutine may not have a polymorphic ultimate component"_err_en_US);
             }
-            if (HasImpureFinal(*derived)) {  // C1587
+            if (HasImpureFinal(*derived)) { // C1587
               messages_.Say(
                   "An INTENT(OUT) dummy argument of a pure subroutine may not have an impure FINAL subroutine"_err_en_US);
             }
           }
         }
-      } else if (!IsIntentInOut(symbol)) {  // C1586
+      } else if (!IsIntentInOut(symbol)) { // C1586
         messages_.Say(
             "non-POINTER dummy argument of pure subroutine must have INTENT() or VALUE attribute"_err_en_US);
       }
@@ -456,7 +456,7 @@ void CheckHelper::CheckObjectEntity(
       }
     }
   }
-  if (const DeclTypeSpec * type{details.type()}) {  // C708
+  if (const DeclTypeSpec * type{details.type()}) { // C708
     if (type->IsPolymorphic() &&
         !(type->IsAssumedType() || IsAllocatableOrPointer(symbol) ||
             symbol.IsDummy())) {
@@ -496,7 +496,7 @@ void CheckHelper::CheckArraySpec(
     msg = "Cray pointee '%s' must have must have explicit shape or"
           " assumed size"_err_en_US;
   } else if (IsAllocatableOrPointer(symbol) && !isDeferred && !isAssumedRank) {
-    if (symbol.owner().IsDerivedType()) {  // C745
+    if (symbol.owner().IsDerivedType()) { // C745
       if (IsAllocatable(symbol)) {
         msg = "Allocatable array component '%s' must have"
               " deferred shape"_err_en_US;
@@ -504,7 +504,7 @@ void CheckHelper::CheckArraySpec(
         msg = "Array pointer component '%s' must have deferred shape"_err_en_US;
       }
     } else {
-      if (IsAllocatable(symbol)) {  // C832
+      if (IsAllocatable(symbol)) { // C832
         msg = "Allocatable array '%s' must have deferred shape or"
               " assumed rank"_err_en_US;
       } else {
@@ -513,17 +513,17 @@ void CheckHelper::CheckArraySpec(
       }
     }
   } else if (symbol.IsDummy()) {
-    if (isImplied && !isAssumedSize) {  // C836
+    if (isImplied && !isAssumedSize) { // C836
       msg = "Dummy array argument '%s' may not have implied shape"_err_en_US;
     }
   } else if (isAssumedShape && !isDeferred) {
     msg = "Assumed-shape array '%s' must be a dummy argument"_err_en_US;
-  } else if (isAssumedSize && !isImplied) {  // C833
+  } else if (isAssumedSize && !isImplied) { // C833
     msg = "Assumed-size array '%s' must be a dummy argument"_err_en_US;
-  } else if (isAssumedRank) {  // C837
+  } else if (isAssumedRank) { // C837
     msg = "Assumed-rank array '%s' must be a dummy argument"_err_en_US;
   } else if (isImplied) {
-    if (!IsNamedConstant(symbol)) {  // C836
+    if (!IsNamedConstant(symbol)) { // C836
       msg = "Implied-shape array '%s' must be a named constant"_err_en_US;
     }
   } else if (IsNamedConstant(symbol)) {
@@ -532,10 +532,10 @@ void CheckHelper::CheckArraySpec(
             " implied shape"_err_en_US;
     }
   } else if (!IsAllocatableOrPointer(symbol) && !isExplicit) {
-    if (symbol.owner().IsDerivedType()) {  // C749
+    if (symbol.owner().IsDerivedType()) { // C749
       msg = "Component array '%s' without ALLOCATABLE or POINTER attribute must"
             " have explicit shape"_err_en_US;
-    } else {  // C816
+    } else { // C816
       msg = "Array '%s' without ALLOCATABLE or POINTER attribute must have"
             " explicit shape"_err_en_US;
     }
@@ -569,7 +569,7 @@ void CheckHelper::CheckProcEntity(
       if (interface->attrs().test(Attr::ELEMENTAL) &&
           !interface->attrs().test(Attr::INTRINSIC)) {
         messages_.Say("Procedure pointer '%s' may not be ELEMENTAL"_err_en_US,
-            symbol.name());  // C1517
+            symbol.name()); // C1517
       }
     }
   }
@@ -583,7 +583,7 @@ void CheckHelper::CheckProcEntity(
 class SubprogramMatchHelper {
 public:
   explicit SubprogramMatchHelper(SemanticsContext &context)
-    : context{context} {}
+      : context{context} {}
 
   void Check(const Symbol &, const Symbol &);
 
@@ -596,10 +596,10 @@ private:
       const DummyProcedure &, const DummyProcedure &);
   bool CheckSameIntent(
       const Symbol &, const Symbol &, common::Intent, common::Intent);
-  template<typename... A>
+  template <typename... A>
   void Say(
       const Symbol &, const Symbol &, parser::MessageFixedText &&, A &&...);
-  template<typename ATTRS>
+  template <typename ATTRS>
   bool CheckSameAttrs(const Symbol &, const Symbol &, ATTRS, ATTRS);
   bool ShapesAreCompatible(const DummyDataObject &, const DummyDataObject &);
   evaluate::Shape FoldShape(const evaluate::Shape &);
@@ -691,7 +691,7 @@ void CheckHelper::CheckDerivedType(
   }
   if (const DeclTypeSpec * parent{FindParentTypeSpec(symbol)}) {
     const DerivedTypeSpec *parentDerived{parent->AsDerived()};
-    if (!IsExtensibleType(parentDerived)) {  // C705
+    if (!IsExtensibleType(parentDerived)) { // C705
       messages_.Say("The parent type is not extensible"_err_en_US);
     }
     if (!symbol.attrs().test(Attr::ABSTRACT) && parentDerived &&
@@ -708,7 +708,7 @@ void CheckHelper::CheckDerivedType(
       }
     }
   }
-  if (HasIntrinsicTypeName(symbol)) {  // C729
+  if (HasIntrinsicTypeName(symbol)) { // C729
     messages_.Say("A derived type name cannot be the name of an intrinsic"
                   " type"_err_en_US);
   }
@@ -789,7 +789,7 @@ static bool ConflictsWithIntrinsicOperator(
     const GenericKind &kind, const Procedure &proc) {
   auto arg0{std::get<DummyDataObject>(proc.dummyArguments[0].u).type};
   auto type0{arg0.type()};
-  if (proc.dummyArguments.size() == 1) {  // unary
+  if (proc.dummyArguments.size() == 1) { // unary
     return std::visit(
         common::visitors{
             [&](common::NumericOperator) { return IsIntrinsicNumeric(type0); },
@@ -797,7 +797,7 @@ static bool ConflictsWithIntrinsicOperator(
             [](const auto &) -> bool { DIE("bad generic kind"); },
         },
         kind.u);
-  } else {  // binary
+  } else { // binary
     int rank0{arg0.Rank()};
     auto arg1{std::get<DummyDataObject>(proc.dummyArguments[1].u).type};
     auto type1{arg1.type()};
@@ -827,7 +827,7 @@ static bool ConflictsWithIntrinsicOperator(
 bool CheckHelper::CheckDefinedOperator(const SourceName &opName,
     const GenericKind &kind, const Symbol &specific, const Procedure &proc) {
   std::optional<parser::MessageFixedText> msg;
-  if (specific.attrs().test(Attr::NOPASS)) {  // C774
+  if (specific.attrs().test(Attr::NOPASS)) { // C774
     msg = "%s procedure '%s' may not have NOPASS attribute"_err_en_US;
   } else if (!proc.functionResult.has_value()) {
     msg = "%s procedure '%s' must be a function"_err_en_US;
@@ -838,11 +838,11 @@ bool CheckHelper::CheckDefinedOperator(const SourceName &opName,
     msg = std::move(m);
   } else if (!CheckDefinedOperatorArg(opName, specific, proc, 0) |
       !CheckDefinedOperatorArg(opName, specific, proc, 1)) {
-    return false;  // error was reported
+    return false; // error was reported
   } else if (ConflictsWithIntrinsicOperator(kind, proc)) {
     msg = "%s function '%s' conflicts with intrinsic operator"_err_en_US;
   } else {
-    return true;  // OK
+    return true; // OK
   }
   SayWithDeclaration(specific, std::move(msg.value()),
       parser::ToUpperCaseLetters(opName.ToString()), specific.name());
@@ -853,29 +853,28 @@ bool CheckHelper::CheckDefinedOperator(const SourceName &opName,
 // false and return the error message in msg.
 std::optional<parser::MessageFixedText> CheckHelper::CheckNumberOfArgs(
     const GenericKind &kind, std::size_t nargs) {
-  std::size_t min{2}, max{2};  // allowed number of args; default is binary
-  std::visit(
-      common::visitors{
-          [&](const common::NumericOperator &x) {
-            if (x == common::NumericOperator::Add ||
-                x == common::NumericOperator::Subtract) {
-              min = 1;  // + and - are unary or binary
-            }
-          },
-          [&](const common::LogicalOperator &x) {
-            if (x == common::LogicalOperator::Not) {
-              min = 1;  // .NOT. is unary
-              max = 1;
-            }
-          },
-          [](const common::RelationalOperator &) {
-            // all are binary
-          },
-          [](const GenericKind::OtherKind &x) {
-            CHECK(x == GenericKind::OtherKind::Concat);
-          },
-          [](const auto &) { DIE("expected intrinsic operator"); },
-      },
+  std::size_t min{2}, max{2}; // allowed number of args; default is binary
+  std::visit(common::visitors{
+                 [&](const common::NumericOperator &x) {
+                   if (x == common::NumericOperator::Add ||
+                       x == common::NumericOperator::Subtract) {
+                     min = 1; // + and - are unary or binary
+                   }
+                 },
+                 [&](const common::LogicalOperator &x) {
+                   if (x == common::LogicalOperator::Not) {
+                     min = 1; // .NOT. is unary
+                     max = 1;
+                   }
+                 },
+                 [](const common::RelationalOperator &) {
+                   // all are binary
+                 },
+                 [](const GenericKind::OtherKind &x) {
+                   CHECK(x == GenericKind::OtherKind::Concat);
+                 },
+                 [](const auto &) { DIE("expected intrinsic operator"); },
+             },
       kind.u);
   if (nargs >= min && nargs <= max) {
     return std::nullopt;
@@ -919,7 +918,7 @@ bool CheckHelper::CheckDefinedOperatorArg(const SourceName &opName,
 bool CheckHelper::CheckDefinedAssignment(
     const Symbol &specific, const Procedure &proc) {
   std::optional<parser::MessageFixedText> msg;
-  if (specific.attrs().test(Attr::NOPASS)) {  // C774
+  if (specific.attrs().test(Attr::NOPASS)) { // C774
     msg = "Defined assignment procedure '%s' may not have"
           " NOPASS attribute"_err_en_US;
   } else if (!proc.IsSubroutine()) {
@@ -929,12 +928,12 @@ bool CheckHelper::CheckDefinedAssignment(
           " two dummy arguments"_err_en_US;
   } else if (!CheckDefinedAssignmentArg(specific, proc.dummyArguments[0], 0) |
       !CheckDefinedAssignmentArg(specific, proc.dummyArguments[1], 1)) {
-    return false;  // error was reported
+    return false; // error was reported
   } else if (ConflictsWithIntrinsicAssignment(proc)) {
     msg = "Defined assignment subroutine '%s' conflicts with"
           " intrinsic assignment"_err_en_US;
   } else {
-    return true;  // OK
+    return true; // OK
   }
   SayWithDeclaration(specific, std::move(msg.value()), specific.name());
   return false;
@@ -999,7 +998,7 @@ std::optional<std::vector<Procedure>> CheckHelper::Characterize(
 }
 
 void CheckHelper::CheckVolatile(const Symbol &symbol, bool isAssociated,
-    const DerivedTypeSpec *derived) {  // C866 - C868
+    const DerivedTypeSpec *derived) { // C866 - C868
   if (IsIntentIn(symbol)) {
     messages_.Say(
         "VOLATILE attribute may not apply to an INTENT(IN) argument"_err_en_US);
@@ -1022,7 +1021,7 @@ void CheckHelper::CheckVolatile(const Symbol &symbol, bool isAssociated,
   }
 }
 
-void CheckHelper::CheckPointer(const Symbol &symbol) {  // C852
+void CheckHelper::CheckPointer(const Symbol &symbol) { // C852
   CheckConflicting(symbol, Attr::POINTER, Attr::TARGET);
   CheckConflicting(symbol, Attr::POINTER, Attr::ALLOCATABLE);
   CheckConflicting(symbol, Attr::POINTER, Attr::INTRINSIC);
@@ -1105,7 +1104,7 @@ void CheckHelper::CheckPassArg(
   }
   const DeclTypeSpec *type{passArg.GetType()};
   if (!type) {
-    return;  // an error already occurred
+    return; // an error already occurred
   }
   const Symbol &typeSymbol{*proc.owner().GetSymbol()};
   const DerivedTypeSpec *derived{type->AsDerived()};
@@ -1224,7 +1223,7 @@ void CheckHelper::Check(const Scope &scope) {
   if (const Symbol * symbol{scope.symbol()}) {
     innermostSymbol_ = symbol;
   } else if (scope.IsDerivedType()) {
-    return;  // PDT instantiations have null symbol()
+    return; // PDT instantiations have null symbol()
   }
   for (const auto &set : scope.equivalenceSets()) {
     CheckEquivalenceSet(set);
@@ -1251,7 +1250,7 @@ void CheckHelper::CheckEquivalenceSet(const EquivalenceSet &set) {
       if (&object != &*iter) {
         if (auto *details{object.symbol.detailsIf<ObjectEntityDetails>()}) {
           if (details->commonBlock()) {
-            if (details->commonBlock() != &commonBlock) {  // 8.10.3 paragraph 1
+            if (details->commonBlock() != &commonBlock) { // 8.10.3 paragraph 1
               if (auto *msg{messages_.Say(object.symbol.name(),
                       "Two objects in the same EQUIVALENCE set may not be members of distinct COMMON blocks"_err_en_US)}) {
                 msg->Attach(iter->symbol.name(),
@@ -1323,7 +1322,7 @@ void SubprogramMatchHelper::Check(
     return;
   }
   bool nonRecursive1{symbol1.attrs().test(Attr::NON_RECURSIVE)};
-  if (nonRecursive1 != symbol2.attrs().test(Attr::NON_RECURSIVE)) {  // C1551
+  if (nonRecursive1 != symbol2.attrs().test(Attr::NON_RECURSIVE)) { // C1551
     Say(symbol1, symbol2,
         nonRecursive1
             ? "Module subprogram '%s' has NON_RECURSIVE prefix but"
@@ -1393,26 +1392,25 @@ void SubprogramMatchHelper::Check(
 void SubprogramMatchHelper::CheckDummyArg(const Symbol &symbol1,
     const Symbol &symbol2, const DummyArgument &arg1,
     const DummyArgument &arg2) {
-  std::visit(
-      common::visitors{
-          [&](const DummyDataObject &obj1, const DummyDataObject &obj2) {
-            CheckDummyDataObject(symbol1, symbol2, obj1, obj2);
-          },
-          [&](const DummyProcedure &proc1, const DummyProcedure &proc2) {
-            CheckDummyProcedure(symbol1, symbol2, proc1, proc2);
-          },
-          [&](const DummyDataObject &, const auto &) {
-            Say(symbol1, symbol2,
-                "Dummy argument '%s' is a data object; the corresponding"
-                " argument in the interface body is not"_err_en_US);
-          },
-          [&](const DummyProcedure &, const auto &) {
-            Say(symbol1, symbol2,
-                "Dummy argument '%s' is a procedure; the corresponding"
-                " argument in the interface body is not"_err_en_US);
-          },
-          [&](const auto &, const auto &) { DIE("can't happen"); },
-      },
+  std::visit(common::visitors{
+                 [&](const DummyDataObject &obj1, const DummyDataObject &obj2) {
+                   CheckDummyDataObject(symbol1, symbol2, obj1, obj2);
+                 },
+                 [&](const DummyProcedure &proc1, const DummyProcedure &proc2) {
+                   CheckDummyProcedure(symbol1, symbol2, proc1, proc2);
+                 },
+                 [&](const DummyDataObject &, const auto &) {
+                   Say(symbol1, symbol2,
+                       "Dummy argument '%s' is a data object; the corresponding"
+                       " argument in the interface body is not"_err_en_US);
+                 },
+                 [&](const DummyProcedure &, const auto &) {
+                   Say(symbol1, symbol2,
+                       "Dummy argument '%s' is a procedure; the corresponding"
+                       " argument in the interface body is not"_err_en_US);
+                 },
+                 [&](const auto &, const auto &) { DIE("can't happen"); },
+             },
       arg1.u, arg2.u);
 }
 
@@ -1459,7 +1457,7 @@ bool SubprogramMatchHelper::CheckSameIntent(const Symbol &symbol1,
 }
 
 // Report an error referring to first symbol with declaration of second symbol
-template<typename... A>
+template <typename... A>
 void SubprogramMatchHelper::Say(const Symbol &symbol1, const Symbol &symbol2,
     parser::MessageFixedText &&text, A &&... args) {
   auto &message{context.Say(symbol1.name(), std::move(text), symbol1.name(),
@@ -1467,7 +1465,7 @@ void SubprogramMatchHelper::Say(const Symbol &symbol1, const Symbol &symbol2,
   evaluate::AttachDeclaration(message, symbol2);
 }
 
-template<typename ATTRS>
+template <typename ATTRS>
 bool SubprogramMatchHelper::CheckSameAttrs(
     const Symbol &symbol1, const Symbol &symbol2, ATTRS attrs1, ATTRS attrs2) {
   if (attrs1 == attrs2) {
@@ -1511,4 +1509,4 @@ void CheckDeclarations(SemanticsContext &context) {
   CheckHelper{context}.Check();
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-declarations.h b/flang/lib/Semantics/check-declarations.h
index 98cea3249d4a..3b50bac4f5e7 100644
--- a/flang/lib/Semantics/check-declarations.h
+++ b/flang/lib/Semantics/check-declarations.h
@@ -13,5 +13,5 @@
 namespace Fortran::semantics {
 class SemanticsContext;
 void CheckDeclarations(SemanticsContext &);
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/flang/lib/Semantics/check-do-forall.cpp b/flang/lib/Semantics/check-do-forall.cpp
index 58b434b18a60..503a28412102 100644
--- a/flang/lib/Semantics/check-do-forall.cpp
+++ b/flang/lib/Semantics/check-do-forall.cpp
@@ -27,7 +27,7 @@ using ActualArgumentRef = common::Reference<const ActualArgument>;
 inline bool operator<(ActualArgumentRef x, ActualArgumentRef y) {
   return &*x < &*y;
 }
-}
+} // namespace Fortran::evaluate
 
 namespace Fortran::semantics {
 
@@ -55,7 +55,7 @@ static const parser::ConcurrentHeader &GetConcurrentHeader(
   return std::get<common::Indirection<parser::ConcurrentHeader>>(stmt.t)
       .value();
 }
-template<typename T>
+template <typename T>
 static const std::list<parser::ConcurrentControl> &GetControls(const T &x) {
   return std::get<std::list<parser::ConcurrentControl>>(
       GetConcurrentHeader(x).t);
@@ -73,7 +73,7 @@ static const parser::Name &GetDoVariable(
 }
 
 // Return the (possibly null)  name of the construct
-template<typename A>
+template <typename A>
 static const parser::Name *MaybeGetConstructName(const A &a) {
   return common::GetPtrFromOptional(std::get<0>(std::get<0>(a.t).statement.t));
 }
@@ -99,13 +99,13 @@ class DoConcurrentBodyEnforce {
 public:
   DoConcurrentBodyEnforce(
       SemanticsContext &context, parser::CharBlock doConcurrentSourcePosition)
-    : context_{context}, doConcurrentSourcePosition_{
-                             doConcurrentSourcePosition} {}
+      : context_{context}, doConcurrentSourcePosition_{
+                               doConcurrentSourcePosition} {}
   std::set<parser::Label> labels() { return labels_; }
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
 
-  template<typename T> bool Pre(const parser::Statement<T> &statement) {
+  template <typename T> bool Pre(const parser::Statement<T> &statement) {
     currentStatementSourcePosition_ = statement.source;
     if (statement.label.has_value()) {
       labels_.insert(*statement.label);
@@ -113,7 +113,7 @@ public:
     return true;
   }
 
-  template<typename T> bool Pre(const parser::UnlabeledStatement<T> &stmt) {
+  template <typename T> bool Pre(const parser::UnlabeledStatement<T> &stmt) {
     currentStatementSourcePosition_ = stmt.source;
     return true;
   }
@@ -246,7 +246,7 @@ public:
       if (name.symbol) {
         const Symbol &entity{*name.symbol};
         const DeclTypeSpec *entityType{entity.GetType()};
-        if ((entityType && entityType->IsPolymorphic()) ||  // POINTER case
+        if ((entityType && entityType->IsPolymorphic()) || // POINTER case
             MightDeallocatePolymorphic(entity, DeallocateAll)) {
           SayDeallocateOfPolymorph(
               currentStatementSourcePosition_, entity, reason);
@@ -330,7 +330,8 @@ public:
 
 private:
   // Return the (possibly null) name of the statement
-  template<typename A> static const parser::Name *MaybeGetStmtName(const A &a) {
+  template <typename A>
+  static const parser::Name *MaybeGetStmtName(const A &a) {
     return common::GetPtrFromOptional(std::get<0>(a.t));
   }
 
@@ -347,7 +348,7 @@ private:
   parser::CharBlock currentStatementSourcePosition_;
   SemanticsContext &context_;
   parser::CharBlock doConcurrentSourcePosition_;
-};  // class DoConcurrentBodyEnforce
+}; // class DoConcurrentBodyEnforce
 
 // Class for enforcing C1130 -- in a DO CONCURRENT with DEFAULT(NONE),
 // variables from enclosing scopes must have their locality specified
@@ -355,12 +356,12 @@ class DoConcurrentVariableEnforce {
 public:
   DoConcurrentVariableEnforce(
       SemanticsContext &context, parser::CharBlock doConcurrentSourcePosition)
-    : context_{context},
-      doConcurrentSourcePosition_{doConcurrentSourcePosition},
-      blockScope_{context.FindScope(doConcurrentSourcePosition_)} {}
+      : context_{context},
+        doConcurrentSourcePosition_{doConcurrentSourcePosition},
+        blockScope_{context.FindScope(doConcurrentSourcePosition_)} {}
 
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
 
   // Check to see if the name is a variable from an enclosing scope
   void Post(const parser::Name &name) {
@@ -382,13 +383,13 @@ private:
   SemanticsContext &context_;
   parser::CharBlock doConcurrentSourcePosition_;
   const Scope &blockScope_;
-};  // class DoConcurrentVariableEnforce
+}; // class DoConcurrentVariableEnforce
 
 // Find a DO or FORALL and enforce semantics checks on its body
 class DoContext {
 public:
   DoContext(SemanticsContext &context, IndexVarKind kind)
-    : context_{context}, kind_{kind} {}
+      : context_{context}, kind_{kind} {}
 
   // Mark this DO construct as a point of definition for the DO variables
   // or index-names it contains.  If they're already defined, emit an error
@@ -459,24 +460,23 @@ public:
               std::get_if<evaluate::ProcedureRef>(&assignment->u)}) {
         CheckForImpureCall(*proc);
       }
-      std::visit(
-          common::visitors{
-              [](const evaluate::Assignment::Intrinsic &) {},
-              [&](const evaluate::ProcedureRef &proc) {
-                CheckForImpureCall(proc);
-              },
-              [&](const evaluate::Assignment::BoundsSpec &bounds) {
-                for (const auto &bound : bounds) {
-                  CheckForImpureCall(SomeExpr{bound});
-                }
-              },
-              [&](const evaluate::Assignment::BoundsRemapping &bounds) {
-                for (const auto &bound : bounds) {
-                  CheckForImpureCall(SomeExpr{bound.first});
-                  CheckForImpureCall(SomeExpr{bound.second});
-                }
-              },
-          },
+      std::visit(common::visitors{
+                     [](const evaluate::Assignment::Intrinsic &) {},
+                     [&](const evaluate::ProcedureRef &proc) {
+                       CheckForImpureCall(proc);
+                     },
+                     [&](const evaluate::Assignment::BoundsSpec &bounds) {
+                       for (const auto &bound : bounds) {
+                         CheckForImpureCall(SomeExpr{bound});
+                       }
+                     },
+                     [&](const evaluate::Assignment::BoundsRemapping &bounds) {
+                       for (const auto &bound : bounds) {
+                         CheckForImpureCall(SomeExpr{bound.first});
+                         CheckForImpureCall(SomeExpr{bound.second});
+                       }
+                     },
+                 },
           assignment->u);
     }
   }
@@ -514,7 +514,7 @@ private:
                 sourceLocation, symType->IsNumeric(TypeCategory::Real));
           }
         }
-      }  // No messages for INTEGER
+      } // No messages for INTEGER
     }
   }
 
@@ -745,7 +745,7 @@ private:
     CheckConcurrentHeader(std::get<parser::ConcurrentHeader>(concurrent.t));
   }
 
-  template<typename T> void CheckForImpureCall(const T &x) {
+  template <typename T> void CheckForImpureCall(const T &x) {
     const auto &intrinsics{context_.foldingContext().intrinsics()};
     if (auto bad{FindImpureCall(intrinsics, x)}) {
       context_.Say(
@@ -808,7 +808,7 @@ private:
   SemanticsContext &context_;
   const IndexVarKind kind_;
   parser::CharBlock currentStatementSourcePosition_;
-};  // class DoContext
+}; // class DoContext
 
 void DoForallChecker::Enter(const parser::DoConstruct &doConstruct) {
   DoContext doContext{context_, IndexVarKind::DO};
@@ -851,7 +851,8 @@ static const parser::Name *MaybeGetNodeName(const ConstructNode &construct) {
       [&](const auto &x) { return MaybeGetConstructName(*x); }, construct);
 }
 
-template<typename A> static parser::CharBlock GetConstructPosition(const A &a) {
+template <typename A>
+static parser::CharBlock GetConstructPosition(const A &a) {
   return std::get<0>(a.t).source;
 }
 
@@ -887,25 +888,24 @@ static bool ConstructIsDoConcurrent(const ConstructNode &construct) {
 // leave DO CONCURRENT, CRITICAL, or CHANGE TEAM constructs.
 void DoForallChecker::CheckForBadLeave(
     StmtType stmtType, const ConstructNode &construct) const {
-  std::visit(
-      common::visitors{
-          [&](const parser::DoConstruct *doConstructPtr) {
-            if (doConstructPtr->IsDoConcurrent()) {
-              // C1135 and C1167 -- CYCLE and EXIT statements can't leave a
-              // DO CONCURRENT
-              SayBadLeave(stmtType, "DO CONCURRENT", construct);
-            }
-          },
-          [&](const parser::CriticalConstruct *) {
-            // C1135 and C1168 -- similarly, for CRITICAL
-            SayBadLeave(stmtType, "CRITICAL", construct);
-          },
-          [&](const parser::ChangeTeamConstruct *) {
-            // C1135 and C1168 -- similarly, for CHANGE TEAM
-            SayBadLeave(stmtType, "CHANGE TEAM", construct);
-          },
-          [](const auto *) {},
-      },
+  std::visit(common::visitors{
+                 [&](const parser::DoConstruct *doConstructPtr) {
+                   if (doConstructPtr->IsDoConcurrent()) {
+                     // C1135 and C1167 -- CYCLE and EXIT statements can't leave
+                     // a DO CONCURRENT
+                     SayBadLeave(stmtType, "DO CONCURRENT", construct);
+                   }
+                 },
+                 [&](const parser::CriticalConstruct *) {
+                   // C1135 and C1168 -- similarly, for CRITICAL
+                   SayBadLeave(stmtType, "CRITICAL", construct);
+                 },
+                 [&](const parser::ChangeTeamConstruct *) {
+                   // C1135 and C1168 -- similarly, for CHANGE TEAM
+                   SayBadLeave(stmtType, "CHANGE TEAM", construct);
+                 },
+                 [](const auto *) {},
+             },
       construct);
 }
 
@@ -914,7 +914,7 @@ static bool StmtMatchesConstruct(const parser::Name *stmtName,
     const ConstructNode &construct) {
   bool inDoConstruct{MaybeGetDoConstruct(construct) != nullptr};
   if (!stmtName) {
-    return inDoConstruct;  // Unlabeled statements match all DO constructs
+    return inDoConstruct; // Unlabeled statements match all DO constructs
   } else if (constructName && constructName->source == stmtName->source) {
     return stmtType == StmtType::EXIT || inDoConstruct;
   } else {
@@ -942,7 +942,7 @@ void DoForallChecker::CheckNesting(
     const parser::Name *constructName{MaybeGetNodeName(construct)};
     if (StmtMatchesConstruct(stmtName, stmtType, constructName, construct)) {
       CheckDoConcurrentExit(stmtType, construct);
-      return;  // We got a match, so we're finished checking
+      return; // We got a match, so we're finished checking
     }
     CheckForBadLeave(stmtType, construct);
   }
@@ -979,7 +979,7 @@ static void CheckIfArgIsDoVar(const evaluate::ActualArgument &arg,
         if (intent == common::Intent::Out) {
           context.CheckIndexVarRedefine(location, *var);
         } else {
-          context.WarnIndexVarRedefine(location, *var);  // INTENT(INOUT)
+          context.WarnIndexVarRedefine(location, *var); // INTENT(INOUT)
         }
       }
     }
@@ -1002,7 +1002,7 @@ void DoForallChecker::Leave(const parser::CallStmt &callStmt) {
     const evaluate::ActualArguments &checkedArgs{typedCall->arguments()};
     for (const auto &checkedOptionalArg : checkedArgs) {
       if (parsedArgIter == parsedArgs.end()) {
-        break;  // No more parsed arguments, we're done.
+        break; // No more parsed arguments, we're done.
       }
       const auto &parsedArg{std::get<parser::ActualArg>(parsedArgIter->t)};
       ++parsedArgIter;
@@ -1028,8 +1028,8 @@ void DoForallChecker::Leave(const parser::ConnectSpec &connectSpec) {
 using ActualArgumentSet = std::set<evaluate::ActualArgumentRef>;
 
 struct CollectActualArgumentsHelper
-  : public evaluate::SetTraverse<CollectActualArgumentsHelper,
-        ActualArgumentSet> {
+    : public evaluate::SetTraverse<CollectActualArgumentsHelper,
+          ActualArgumentSet> {
   using Base = SetTraverse<CollectActualArgumentsHelper, ActualArgumentSet>;
   CollectActualArgumentsHelper() : Base{*this} {}
   using Base::operator();
@@ -1038,7 +1038,7 @@ struct CollectActualArgumentsHelper
   }
 };
 
-template<typename A> ActualArgumentSet CollectActualArguments(const A &x) {
+template <typename A> ActualArgumentSet CollectActualArguments(const A &x) {
   return CollectActualArgumentsHelper{}(x);
 }
 
@@ -1078,4 +1078,4 @@ void DoForallChecker::Leave(const parser::StatVariable &statVariable) {
   context_.CheckIndexVarRedefine(statVariable.v.thing.thing);
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-do-forall.h b/flang/lib/Semantics/check-do-forall.h
index f820926d9199..8f0cdc75ac97 100644
--- a/flang/lib/Semantics/check-do-forall.h
+++ b/flang/lib/Semantics/check-do-forall.h
@@ -27,7 +27,7 @@ struct InquireSpec;
 struct IoControlSpec;
 struct OutputImpliedDo;
 struct StatVariable;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -65,5 +65,5 @@ private:
   void CheckForBadLeave(StmtType, const ConstructNode &) const;
   void CheckNesting(StmtType, const parser::Name *) const;
 };
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/flang/lib/Semantics/check-if-stmt.cpp b/flang/lib/Semantics/check-if-stmt.cpp
index b9693389f5d9..6aca57c99207 100644
--- a/flang/lib/Semantics/check-if-stmt.cpp
+++ b/flang/lib/Semantics/check-if-stmt.cpp
@@ -24,4 +24,4 @@ void IfStmtChecker::Leave(const parser::IfStmt &ifStmt) {
   }
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-if-stmt.h b/flang/lib/Semantics/check-if-stmt.h
index 21ae269d2049..ea4a5c22bd31 100644
--- a/flang/lib/Semantics/check-if-stmt.h
+++ b/flang/lib/Semantics/check-if-stmt.h
@@ -24,5 +24,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_IF_STMT_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_IF_STMT_H_
diff --git a/flang/lib/Semantics/check-io.cpp b/flang/lib/Semantics/check-io.cpp
index a3de44ef8dd0..d670c792eb81 100644
--- a/flang/lib/Semantics/check-io.cpp
+++ b/flang/lib/Semantics/check-io.cpp
@@ -21,15 +21,15 @@ class FormatErrorReporter {
 public:
   FormatErrorReporter(SemanticsContext &context,
       const parser::CharBlock &formatCharBlock, int errorAllowance = 3)
-    : context_{context}, formatCharBlock_{formatCharBlock},
-      errorAllowance_{errorAllowance} {}
+      : context_{context}, formatCharBlock_{formatCharBlock},
+        errorAllowance_{errorAllowance} {}
 
   bool Say(const common::FormatMessage &);
 
 private:
   SemanticsContext &context_;
   const parser::CharBlock &formatCharBlock_;
-  int errorAllowance_;  // initialized to maximum number of errors to report
+  int errorAllowance_; // initialized to maximum number of errors to report
 };
 
 bool FormatErrorReporter::Say(const common::FormatMessage &msg) {
@@ -56,7 +56,7 @@ bool FormatErrorReporter::Say(const common::FormatMessage &msg) {
 void IoChecker::Enter(
     const parser::Statement<common::Indirection<parser::FormatStmt>> &stmt) {
   if (!stmt.label) {
-    context_.Say("Format statement must be labeled"_err_en_US);  // C1301
+    context_.Say("Format statement must be labeled"_err_en_US); // C1301
   }
   const char *formatStart{static_cast<const char *>(
       std::memchr(stmt.source.begin(), '(', stmt.source.size()))};
@@ -71,19 +71,20 @@ void IoChecker::Enter(
     validator.Check();
     break;
   }
-  case 2: {  // TODO: Get this to work.
+  case 2: { // TODO: Get this to work.
     common::FormatValidator<char16_t> validator{
         /*???*/ nullptr, /*???*/ 0, reporterWrapper};
     validator.Check();
     break;
   }
-  case 4: {  // TODO: Get this to work.
+  case 4: { // TODO: Get this to work.
     common::FormatValidator<char32_t> validator{
         /*???*/ nullptr, /*???*/ 0, reporterWrapper};
     validator.Check();
     break;
   }
-  default: CRASH_NO_CASE;
+  default:
+    CRASH_NO_CASE;
   }
 }
 
@@ -98,20 +99,48 @@ void IoChecker::Enter(const parser::ConnectSpec::CharExpr &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::ConnectSpec::CharExpr::Kind;
   switch (std::get<ParseKind>(spec.t)) {
-  case ParseKind::Access: specKind = IoSpecKind::Access; break;
-  case ParseKind::Action: specKind = IoSpecKind::Action; break;
-  case ParseKind::Asynchronous: specKind = IoSpecKind::Asynchronous; break;
-  case ParseKind::Blank: specKind = IoSpecKind::Blank; break;
-  case ParseKind::Decimal: specKind = IoSpecKind::Decimal; break;
-  case ParseKind::Delim: specKind = IoSpecKind::Delim; break;
-  case ParseKind::Encoding: specKind = IoSpecKind::Encoding; break;
-  case ParseKind::Form: specKind = IoSpecKind::Form; break;
-  case ParseKind::Pad: specKind = IoSpecKind::Pad; break;
-  case ParseKind::Position: specKind = IoSpecKind::Position; break;
-  case ParseKind::Round: specKind = IoSpecKind::Round; break;
-  case ParseKind::Sign: specKind = IoSpecKind::Sign; break;
-  case ParseKind::Convert: specKind = IoSpecKind::Convert; break;
-  case ParseKind::Dispose: specKind = IoSpecKind::Dispose; break;
+  case ParseKind::Access:
+    specKind = IoSpecKind::Access;
+    break;
+  case ParseKind::Action:
+    specKind = IoSpecKind::Action;
+    break;
+  case ParseKind::Asynchronous:
+    specKind = IoSpecKind::Asynchronous;
+    break;
+  case ParseKind::Blank:
+    specKind = IoSpecKind::Blank;
+    break;
+  case ParseKind::Decimal:
+    specKind = IoSpecKind::Decimal;
+    break;
+  case ParseKind::Delim:
+    specKind = IoSpecKind::Delim;
+    break;
+  case ParseKind::Encoding:
+    specKind = IoSpecKind::Encoding;
+    break;
+  case ParseKind::Form:
+    specKind = IoSpecKind::Form;
+    break;
+  case ParseKind::Pad:
+    specKind = IoSpecKind::Pad;
+    break;
+  case ParseKind::Position:
+    specKind = IoSpecKind::Position;
+    break;
+  case ParseKind::Round:
+    specKind = IoSpecKind::Round;
+    break;
+  case ParseKind::Sign:
+    specKind = IoSpecKind::Sign;
+    break;
+  case ParseKind::Convert:
+    specKind = IoSpecKind::Convert;
+    break;
+  case ParseKind::Dispose:
+    specKind = IoSpecKind::Dispose;
+    break;
   }
   SetSpecifier(specKind);
   if (const std::optional<std::string> charConst{GetConstExpr<std::string>(
@@ -137,7 +166,7 @@ void IoChecker::Enter(const parser::ConnectSpec::Recl &spec) {
     if (*recl <= 0) {
       context_.Say(parser::FindSourceLocation(spec),
           "RECL value (%jd) must be positive"_err_en_US,
-          std::move(static_cast<std::intmax_t>(*recl)));  // 12.5.6.15
+          std::move(static_cast<std::intmax_t>(*recl))); // 12.5.6.15
     }
   }
 }
@@ -204,7 +233,8 @@ void IoChecker::Enter(const parser::Format &spec) {
               validator.Check();
               break;
             }
-            default: CRASH_NO_CASE;
+            default:
+              CRASH_NO_CASE;
             }
           },
       },
@@ -224,7 +254,7 @@ void IoChecker::Enter(const parser::IdVariable &spec) {
   if (kind < defaultKind) {
     context_.Say(
         "ID kind (%d) is smaller than default INTEGER kind (%d)"_err_en_US,
-        std::move(kind), std::move(defaultKind));  // C1229
+        std::move(kind), std::move(defaultKind)); // C1229
   }
 }
 
@@ -240,7 +270,7 @@ void IoChecker::Enter(const parser::InputItem &spec) {
         // This check may be superseded by C928 or C1002.
         context_.Say(name.source,
             "'%s' must not be a whole assumed size array"_err_en_US,
-            name.source);  // C1231
+            name.source); // C1231
       }
     }
   }
@@ -257,31 +287,81 @@ void IoChecker::Enter(const parser::InquireSpec::CharVar &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::InquireSpec::CharVar::Kind;
   switch (std::get<ParseKind>(spec.t)) {
-  case ParseKind::Access: specKind = IoSpecKind::Access; break;
-  case ParseKind::Action: specKind = IoSpecKind::Action; break;
-  case ParseKind::Asynchronous: specKind = IoSpecKind::Asynchronous; break;
-  case ParseKind::Blank: specKind = IoSpecKind::Blank; break;
-  case ParseKind::Decimal: specKind = IoSpecKind::Decimal; break;
-  case ParseKind::Delim: specKind = IoSpecKind::Delim; break;
-  case ParseKind::Direct: specKind = IoSpecKind::Direct; break;
-  case ParseKind::Encoding: specKind = IoSpecKind::Encoding; break;
-  case ParseKind::Form: specKind = IoSpecKind::Form; break;
-  case ParseKind::Formatted: specKind = IoSpecKind::Formatted; break;
-  case ParseKind::Iomsg: specKind = IoSpecKind::Iomsg; break;
-  case ParseKind::Name: specKind = IoSpecKind::Name; break;
-  case ParseKind::Pad: specKind = IoSpecKind::Pad; break;
-  case ParseKind::Position: specKind = IoSpecKind::Position; break;
-  case ParseKind::Read: specKind = IoSpecKind::Read; break;
-  case ParseKind::Readwrite: specKind = IoSpecKind::Readwrite; break;
-  case ParseKind::Round: specKind = IoSpecKind::Round; break;
-  case ParseKind::Sequential: specKind = IoSpecKind::Sequential; break;
-  case ParseKind::Sign: specKind = IoSpecKind::Sign; break;
-  case ParseKind::Status: specKind = IoSpecKind::Status; break;
-  case ParseKind::Stream: specKind = IoSpecKind::Stream; break;
-  case ParseKind::Unformatted: specKind = IoSpecKind::Unformatted; break;
-  case ParseKind::Write: specKind = IoSpecKind::Write; break;
-  case ParseKind::Convert: specKind = IoSpecKind::Convert; break;
-  case ParseKind::Dispose: specKind = IoSpecKind::Dispose; break;
+  case ParseKind::Access:
+    specKind = IoSpecKind::Access;
+    break;
+  case ParseKind::Action:
+    specKind = IoSpecKind::Action;
+    break;
+  case ParseKind::Asynchronous:
+    specKind = IoSpecKind::Asynchronous;
+    break;
+  case ParseKind::Blank:
+    specKind = IoSpecKind::Blank;
+    break;
+  case ParseKind::Decimal:
+    specKind = IoSpecKind::Decimal;
+    break;
+  case ParseKind::Delim:
+    specKind = IoSpecKind::Delim;
+    break;
+  case ParseKind::Direct:
+    specKind = IoSpecKind::Direct;
+    break;
+  case ParseKind::Encoding:
+    specKind = IoSpecKind::Encoding;
+    break;
+  case ParseKind::Form:
+    specKind = IoSpecKind::Form;
+    break;
+  case ParseKind::Formatted:
+    specKind = IoSpecKind::Formatted;
+    break;
+  case ParseKind::Iomsg:
+    specKind = IoSpecKind::Iomsg;
+    break;
+  case ParseKind::Name:
+    specKind = IoSpecKind::Name;
+    break;
+  case ParseKind::Pad:
+    specKind = IoSpecKind::Pad;
+    break;
+  case ParseKind::Position:
+    specKind = IoSpecKind::Position;
+    break;
+  case ParseKind::Read:
+    specKind = IoSpecKind::Read;
+    break;
+  case ParseKind::Readwrite:
+    specKind = IoSpecKind::Readwrite;
+    break;
+  case ParseKind::Round:
+    specKind = IoSpecKind::Round;
+    break;
+  case ParseKind::Sequential:
+    specKind = IoSpecKind::Sequential;
+    break;
+  case ParseKind::Sign:
+    specKind = IoSpecKind::Sign;
+    break;
+  case ParseKind::Status:
+    specKind = IoSpecKind::Status;
+    break;
+  case ParseKind::Stream:
+    specKind = IoSpecKind::Stream;
+    break;
+  case ParseKind::Unformatted:
+    specKind = IoSpecKind::Unformatted;
+    break;
+  case ParseKind::Write:
+    specKind = IoSpecKind::Write;
+    break;
+  case ParseKind::Convert:
+    specKind = IoSpecKind::Convert;
+    break;
+  case ParseKind::Dispose:
+    specKind = IoSpecKind::Dispose;
+    break;
   }
   SetSpecifier(specKind);
 }
@@ -290,12 +370,24 @@ void IoChecker::Enter(const parser::InquireSpec::IntVar &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::InquireSpec::IntVar::Kind;
   switch (std::get<parser::InquireSpec::IntVar::Kind>(spec.t)) {
-  case ParseKind::Iostat: specKind = IoSpecKind::Iostat; break;
-  case ParseKind::Nextrec: specKind = IoSpecKind::Nextrec; break;
-  case ParseKind::Number: specKind = IoSpecKind::Number; break;
-  case ParseKind::Pos: specKind = IoSpecKind::Pos; break;
-  case ParseKind::Recl: specKind = IoSpecKind::Recl; break;
-  case ParseKind::Size: specKind = IoSpecKind::Size; break;
+  case ParseKind::Iostat:
+    specKind = IoSpecKind::Iostat;
+    break;
+  case ParseKind::Nextrec:
+    specKind = IoSpecKind::Nextrec;
+    break;
+  case ParseKind::Number:
+    specKind = IoSpecKind::Number;
+    break;
+  case ParseKind::Pos:
+    specKind = IoSpecKind::Pos;
+    break;
+  case ParseKind::Recl:
+    specKind = IoSpecKind::Recl;
+    break;
+  case ParseKind::Size:
+    specKind = IoSpecKind::Size;
+    break;
   }
   SetSpecifier(specKind);
 }
@@ -304,10 +396,18 @@ void IoChecker::Enter(const parser::InquireSpec::LogVar &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::InquireSpec::LogVar::Kind;
   switch (std::get<parser::InquireSpec::LogVar::Kind>(spec.t)) {
-  case ParseKind::Exist: specKind = IoSpecKind::Exist; break;
-  case ParseKind::Named: specKind = IoSpecKind::Named; break;
-  case ParseKind::Opened: specKind = IoSpecKind::Opened; break;
-  case ParseKind::Pending: specKind = IoSpecKind::Pending; break;
+  case ParseKind::Exist:
+    specKind = IoSpecKind::Exist;
+    break;
+  case ParseKind::Named:
+    specKind = IoSpecKind::Named;
+    break;
+  case ParseKind::Opened:
+    specKind = IoSpecKind::Opened;
+    break;
+  case ParseKind::Pending:
+    specKind = IoSpecKind::Pending;
+    break;
   }
   SetSpecifier(specKind);
 }
@@ -328,7 +428,7 @@ void IoChecker::Enter(const parser::IoControlSpec::Asynchronous &spec) {
     flags_.set(
         Flag::AsynchronousYes, parser::ToUpperCaseLetters(*charConst) == "YES");
     CheckStringValue(IoSpecKind::Asynchronous, *charConst,
-        parser::FindSourceLocation(spec));  // C1223
+        parser::FindSourceLocation(spec)); // C1223
   }
 }
 
@@ -336,13 +436,27 @@ void IoChecker::Enter(const parser::IoControlSpec::CharExpr &spec) {
   IoSpecKind specKind{};
   using ParseKind = parser::IoControlSpec::CharExpr::Kind;
   switch (std::get<ParseKind>(spec.t)) {
-  case ParseKind::Advance: specKind = IoSpecKind::Advance; break;
-  case ParseKind::Blank: specKind = IoSpecKind::Blank; break;
-  case ParseKind::Decimal: specKind = IoSpecKind::Decimal; break;
-  case ParseKind::Delim: specKind = IoSpecKind::Delim; break;
-  case ParseKind::Pad: specKind = IoSpecKind::Pad; break;
-  case ParseKind::Round: specKind = IoSpecKind::Round; break;
-  case ParseKind::Sign: specKind = IoSpecKind::Sign; break;
+  case ParseKind::Advance:
+    specKind = IoSpecKind::Advance;
+    break;
+  case ParseKind::Blank:
+    specKind = IoSpecKind::Blank;
+    break;
+  case ParseKind::Decimal:
+    specKind = IoSpecKind::Decimal;
+    break;
+  case ParseKind::Delim:
+    specKind = IoSpecKind::Delim;
+    break;
+  case ParseKind::Pad:
+    specKind = IoSpecKind::Pad;
+    break;
+  case ParseKind::Round:
+    specKind = IoSpecKind::Round;
+    break;
+  case ParseKind::Sign:
+    specKind = IoSpecKind::Sign;
+    break;
   }
   SetSpecifier(specKind);
   if (const std::optional<std::string> charConst{GetConstExpr<std::string>(
@@ -373,7 +487,7 @@ void IoChecker::Enter(const parser::IoUnit &spec) {
     if (auto expr{GetExpr(*var)}) {
       if (!ExprTypeKindIsDefault(*expr, context_)) {
         // This may be too restrictive; other kinds may be valid.
-        context_.Say(  // C1202
+        context_.Say( // C1202
             "Invalid character kind for an internal file variable"_err_en_US);
       }
     }
@@ -429,28 +543,28 @@ void IoChecker::Enter(const parser::StatVariable &) {
 void IoChecker::Leave(const parser::BackspaceStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1240
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1240
   Done();
 }
 
 void IoChecker::Leave(const parser::CloseStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1208
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1208
   Done();
 }
 
 void IoChecker::Leave(const parser::EndfileStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1240
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1240
   Done();
 }
 
 void IoChecker::Leave(const parser::FlushStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1243
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1243
   Done();
 }
 
@@ -460,9 +574,9 @@ void IoChecker::Leave(const parser::InquireStmt &stmt) {
     // Inquire by unit or by file (vs. by output list).
     CheckForRequiredSpecifier(
         flags_.test(Flag::NumberUnit) || specifierSet_.test(IoSpecKind::File),
-        "UNIT number or FILE");  // C1246
-    CheckForProhibitedSpecifier(IoSpecKind::File, IoSpecKind::Unit);  // C1246
-    CheckForRequiredSpecifier(IoSpecKind::Id, IoSpecKind::Pending);  // C1248
+        "UNIT number or FILE"); // C1246
+    CheckForProhibitedSpecifier(IoSpecKind::File, IoSpecKind::Unit); // C1246
+    CheckForRequiredSpecifier(IoSpecKind::Id, IoSpecKind::Pending); // C1248
   }
   Done();
 }
@@ -471,31 +585,31 @@ void IoChecker::Leave(const parser::OpenStmt &) {
   CheckForPureSubprogram();
   CheckForRequiredSpecifier(specifierSet_.test(IoSpecKind::Unit) ||
           specifierSet_.test(IoSpecKind::Newunit),
-      "UNIT or NEWUNIT");  // C1204, C1205
+      "UNIT or NEWUNIT"); // C1204, C1205
   CheckForProhibitedSpecifier(
-      IoSpecKind::Newunit, IoSpecKind::Unit);  // C1204, C1205
+      IoSpecKind::Newunit, IoSpecKind::Unit); // C1204, C1205
   CheckForRequiredSpecifier(flags_.test(Flag::StatusNew), "STATUS='NEW'",
-      IoSpecKind::File);  // 12.5.6.10
+      IoSpecKind::File); // 12.5.6.10
   CheckForRequiredSpecifier(flags_.test(Flag::StatusReplace),
-      "STATUS='REPLACE'", IoSpecKind::File);  // 12.5.6.10
+      "STATUS='REPLACE'", IoSpecKind::File); // 12.5.6.10
   CheckForProhibitedSpecifier(flags_.test(Flag::StatusScratch),
-      "STATUS='SCRATCH'", IoSpecKind::File);  // 12.5.6.10
+      "STATUS='SCRATCH'", IoSpecKind::File); // 12.5.6.10
   if (flags_.test(Flag::KnownStatus)) {
     CheckForRequiredSpecifier(IoSpecKind::Newunit,
         specifierSet_.test(IoSpecKind::File) ||
             flags_.test(Flag::StatusScratch),
-        "FILE or STATUS='SCRATCH'");  // 12.5.6.12
+        "FILE or STATUS='SCRATCH'"); // 12.5.6.12
   } else {
     CheckForRequiredSpecifier(IoSpecKind::Newunit,
         specifierSet_.test(IoSpecKind::File) ||
             specifierSet_.test(IoSpecKind::Status),
-        "FILE or STATUS");  // 12.5.6.12
+        "FILE or STATUS"); // 12.5.6.12
   }
   if (flags_.test(Flag::KnownAccess)) {
     CheckForRequiredSpecifier(flags_.test(Flag::AccessDirect),
-        "ACCESS='DIRECT'", IoSpecKind::Recl);  // 12.5.6.15
+        "ACCESS='DIRECT'", IoSpecKind::Recl); // 12.5.6.15
     CheckForProhibitedSpecifier(flags_.test(Flag::AccessStream),
-        "STATUS='STREAM'", IoSpecKind::Recl);  // 12.5.6.15
+        "STATUS='STREAM'", IoSpecKind::Recl); // 12.5.6.15
   }
   Done();
 }
@@ -547,29 +661,29 @@ void IoChecker::Leave(const parser::ReadStmt &readStmt) {
     return;
   }
   LeaveReadWrite();
-  CheckForProhibitedSpecifier(IoSpecKind::Delim);  // C1212
-  CheckForProhibitedSpecifier(IoSpecKind::Sign);  // C1212
-  CheckForProhibitedSpecifier(IoSpecKind::Rec, IoSpecKind::End);  // C1220
+  CheckForProhibitedSpecifier(IoSpecKind::Delim); // C1212
+  CheckForProhibitedSpecifier(IoSpecKind::Sign); // C1212
+  CheckForProhibitedSpecifier(IoSpecKind::Rec, IoSpecKind::End); // C1220
   CheckForRequiredSpecifier(IoSpecKind::Eor,
       specifierSet_.test(IoSpecKind::Advance) && !flags_.test(Flag::AdvanceYes),
-      "ADVANCE with value 'NO'");  // C1222 + 12.6.2.1p2
+      "ADVANCE with value 'NO'"); // C1222 + 12.6.2.1p2
   CheckForRequiredSpecifier(IoSpecKind::Blank, flags_.test(Flag::FmtOrNml),
-      "FMT or NML");  // C1227
+      "FMT or NML"); // C1227
   CheckForRequiredSpecifier(
-      IoSpecKind::Pad, flags_.test(Flag::FmtOrNml), "FMT or NML");  // C1227
+      IoSpecKind::Pad, flags_.test(Flag::FmtOrNml), "FMT or NML"); // C1227
   Done();
 }
 
 void IoChecker::Leave(const parser::RewindStmt &) {
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1240
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1240
   CheckForPureSubprogram();
   Done();
 }
 
 void IoChecker::Leave(const parser::WaitStmt &) {
   CheckForRequiredSpecifier(
-      flags_.test(Flag::NumberUnit), "UNIT number");  // C1237
+      flags_.test(Flag::NumberUnit), "UNIT number"); // C1237
   CheckForPureSubprogram();
   Done();
 }
@@ -579,50 +693,50 @@ void IoChecker::Leave(const parser::WriteStmt &) {
     CheckForPureSubprogram();
   }
   LeaveReadWrite();
-  CheckForProhibitedSpecifier(IoSpecKind::Blank);  // C1213
-  CheckForProhibitedSpecifier(IoSpecKind::End);  // C1213
-  CheckForProhibitedSpecifier(IoSpecKind::Eor);  // C1213
-  CheckForProhibitedSpecifier(IoSpecKind::Pad);  // C1213
-  CheckForProhibitedSpecifier(IoSpecKind::Size);  // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::Blank); // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::End); // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::Eor); // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::Pad); // C1213
+  CheckForProhibitedSpecifier(IoSpecKind::Size); // C1213
   CheckForRequiredSpecifier(
-      IoSpecKind::Sign, flags_.test(Flag::FmtOrNml), "FMT or NML");  // C1227
+      IoSpecKind::Sign, flags_.test(Flag::FmtOrNml), "FMT or NML"); // C1227
   CheckForRequiredSpecifier(IoSpecKind::Delim,
       flags_.test(Flag::StarFmt) || specifierSet_.test(IoSpecKind::Nml),
-      "FMT=* or NML");  // C1228
+      "FMT=* or NML"); // C1228
   Done();
 }
 
 void IoChecker::LeaveReadWrite() const {
-  CheckForRequiredSpecifier(IoSpecKind::Unit);  // C1211
-  CheckForProhibitedSpecifier(IoSpecKind::Nml, IoSpecKind::Rec);  // C1216
-  CheckForProhibitedSpecifier(IoSpecKind::Nml, IoSpecKind::Fmt);  // C1216
+  CheckForRequiredSpecifier(IoSpecKind::Unit); // C1211
+  CheckForProhibitedSpecifier(IoSpecKind::Nml, IoSpecKind::Rec); // C1216
+  CheckForProhibitedSpecifier(IoSpecKind::Nml, IoSpecKind::Fmt); // C1216
   CheckForProhibitedSpecifier(
-      IoSpecKind::Nml, flags_.test(Flag::DataList), "a data list");  // C1216
+      IoSpecKind::Nml, flags_.test(Flag::DataList), "a data list"); // C1216
   CheckForProhibitedSpecifier(flags_.test(Flag::InternalUnit),
-      "UNIT=internal-file", IoSpecKind::Pos);  // C1219
+      "UNIT=internal-file", IoSpecKind::Pos); // C1219
   CheckForProhibitedSpecifier(flags_.test(Flag::InternalUnit),
-      "UNIT=internal-file", IoSpecKind::Rec);  // C1219
+      "UNIT=internal-file", IoSpecKind::Rec); // C1219
   CheckForProhibitedSpecifier(
-      flags_.test(Flag::StarUnit), "UNIT=*", IoSpecKind::Pos);  // C1219
+      flags_.test(Flag::StarUnit), "UNIT=*", IoSpecKind::Pos); // C1219
   CheckForProhibitedSpecifier(
-      flags_.test(Flag::StarUnit), "UNIT=*", IoSpecKind::Rec);  // C1219
+      flags_.test(Flag::StarUnit), "UNIT=*", IoSpecKind::Rec); // C1219
   CheckForProhibitedSpecifier(
-      IoSpecKind::Rec, flags_.test(Flag::StarFmt), "FMT=*");  // C1220
+      IoSpecKind::Rec, flags_.test(Flag::StarFmt), "FMT=*"); // C1220
   CheckForRequiredSpecifier(IoSpecKind::Advance,
       flags_.test(Flag::CharFmt) || flags_.test(Flag::LabelFmt),
-      "an explicit format");  // C1221
+      "an explicit format"); // C1221
   CheckForProhibitedSpecifier(IoSpecKind::Advance,
-      flags_.test(Flag::InternalUnit), "UNIT=internal-file");  // C1221
+      flags_.test(Flag::InternalUnit), "UNIT=internal-file"); // C1221
   CheckForRequiredSpecifier(flags_.test(Flag::AsynchronousYes),
       "ASYNCHRONOUS='YES'", flags_.test(Flag::NumberUnit),
-      "UNIT=number");  // C1224
+      "UNIT=number"); // C1224
   CheckForRequiredSpecifier(IoSpecKind::Id, flags_.test(Flag::AsynchronousYes),
-      "ASYNCHRONOUS='YES'");  // C1225
-  CheckForProhibitedSpecifier(IoSpecKind::Pos, IoSpecKind::Rec);  // C1226
+      "ASYNCHRONOUS='YES'"); // C1225
+  CheckForProhibitedSpecifier(IoSpecKind::Pos, IoSpecKind::Rec); // C1226
   CheckForRequiredSpecifier(IoSpecKind::Decimal, flags_.test(Flag::FmtOrNml),
-      "FMT or NML");  // C1227
+      "FMT or NML"); // C1227
   CheckForRequiredSpecifier(IoSpecKind::Round, flags_.test(Flag::FmtOrNml),
-      "FMT or NML");  // C1227
+      "FMT or NML"); // C1227
 }
 
 void IoChecker::SetSpecifier(IoSpecKind specKind) {
@@ -755,11 +869,11 @@ void IoChecker::CheckForProhibitedSpecifier(
   }
 }
 
-void IoChecker::CheckForPureSubprogram() const {  // C1597
+void IoChecker::CheckForPureSubprogram() const { // C1597
   CHECK(context_.location());
   if (FindPureProcedureContaining(context_.FindScope(*context_.location()))) {
     context_.Say("External I/O is not allowed in a pure subprogram"_err_en_US);
   }
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-io.h b/flang/lib/Semantics/check-io.h
index c43f62b1ae03..6763657e623b 100644
--- a/flang/lib/Semantics/check-io.h
+++ b/flang/lib/Semantics/check-io.h
@@ -85,7 +85,7 @@ private:
       AdvanceYes, AsynchronousYes, KnownStatus, StatusNew, StatusReplace,
       StatusScratch, DataList)
 
-  template<typename R, typename T> std::optional<R> GetConstExpr(const T &x) {
+  template <typename R, typename T> std::optional<R> GetConstExpr(const T &x) {
     using DefaultCharConstantType =
         evaluate::Type<common::TypeCategory::Character, 1>;
     if (const SomeExpr * expr{GetExpr(x)}) {
@@ -138,5 +138,5 @@ private:
   common::EnumSet<Flag, Flag_enumSize> flags_;
 };
 
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_IO_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_IO_H_
diff --git a/flang/lib/Semantics/check-namelist.cpp b/flang/lib/Semantics/check-namelist.cpp
index c720552bfe08..630840ab5d92 100644
--- a/flang/lib/Semantics/check-namelist.cpp
+++ b/flang/lib/Semantics/check-namelist.cpp
@@ -18,14 +18,14 @@ void NamelistChecker::Leave(const parser::NamelistStmt &nmlStmt) {
         if (nmlObjSymbol && nmlObjSymbol->has<ObjectEntityDetails>()) {
           const auto *symDetails{
               std::get_if<ObjectEntityDetails>(&nmlObjSymbol->details())};
-          if (symDetails && symDetails->IsAssumedSize()) {  // C8104
+          if (symDetails && symDetails->IsAssumedSize()) { // C8104
             context_.Say(nmlObjName.source,
                 "A namelist group object '%s' must not be"
                 " assumed-size"_err_en_US,
                 nmlObjSymbol->name());
           }
           if (nml->attrs().test(Attr::PUBLIC) &&
-              nmlObjSymbol->attrs().test(Attr::PRIVATE)) {  // C8105
+              nmlObjSymbol->attrs().test(Attr::PRIVATE)) { // C8105
             context_.Say(nmlObjName.source,
                 "A PRIVATE namelist group object '%s' must not be in a "
                 "PUBLIC namelist"_err_en_US,
@@ -37,4 +37,4 @@ void NamelistChecker::Leave(const parser::NamelistStmt &nmlStmt) {
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-namelist.h b/flang/lib/Semantics/check-namelist.h
index 7989ed404bcf..a23b7d717b02 100644
--- a/flang/lib/Semantics/check-namelist.h
+++ b/flang/lib/Semantics/check-namelist.h
@@ -21,5 +21,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_NAMELIST_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_NAMELIST_H_
diff --git a/flang/lib/Semantics/check-nullify.cpp b/flang/lib/Semantics/check-nullify.cpp
index c7595f476d39..5c3396e8128d 100644
--- a/flang/lib/Semantics/check-nullify.cpp
+++ b/flang/lib/Semantics/check-nullify.cpp
@@ -32,7 +32,7 @@ void NullifyChecker::Leave(const parser::NullifyStmt &nullifyStmt) {
               } else if (!IsVariableName(symbol) && !IsProcName(symbol)) {
                 messages.Say(name.source,
                     "name in NULLIFY statement must be a variable or procedure pointer name"_err_en_US);
-              } else if (!IsPointer(symbol)) {  // C951
+              } else if (!IsPointer(symbol)) { // C951
                 messages.Say(name.source,
                     "name in NULLIFY statement must have the POINTER attribute"_err_en_US);
               } else if (pure) {
@@ -42,7 +42,7 @@ void NullifyChecker::Leave(const parser::NullifyStmt &nullifyStmt) {
             [&](const parser::StructureComponent &structureComponent) {
               evaluate::ExpressionAnalyzer analyzer{context_};
               if (MaybeExpr checked{analyzer.Analyze(structureComponent)}) {
-                if (!IsPointer(*structureComponent.component.symbol)) {  // C951
+                if (!IsPointer(*structureComponent.component.symbol)) { // C951
                   messages.Say(structureComponent.component.source,
                       "component in NULLIFY statement must have the POINTER attribute"_err_en_US);
                 } else if (pure) {
@@ -64,4 +64,4 @@ void NullifyChecker::Leave(const parser::NullifyStmt &nullifyStmt) {
   // Some dependencies can be found compile time or at
   // runtime, but for now we choose to skip such checks.
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-nullify.h b/flang/lib/Semantics/check-nullify.h
index 508631a9649b..7b9191508e3b 100644
--- a/flang/lib/Semantics/check-nullify.h
+++ b/flang/lib/Semantics/check-nullify.h
@@ -24,5 +24,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_NULLIFY_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_NULLIFY_H_
diff --git a/flang/lib/Semantics/check-omp-structure.cpp b/flang/lib/Semantics/check-omp-structure.cpp
index 0e122856985f..b1864fbda62a 100644
--- a/flang/lib/Semantics/check-omp-structure.cpp
+++ b/flang/lib/Semantics/check-omp-structure.cpp
@@ -668,7 +668,7 @@ void OmpStructureChecker::Leave(const parser::OmpClauseList &) {
 
       // TODO: ordered region binding check (requires nesting implementation)
     }
-  }  // doSet
+  } // doSet
 
   // 2.8.1 Simd Construct Restriction
   if (simdSet.test(GetContext().directive)) {
@@ -692,7 +692,7 @@ void OmpStructureChecker::Leave(const parser::OmpClauseList &) {
     }
 
     // TODO: A list-item cannot appear in more than one aligned clause
-  }  // SIMD
+  } // SIMD
 
   // 2.7.3 Single Construct Restriction
   if (GetContext().directive == OmpDirective::END_SINGLE) {
@@ -938,7 +938,8 @@ void OmpStructureChecker::Enter(const parser::OmpMapClause &x) {
             ContextDirectiveAsFortran());
       }
     } break;
-    default: break;
+    default:
+      break;
     }
   }
 }
@@ -995,4 +996,4 @@ void OmpStructureChecker::Enter(const parser::OmpScheduleClause &x) {
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-omp-structure.h b/flang/lib/Semantics/check-omp-structure.h
index 67709e38b5a8..e952b3531f84 100644
--- a/flang/lib/Semantics/check-omp-structure.h
+++ b/flang/lib/Semantics/check-omp-structure.h
@@ -170,7 +170,7 @@ public:
 private:
   struct OmpContext {
     OmpContext(parser::CharBlock source, OmpDirective d)
-      : directiveSource{source}, directive{d} {}
+        : directiveSource{source}, directive{d} {}
     parser::CharBlock directiveSource{nullptr};
     parser::CharBlock clauseSource{nullptr};
     OmpDirective directive;
@@ -246,7 +246,7 @@ private:
   void CheckRequired(OmpClause);
   std::string ContextDirectiveAsFortran();
   void SayNotMatching(const parser::CharBlock &, const parser::CharBlock &);
-  template<typename A, typename B, typename C>
+  template <typename A, typename B, typename C>
   const A &CheckMatching(const B &beginDir, const C &endDir) {
     const A &begin{std::get<A>(beginDir.t)};
     const A &end{std::get<A>(endDir.t)};
@@ -261,7 +261,7 @@ private:
       const parser::OmpScheduleModifierType::ModType &);
 
   SemanticsContext &context_;
-  std::vector<OmpContext> ompContext_;  // used as a stack
+  std::vector<OmpContext> ompContext_; // used as a stack
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_
diff --git a/flang/lib/Semantics/check-purity.cpp b/flang/lib/Semantics/check-purity.cpp
index 9ca56fc04fa1..5176390f366b 100644
--- a/flang/lib/Semantics/check-purity.cpp
+++ b/flang/lib/Semantics/check-purity.cpp
@@ -70,4 +70,4 @@ void PurityChecker::Left() {
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-purity.h b/flang/lib/Semantics/check-purity.h
index b4c8272de634..a6551162325f 100644
--- a/flang/lib/Semantics/check-purity.h
+++ b/flang/lib/Semantics/check-purity.h
@@ -15,7 +15,7 @@ struct ExecutableConstruct;
 struct SubroutineSubprogram;
 struct FunctionSubprogram;
 struct PrefixSpec;
-}
+} // namespace Fortran::parser
 namespace Fortran::semantics {
 class PurityChecker : public virtual BaseChecker {
 public:
@@ -35,5 +35,5 @@ private:
   int depth_{0};
   int pureDepth_{-1};
 };
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/flang/lib/Semantics/check-return.cpp b/flang/lib/Semantics/check-return.cpp
index 0e0dd2c3e66f..602ecc8a22f7 100644
--- a/flang/lib/Semantics/check-return.cpp
+++ b/flang/lib/Semantics/check-return.cpp
@@ -43,4 +43,4 @@ void ReturnStmtChecker::Leave(const parser::ReturnStmt &returnStmt) {
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-return.h b/flang/lib/Semantics/check-return.h
index edaf90b4f641..d49c747717ec 100644
--- a/flang/lib/Semantics/check-return.h
+++ b/flang/lib/Semantics/check-return.h
@@ -24,5 +24,5 @@ public:
 private:
   SemanticsContext &context_;
 };
-}
-#endif  // FORTRAN_SEMANTICS_CHECK_RETURN_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_CHECK_RETURN_H_
diff --git a/flang/lib/Semantics/check-stop.cpp b/flang/lib/Semantics/check-stop.cpp
index 08487a5c07af..ce3482a072bb 100644
--- a/flang/lib/Semantics/check-stop.cpp
+++ b/flang/lib/Semantics/check-stop.cpp
@@ -39,4 +39,4 @@ void StopChecker::Enter(const parser::StopStmt &stmt) {
   }
 }
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/check-stop.h b/flang/lib/Semantics/check-stop.h
index ed50830edc4a..b9a22bf9df80 100644
--- a/flang/lib/Semantics/check-stop.h
+++ b/flang/lib/Semantics/check-stop.h
@@ -28,6 +28,6 @@ private:
   SemanticsContext &context_;
 };
 
-}  // namespace Fortran::semantics
+} // namespace Fortran::semantics
 
-#endif  // FORTRAN_SEMANTICS_CHECK_STOP_H_
+#endif // FORTRAN_SEMANTICS_CHECK_STOP_H_
diff --git a/flang/lib/Semantics/expression.cpp b/flang/lib/Semantics/expression.cpp
index 717266af9733..d36bd6f8e1e0 100644
--- a/flang/lib/Semantics/expression.cpp
+++ b/flang/lib/Semantics/expression.cpp
@@ -873,21 +873,21 @@ std::optional<Expr<SubscriptInteger>> ExpressionAnalyzer::TripletPart(
 
 std::optional<Subscript> ExpressionAnalyzer::AnalyzeSectionSubscript(
     const parser::SectionSubscript &ss) {
-  return std::visit(
-      common::visitors{
-          [&](const parser::SubscriptTriplet &t) {
-            return std::make_optional<Subscript>(Triplet{
-                TripletPart(std::get<0>(t.t)), TripletPart(std::get<1>(t.t)),
-                TripletPart(std::get<2>(t.t))});
-          },
-          [&](const auto &s) -> std::optional<Subscript> {
-            if (auto subscriptExpr{AsSubscript(Analyze(s))}) {
-              return Subscript{std::move(*subscriptExpr)};
-            } else {
-              return std::nullopt;
-            }
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](const parser::SubscriptTriplet &t) {
+                          return std::make_optional<Subscript>(
+                              Triplet{TripletPart(std::get<0>(t.t)),
+                                  TripletPart(std::get<1>(t.t)),
+                                  TripletPart(std::get<2>(t.t))});
+                        },
+                        [&](const auto &s) -> std::optional<Subscript> {
+                          if (auto subscriptExpr{AsSubscript(Analyze(s))}) {
+                            return Subscript{std::move(*subscriptExpr)};
+                          } else {
+                            return std::nullopt;
+                          }
+                        },
+                    },
       ss.u);
 }
 
@@ -2027,30 +2027,29 @@ const Assignment *ExpressionAnalyzer::Analyze(
       x.typedAssignment.reset(new GenericAssignmentWrapper{});
     } else {
       Assignment assignment{std::move(*lhs), std::move(*rhs)};
-      std::visit(
-          common::visitors{
-              [&](const std::list<parser::BoundsRemapping> &list) {
-                Assignment::BoundsRemapping bounds;
-                for (const auto &elem : list) {
-                  auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
-                  auto upper{AsSubscript(Analyze(std::get<1>(elem.t)))};
-                  if (lower && upper) {
-                    bounds.emplace_back(
-                        Fold(std::move(*lower)), Fold(std::move(*upper)));
-                  }
-                }
-                assignment.u = std::move(bounds);
-              },
-              [&](const std::list<parser::BoundsSpec> &list) {
-                Assignment::BoundsSpec bounds;
-                for (const auto &bound : list) {
-                  if (auto lower{AsSubscript(Analyze(bound.v))}) {
-                    bounds.emplace_back(Fold(std::move(*lower)));
-                  }
-                }
-                assignment.u = std::move(bounds);
-              },
-          },
+      std::visit(common::visitors{
+                     [&](const std::list<parser::BoundsRemapping> &list) {
+                       Assignment::BoundsRemapping bounds;
+                       for (const auto &elem : list) {
+                         auto lower{AsSubscript(Analyze(std::get<0>(elem.t)))};
+                         auto upper{AsSubscript(Analyze(std::get<1>(elem.t)))};
+                         if (lower && upper) {
+                           bounds.emplace_back(Fold(std::move(*lower)),
+                               Fold(std::move(*upper)));
+                         }
+                       }
+                       assignment.u = std::move(bounds);
+                     },
+                     [&](const std::list<parser::BoundsSpec> &list) {
+                       Assignment::BoundsSpec bounds;
+                       for (const auto &bound : list) {
+                         if (auto lower{AsSubscript(Analyze(bound.v))}) {
+                           bounds.emplace_back(Fold(std::move(*lower)));
+                         }
+                       }
+                       assignment.u = std::move(bounds);
+                     },
+                 },
           std::get<parser::PointerAssignmentStmt::Bounds>(x.t).u);
       x.typedAssignment.reset(
           new GenericAssignmentWrapper{std::move(assignment)});
@@ -2399,14 +2398,14 @@ static void FixMisparsedFunctionReference(
     parser::FunctionReference &funcRef{func->value()};
     auto &proc{std::get<parser::ProcedureDesignator>(funcRef.v.t)};
     if (Symbol *
-        origSymbol{std::visit(
-            common::visitors{
-                [&](parser::Name &name) { return name.symbol; },
-                [&](parser::ProcComponentRef &pcr) {
-                  return pcr.v.thing.component.symbol;
-                },
-            },
-            proc.u)}) {
+        origSymbol{
+            std::visit(common::visitors{
+                           [&](parser::Name &name) { return name.symbol; },
+                           [&](parser::ProcComponentRef &pcr) {
+                             return pcr.v.thing.component.symbol;
+                           },
+                       },
+                proc.u)}) {
       Symbol &symbol{origSymbol->GetUltimate()};
       if (symbol.has<semantics::ObjectEntityDetails>() ||
           symbol.has<semantics::AssocEntityDetails>()) {
@@ -2651,26 +2650,26 @@ void ArgumentAnalyzer::Analyze(
   // be detected and represented (they're not expressions).
   // TODO: C1534: Don't allow a "restricted" specific intrinsic to be passed.
   std::optional<ActualArgument> actual;
-  std::visit(
-      common::visitors{
-          [&](const common::Indirection<parser::Expr> &x) {
-            // TODO: Distinguish & handle procedure name and
-            // proc-component-ref
-            actual = AnalyzeExpr(x.value());
-          },
-          [&](const parser::AltReturnSpec &) {
-            if (!isSubroutine) {
-              context_.Say("alternate return specification may not appear on"
-                           " function reference"_err_en_US);
-            }
-          },
-          [&](const parser::ActualArg::PercentRef &) {
-            context_.Say("TODO: %REF() argument"_err_en_US);
-          },
-          [&](const parser::ActualArg::PercentVal &) {
-            context_.Say("TODO: %VAL() argument"_err_en_US);
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const common::Indirection<parser::Expr> &x) {
+                   // TODO: Distinguish & handle procedure name and
+                   // proc-component-ref
+                   actual = AnalyzeExpr(x.value());
+                 },
+                 [&](const parser::AltReturnSpec &) {
+                   if (!isSubroutine) {
+                     context_.Say(
+                         "alternate return specification may not appear on"
+                         " function reference"_err_en_US);
+                   }
+                 },
+                 [&](const parser::ActualArg::PercentRef &) {
+                   context_.Say("TODO: %REF() argument"_err_en_US);
+                 },
+                 [&](const parser::ActualArg::PercentVal &) {
+                   context_.Say("TODO: %VAL() argument"_err_en_US);
+                 },
+             },
       std::get<parser::ActualArg>(arg.t).u);
   if (actual) {
     if (const auto &argKW{std::get<std::optional<parser::Keyword>>(arg.t)}) {
@@ -3030,14 +3029,13 @@ bool ExprChecker::Walk(const parser::Program &program) {
 }
 
 bool ExprChecker::Pre(const parser::DataStmtConstant &x) {
-  std::visit(
-      common::visitors{
-          [&](const parser::NullInit &) {},
-          [&](const parser::InitialDataTarget &y) {
-            AnalyzeExpr(context_, y.value());
-          },
-          [&](const auto &y) { AnalyzeExpr(context_, y); },
-      },
+  std::visit(common::visitors{
+                 [&](const parser::NullInit &) {},
+                 [&](const parser::InitialDataTarget &y) {
+                   AnalyzeExpr(context_, y.value());
+                 },
+                 [&](const auto &y) { AnalyzeExpr(context_, y); },
+             },
       x.u);
   return false;
 }
diff --git a/flang/lib/Semantics/mod-file.cpp b/flang/lib/Semantics/mod-file.cpp
index ba1df939fd74..5dcc19881363 100644
--- a/flang/lib/Semantics/mod-file.cpp
+++ b/flang/lib/Semantics/mod-file.cpp
@@ -70,7 +70,7 @@ static std::string CheckSum(const std::string_view &);
 class SubprogramSymbolCollector {
 public:
   SubprogramSymbolCollector(const Symbol &symbol, const Scope &scope)
-    : symbol_{symbol}, scope_{scope} {}
+      : symbol_{symbol}, scope_{scope} {}
   const SymbolVector &symbols() const { return need_; }
   const std::set<SourceName> &imports() const { return imports_; }
   void Collect();
@@ -79,10 +79,10 @@ private:
   const Symbol &symbol_;
   const Scope &scope_;
   bool isInterface_{false};
-  SymbolVector need_;  // symbols that are needed
-  SymbolSet needSet_;  // symbols already in need_
-  SymbolSet useSet_;  // use-associations that might be needed
-  std::set<SourceName> imports_;  // imports from host that are needed
+  SymbolVector need_; // symbols that are needed
+  SymbolSet needSet_; // symbols already in need_
+  SymbolSet useSet_; // use-associations that might be needed
+  std::set<SourceName> imports_; // imports from host that are needed
 
   void DoSymbol(const Symbol &);
   void DoSymbol(const SourceName &, const Symbol &);
@@ -91,7 +91,7 @@ private:
   void DoParamValue(const ParamValue &);
   bool NeedImport(const SourceName &, const Symbol &);
 
-  template<typename T> void DoExpr(evaluate::Expr<T> expr) {
+  template <typename T> void DoExpr(evaluate::Expr<T> expr) {
     for (const Symbol &symbol : evaluate::CollectSymbols(expr)) {
       DoSymbol(symbol);
     }
@@ -115,7 +115,7 @@ void ModFileWriter::WriteOne(const Scope &scope) {
     if (!symbol->test(Symbol::Flag::ModFile)) {
       Write(*symbol);
     }
-    WriteAll(scope);  // write out submodules
+    WriteAll(scope); // write out submodules
   }
 }
 
@@ -176,7 +176,7 @@ std::string ModFileWriter::GetAsString(const Symbol &symbol) {
 void ModFileWriter::PutSymbols(const Scope &scope) {
   std::string buf;
   llvm::raw_string_ostream typeBindings{
-      buf};  // stuff after CONTAINS in derived type
+      buf}; // stuff after CONTAINS in derived type
   for (const Symbol &symbol : CollectSymbols(scope)) {
     PutSymbol(typeBindings, symbol);
   }
@@ -190,77 +190,76 @@ void ModFileWriter::PutSymbols(const Scope &scope) {
 // procedures, type-bound generics, final procedures) which go to typeBindings.
 void ModFileWriter::PutSymbol(
     llvm::raw_ostream &typeBindings, const Symbol &symbol) {
-  std::visit(
-      common::visitors{
-          [&](const ModuleDetails &) { /* should be current module */ },
-          [&](const DerivedTypeDetails &) { PutDerivedType(symbol); },
-          [&](const SubprogramDetails &) { PutSubprogram(symbol); },
-          [&](const GenericDetails &x) {
-            if (symbol.owner().IsDerivedType()) {
-              // generic binding
-              for (const Symbol &proc : x.specificProcs()) {
-                typeBindings << "generic::" << symbol.name() << "=>"
-                             << proc.name() << '\n';
-              }
-            } else {
-              PutGeneric(symbol);
-              if (x.specific()) {
-                PutSymbol(typeBindings, *x.specific());
-              }
-              if (x.derivedType()) {
-                PutSymbol(typeBindings, *x.derivedType());
-              }
-            }
-          },
-          [&](const UseDetails &) { PutUse(symbol); },
-          [](const UseErrorDetails &) {},
-          [&](const ProcBindingDetails &x) {
-            bool deferred{symbol.attrs().test(Attr::DEFERRED)};
-            typeBindings << "procedure";
-            if (deferred) {
-              typeBindings << '(' << x.symbol().name() << ')';
-            }
-            PutPassName(typeBindings, x.passName());
-            auto attrs{symbol.attrs()};
-            if (x.passName()) {
-              attrs.reset(Attr::PASS);
-            }
-            PutAttrs(typeBindings, attrs);
-            typeBindings << "::" << symbol.name();
-            if (!deferred && x.symbol().name() != symbol.name()) {
-              typeBindings << "=>" << x.symbol().name();
-            }
-            typeBindings << '\n';
-          },
-          [&](const NamelistDetails &x) {
-            decls_ << "namelist/" << symbol.name();
-            char sep{'/'};
-            for (const Symbol &object : x.objects()) {
-              decls_ << sep << object.name();
-              sep = ',';
-            }
-            decls_ << '\n';
-          },
-          [&](const CommonBlockDetails &x) {
-            decls_ << "common/" << symbol.name();
-            char sep = '/';
-            for (const Symbol &object : x.objects()) {
-              decls_ << sep << object.name();
-              sep = ',';
-            }
-            decls_ << '\n';
-            if (symbol.attrs().test(Attr::BIND_C)) {
-              PutAttrs(decls_, symbol.attrs(), x.bindName(), ""s);
-              decls_ << "::/" << symbol.name() << "/\n";
-            }
-          },
-          [&](const FinalProcDetails &) {
-            typeBindings << "final::" << symbol.name() << '\n';
-          },
-          [](const HostAssocDetails &) {},
-          [](const MiscDetails &) {},
-          [&](const auto &) { PutEntity(decls_, symbol); },
-      },
+  std::visit(common::visitors{
+                 [&](const ModuleDetails &) { /* should be current module */ },
+                 [&](const DerivedTypeDetails &) { PutDerivedType(symbol); },
+                 [&](const SubprogramDetails &) { PutSubprogram(symbol); },
+                 [&](const GenericDetails &x) {
+                   if (symbol.owner().IsDerivedType()) {
+                     // generic binding
+                     for (const Symbol &proc : x.specificProcs()) {
+                       typeBindings << "generic::" << symbol.name() << "=>"
+                                    << proc.name() << '\n';
+                     }
+                   } else {
+                     PutGeneric(symbol);
+                     if (x.specific()) {
+                       PutSymbol(typeBindings, *x.specific());
+                     }
+                     if (x.derivedType()) {
+                       PutSymbol(typeBindings, *x.derivedType());
+                     }
+                   }
+                 },
+                 [&](const UseDetails &) { PutUse(symbol); },
+                 [](const UseErrorDetails &) {},
+                 [&](const ProcBindingDetails &x) {
+                   bool deferred{symbol.attrs().test(Attr::DEFERRED)};
+                   typeBindings << "procedure";
+                   if (deferred) {
+                     typeBindings << '(' << x.symbol().name() << ')';
+                   }
+                   PutPassName(typeBindings, x.passName());
+                   auto attrs{symbol.attrs()};
+                   if (x.passName()) {
+                     attrs.reset(Attr::PASS);
+                   }
+                   PutAttrs(typeBindings, attrs);
+                   typeBindings << "::" << symbol.name();
+                   if (!deferred && x.symbol().name() != symbol.name()) {
+                     typeBindings << "=>" << x.symbol().name();
+                   }
+                   typeBindings << '\n';
+                 },
+                 [&](const NamelistDetails &x) {
+                   decls_ << "namelist/" << symbol.name();
+                   char sep{'/'};
+                   for (const Symbol &object : x.objects()) {
+                     decls_ << sep << object.name();
+                     sep = ',';
+                   }
+                   decls_ << '\n';
+                 },
+                 [&](const CommonBlockDetails &x) {
+                   decls_ << "common/" << symbol.name();
+                   char sep = '/';
+                   for (const Symbol &object : x.objects()) {
+                     decls_ << sep << object.name();
+                     sep = ',';
+                   }
+                   decls_ << '\n';
+                   if (symbol.attrs().test(Attr::BIND_C)) {
+                     PutAttrs(decls_, symbol.attrs(), x.bindName(), ""s);
+                     decls_ << "::/" << symbol.name() << "/\n";
+                   }
+                 },
+                 [&](const FinalProcDetails &) {
+                   typeBindings << "final::" << symbol.name() << '\n';
+                 },
+                 [](const HostAssocDetails &) {},
+                 [](const MiscDetails &) {},
+                 [&](const auto &) { PutEntity(decls_, symbol); },
+             },
       symbol.details());
 }
 
@@ -415,7 +414,7 @@ void ModFileWriter::PutUseExtraAttr(
 // Collect the symbols of this scope sorted by their original order, not name.
 // Namelists are an exception: they are sorted after other symbols.
 SymbolVector CollectSymbols(const Scope &scope) {
-  SymbolSet symbols;  // to prevent duplicates
+  SymbolSet symbols; // to prevent duplicates
   SymbolVector sorted;
   SymbolVector namelist;
   SymbolVector common;
@@ -495,7 +494,8 @@ void PutShape(
 
 void PutObjectEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   auto &details{symbol.get<ObjectEntityDetails>()};
-  PutEntity(os, symbol, [&]() { PutType(os, DEREF(symbol.GetType())); },
+  PutEntity(
+      os, symbol, [&]() { PutType(os, DEREF(symbol.GetType())); },
       symbol.attrs());
   PutShape(os, details.shape(), '(', ')');
   PutShape(os, details.coshape(), '[', ']');
@@ -514,7 +514,8 @@ void PutProcEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   if (details.passName()) {
     attrs.reset(Attr::PASS);
   }
-  PutEntity(os, symbol,
+  PutEntity(
+      os, symbol,
       [&]() {
         os << "procedure(";
         if (interface.symbol()) {
@@ -537,7 +538,8 @@ void PutPassName(
 }
 void PutTypeParam(llvm::raw_ostream &os, const Symbol &symbol) {
   auto &details{symbol.get<TypeParamDetails>()};
-  PutEntity(os, symbol,
+  PutEntity(
+      os, symbol,
       [&]() {
         PutType(os, DEREF(symbol.GetType()));
         PutLower(os << ',', common::EnumToString(details.attr()));
@@ -580,13 +582,12 @@ void PutEntity(llvm::raw_ostream &os, const Symbol &symbol,
     std::function<void()> writeType, Attrs attrs) {
   writeType();
   MaybeExpr bindName;
-  std::visit(
-      common::visitors{
-          [&](const SubprogramDetails &x) { bindName = x.bindName(); },
-          [&](const ObjectEntityDetails &x) { bindName = x.bindName(); },
-          [&](const ProcEntityDetails &x) { bindName = x.bindName(); },
-          [&](const auto &) {},
-      },
+  std::visit(common::visitors{
+                 [&](const SubprogramDetails &x) { bindName = x.bindName(); },
+                 [&](const ObjectEntityDetails &x) { bindName = x.bindName(); },
+                 [&](const ProcEntityDetails &x) { bindName = x.bindName(); },
+                 [&](const auto &) {},
+             },
       symbol.details());
   PutAttrs(os, attrs, bindName);
   os << "::" << symbol.name();
@@ -596,8 +597,8 @@ void PutEntity(llvm::raw_ostream &os, const Symbol &symbol,
 // mapped to lower case.
 llvm::raw_ostream &PutAttrs(llvm::raw_ostream &os, Attrs attrs,
     const MaybeExpr &bindName, std::string before, std::string after) {
-  attrs.set(Attr::PUBLIC, false);  // no need to write PUBLIC
-  attrs.set(Attr::EXTERNAL, false);  // no need to write EXTERNAL
+  attrs.set(Attr::PUBLIC, false); // no need to write PUBLIC
+  attrs.set(Attr::EXTERNAL, false); // no need to write EXTERNAL
   if (bindName) {
     bindName->AsFortran(os << before << "bind(c, name=") << ')' << after;
     attrs.set(Attr::BIND_C, false);
@@ -741,7 +742,7 @@ static bool VerifyHeader(llvm::ArrayRef<char> content) {
 }
 
 Scope *ModFileReader::Read(const SourceName &name, Scope *ancestor) {
-  std::string ancestorName;  // empty for module
+  std::string ancestorName; // empty for module
   if (ancestor) {
     if (auto *scope{ancestor->FindSubmodule(name)}) {
       return scope;
@@ -783,7 +784,7 @@ Scope *ModFileReader::Read(const SourceName &name, Scope *ancestor) {
         sourceFile->path());
     return nullptr;
   }
-  Scope *parentScope;  // the scope this module/submodule goes into
+  Scope *parentScope; // the scope this module/submodule goes into
   if (!ancestor) {
     parentScope = &context_.globalScope();
   } else if (std::optional<SourceName> parent{GetSubmoduleParent(*parseTree)}) {
@@ -868,30 +869,29 @@ void SubprogramSymbolCollector::DoSymbol(
     return;
   }
   if (!needSet_.insert(symbol).second) {
-    return;  // already done
+    return; // already done
   }
-  std::visit(
-      common::visitors{
-          [this](const ObjectEntityDetails &details) {
-            for (const ShapeSpec &spec : details.shape()) {
-              DoBound(spec.lbound());
-              DoBound(spec.ubound());
-            }
-            for (const ShapeSpec &spec : details.coshape()) {
-              DoBound(spec.lbound());
-              DoBound(spec.ubound());
-            }
-            if (const Symbol * commonBlock{details.commonBlock()}) {
-              DoSymbol(*commonBlock);
-            }
-          },
-          [this](const CommonBlockDetails &details) {
-            for (const Symbol &object : details.objects()) {
-              DoSymbol(object);
-            }
-          },
-          [](const auto &) {},
-      },
+  std::visit(common::visitors{
+                 [this](const ObjectEntityDetails &details) {
+                   for (const ShapeSpec &spec : details.shape()) {
+                     DoBound(spec.lbound());
+                     DoBound(spec.ubound());
+                   }
+                   for (const ShapeSpec &spec : details.coshape()) {
+                     DoBound(spec.lbound());
+                     DoBound(spec.ubound());
+                   }
+                   if (const Symbol * commonBlock{details.commonBlock()}) {
+                     DoSymbol(*commonBlock);
+                   }
+                 },
+                 [this](const CommonBlockDetails &details) {
+                   for (const Symbol &object : details.objects()) {
+                     DoSymbol(object);
+                   }
+                 },
+                 [](const auto &) {},
+             },
       symbol.details());
   if (!symbol.has<UseDetails>()) {
     DoType(symbol.GetType());
@@ -907,7 +907,8 @@ void SubprogramSymbolCollector::DoType(const DeclTypeSpec *type) {
   }
   switch (type->category()) {
   case DeclTypeSpec::Numeric:
-  case DeclTypeSpec::Logical: break;  // nothing to do
+  case DeclTypeSpec::Logical:
+    break; // nothing to do
   case DeclTypeSpec::Character:
     DoParamValue(type->characterTypeSpec().length());
     break;
@@ -956,4 +957,4 @@ bool SubprogramSymbolCollector::NeedImport(
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/mod-file.h b/flang/lib/Semantics/mod-file.h
index d71a0f599af8..2800f315054e 100644
--- a/flang/lib/Semantics/mod-file.h
+++ b/flang/lib/Semantics/mod-file.h
@@ -16,7 +16,7 @@ namespace Fortran::parser {
 class CharBlock;
 class Message;
 class MessageFixedText;
-}
+} // namespace Fortran::parser
 
 namespace llvm {
 class raw_ostream;
@@ -43,7 +43,8 @@ private:
   std::string containsBuf_;
 
   llvm::raw_string_ostream uses_{usesBuf_};
-  llvm::raw_string_ostream useExtraAttrs_{useExtraAttrsBuf_};  // attrs added to used entity
+  llvm::raw_string_ostream useExtraAttrs_{
+      useExtraAttrsBuf_}; // attrs added to used entity
   llvm::raw_string_ostream decls_{declsBuf_};
   llvm::raw_string_ostream contains_{containsBuf_};
 
@@ -76,5 +77,5 @@ private:
       parser::MessageFixedText &&, const std::string &);
 };
 
-}
+} // namespace Fortran::semantics
 #endif
diff --git a/flang/lib/Semantics/pointer-assignment.cpp b/flang/lib/Semantics/pointer-assignment.cpp
index fdb6addc20de..cb6fcaa933af 100644
--- a/flang/lib/Semantics/pointer-assignment.cpp
+++ b/flang/lib/Semantics/pointer-assignment.cpp
@@ -41,11 +41,11 @@ class PointerAssignmentChecker {
 public:
   PointerAssignmentChecker(evaluate::FoldingContext &context,
       parser::CharBlock source, const std::string &description)
-    : context_{context}, source_{source}, description_{description} {}
+      : context_{context}, source_{source}, description_{description} {}
   PointerAssignmentChecker(evaluate::FoldingContext &context, const Symbol &lhs)
-    : context_{context}, source_{lhs.name()},
-      description_{"pointer '"s + lhs.name().ToString() + '\''}, lhs_{&lhs},
-      procedure_{Procedure::Characterize(lhs, context.intrinsics())} {
+      : context_{context}, source_{lhs.name()},
+        description_{"pointer '"s + lhs.name().ToString() + '\''}, lhs_{&lhs},
+        procedure_{Procedure::Characterize(lhs, context.intrinsics())} {
     set_lhsType(TypeAndShape::Characterize(lhs, context));
     set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS));
     set_isVolatile(lhs.attrs().test(Attr::VOLATILE));
@@ -57,10 +57,10 @@ public:
   void Check(const SomeExpr &);
 
 private:
-  template<typename T> void Check(const T &);
-  template<typename T> void Check(const evaluate::Expr<T> &);
-  template<typename T> void Check(const evaluate::FunctionRef<T> &);
-  template<typename T> void Check(const evaluate::Designator<T> &);
+  template <typename T> void Check(const T &);
+  template <typename T> void Check(const evaluate::Expr<T> &);
+  template <typename T> void Check(const evaluate::FunctionRef<T> &);
+  template <typename T> void Check(const evaluate::Designator<T> &);
   void Check(const evaluate::NullPointer &);
   void Check(const evaluate::ProcedureDesignator &);
   void Check(const evaluate::ProcedureRef &);
@@ -68,7 +68,7 @@ private:
   void Check(
       parser::CharBlock rhsName, bool isCall, const Procedure * = nullptr);
   bool LhsOkForUnlimitedPoly() const;
-  template<typename... A> parser::Message *Say(A &&...);
+  template <typename... A> parser::Message *Say(A &&...);
 
   evaluate::FoldingContext &context_;
   const parser::CharBlock source_;
@@ -105,22 +105,22 @@ PointerAssignmentChecker &PointerAssignmentChecker::set_isBoundsRemapping(
   return *this;
 }
 
-template<typename T> void PointerAssignmentChecker::Check(const T &) {
+template <typename T> void PointerAssignmentChecker::Check(const T &) {
   // Catch-all case for really bad target expression
   Say("Target associated with %s must be a designator or a call to a"
       " pointer-valued function"_err_en_US,
       description_);
 }
 
-template<typename T>
+template <typename T>
 void PointerAssignmentChecker::Check(const evaluate::Expr<T> &x) {
   std::visit([&](const auto &x) { Check(x); }, x.u);
 }
 
 void PointerAssignmentChecker::Check(const SomeExpr &rhs) {
-  if (HasVectorSubscript(rhs)) {  // C1025
+  if (HasVectorSubscript(rhs)) { // C1025
     Say("An array section with a vector subscript may not be a pointer target"_err_en_US);
-  } else if (ExtractCoarrayRef(rhs)) {  // C1026
+  } else if (ExtractCoarrayRef(rhs)) { // C1026
     Say("A coindexed object may not be a pointer target"_err_en_US);
   } else {
     std::visit([&](const auto &x) { Check(x); }, rhs.u);
@@ -131,7 +131,7 @@ void PointerAssignmentChecker::Check(const evaluate::NullPointer &) {
   // P => NULL() without MOLD=; always OK
 }
 
-template<typename T>
+template <typename T>
 void PointerAssignmentChecker::Check(const evaluate::FunctionRef<T> &f) {
   std::string funcName;
   const auto *symbol{f.proc().GetSymbol()};
@@ -145,7 +145,7 @@ void PointerAssignmentChecker::Check(const evaluate::FunctionRef<T> &f) {
     return;
   }
   std::optional<MessageFixedText> msg;
-  const auto &funcResult{proc->functionResult};  // C1025
+  const auto &funcResult{proc->functionResult}; // C1025
   if (!funcResult) {
     msg = "%s is associated with the non-existent result of reference to"
           " procedure"_err_en_US;
@@ -177,7 +177,7 @@ void PointerAssignmentChecker::Check(const evaluate::FunctionRef<T> &f) {
   }
 }
 
-template<typename T>
+template <typename T>
 void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
   const Symbol *last{d.GetLastSymbol()};
   const Symbol *base{d.GetBaseObject().symbol()};
@@ -191,7 +191,7 @@ void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
     // Shouldn't be here in this function unless lhs is an object pointer.
     msg = "In assignment to procedure %s, the target is not a procedure or"
           " procedure pointer"_err_en_US;
-  } else if (!evaluate::GetLastTarget(GetSymbolVector(d))) {  // C1025
+  } else if (!evaluate::GetLastTarget(GetSymbolVector(d))) { // C1025
     msg = "In assignment to object %s, the target '%s' is not an object with"
           " POINTER or TARGET attributes"_err_en_US;
   } else if (auto rhsType{TypeAndShape::Characterize(d, context_)}) {
@@ -199,7 +199,7 @@ void PointerAssignmentChecker::Check(const evaluate::Designator<T> &d) {
       msg = "%s associated with object '%s' with incompatible type or"
             " shape"_err_en_US;
     } else if (rhsType->corank() > 0 &&
-        (isVolatile_ != last->attrs().test(Attr::VOLATILE))) {  // C1020
+        (isVolatile_ != last->attrs().test(Attr::VOLATILE))) { // C1020
       // TODO: what if A is VOLATILE in A%B%C?  need a better test here
       if (isVolatile_) {
         msg = "Pointer may not be VOLATILE when target is a"
@@ -335,7 +335,7 @@ bool PointerAssignmentChecker::LhsOkForUnlimitedPoly() const {
   }
 }
 
-template<typename... A>
+template <typename... A>
 parser::Message *PointerAssignmentChecker::Say(A &&... x) {
   auto *msg{context_.messages().Say(std::forward<A>(x)...)};
   if (lhs_) {
@@ -377,7 +377,7 @@ static bool CheckPointerBounds(
                     messages.Say(
                         "Pointer bounds require %d elements but target has"
                         " only %d"_err_en_US,
-                        *lhsSize, *rhsSize);  // 10.2.2.3(9)
+                        *lhsSize, *rhsSize); // 10.2.2.3(9)
                   }
                 }
               }
@@ -393,13 +393,13 @@ static bool CheckPointerBounds(
     if (lhs.Rank() != static_cast<int>(numBounds)) {
       messages.Say("Pointer '%s' has rank %d but the number of bounds specified"
                    " is %d"_err_en_US,
-          lhs.AsFortran(), lhs.Rank(), numBounds);  // C1018
+          lhs.AsFortran(), lhs.Rank(), numBounds); // C1018
     }
   }
   if (isBoundsRemapping && rhs.Rank() != 1 &&
       !evaluate::IsSimplyContiguous(rhs, context.intrinsics())) {
     messages.Say("Pointer bounds remapping target must have rank 1 or be"
-                 " simply contiguous"_err_en_US);  // 10.2.2.3(9)
+                 " simply contiguous"_err_en_US); // 10.2.2.3(9)
   }
   return isBoundsRemapping;
 }
@@ -410,7 +410,7 @@ void CheckPointerAssignment(
   const SomeExpr &rhs{assignment.rhs};
   const Symbol *pointer{GetLastSymbol(lhs)};
   if (!pointer) {
-    return;  // error was reported
+    return; // error was reported
   }
   if (!IsPointer(*pointer)) {
     evaluate::SayWithDeclaration(context.messages(), *pointer,
@@ -418,7 +418,7 @@ void CheckPointerAssignment(
     return;
   }
   if (pointer->has<ProcEntityDetails>() && evaluate::ExtractCoarrayRef(lhs)) {
-    context.messages().Say(  // C1027
+    context.messages().Say( // C1027
         "Procedure pointer may not be a coindexed object"_err_en_US);
     return;
   }
@@ -444,4 +444,4 @@ void CheckPointerAssignment(evaluate::FoldingContext &context,
       .Check(rhs);
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/pointer-assignment.h b/flang/lib/Semantics/pointer-assignment.h
index 31131a356e4a..fc64fb7e1656 100644
--- a/flang/lib/Semantics/pointer-assignment.h
+++ b/flang/lib/Semantics/pointer-assignment.h
@@ -34,6 +34,6 @@ void CheckPointerAssignment(evaluate::FoldingContext &,
     parser::CharBlock source, const std::string &description,
     const evaluate::characteristics::DummyDataObject &, const SomeExpr &rhs);
 
-}
+} // namespace Fortran::semantics
 
-#endif  // FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
+#endif // FORTRAN_SEMANTICS_POINTER_ASSIGNMENT_H_
diff --git a/flang/lib/Semantics/program-tree.cpp b/flang/lib/Semantics/program-tree.cpp
index 9325079655d2..e6dfd9b2f51c 100644
--- a/flang/lib/Semantics/program-tree.cpp
+++ b/flang/lib/Semantics/program-tree.cpp
@@ -13,7 +13,7 @@
 
 namespace Fortran::semantics {
 
-template<typename T>
+template <typename T>
 static ProgramTree BuildSubprogramTree(const parser::Name &name, const T &x) {
   const auto &spec{std::get<parser::SpecificationPart>(x.t)};
   const auto &exec{std::get<parser::ExecutionPart>(x.t)};
@@ -37,7 +37,7 @@ static ProgramTree BuildSubprogramTree(
   return ProgramTree{name, spec, nullptr};
 }
 
-template<typename T>
+template <typename T>
 static ProgramTree BuildModuleTree(const parser::Name &name, const T &x) {
   const auto &spec{std::get<parser::SpecificationPart>(x.t)};
   const auto &subps{std::get<std::optional<parser::ModuleSubprogramPart>>(x.t)};
@@ -130,17 +130,17 @@ Symbol::Flag ProgramTree::GetSubpFlag() const {
 
 bool ProgramTree::HasModulePrefix() const {
   using ListType = std::list<parser::PrefixSpec>;
-  const auto *prefixes{std::visit(
-      common::visitors{
-          [](const parser::Statement<parser::FunctionStmt> *x) {
-            return &std::get<ListType>(x->statement.t);
-          },
-          [](const parser::Statement<parser::SubroutineStmt> *x) {
-            return &std::get<ListType>(x->statement.t);
-          },
-          [](const auto *) -> const ListType * { return nullptr; },
-      },
-      stmt_)};
+  const auto *prefixes{
+      std::visit(common::visitors{
+                     [](const parser::Statement<parser::FunctionStmt> *x) {
+                       return &std::get<ListType>(x->statement.t);
+                     },
+                     [](const parser::Statement<parser::SubroutineStmt> *x) {
+                       return &std::get<ListType>(x->statement.t);
+                     },
+                     [](const auto *) -> const ListType * { return nullptr; },
+                 },
+          stmt_)};
   if (prefixes) {
     for (const auto &prefix : *prefixes) {
       if (std::holds_alternative<parser::PrefixSpec::Module>(prefix.u)) {
@@ -189,4 +189,4 @@ void ProgramTree::AddChild(ProgramTree &&child) {
   children_.emplace_back(std::move(child));
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/program-tree.h b/flang/lib/Semantics/program-tree.h
index 43d986be7544..69c133bfbde7 100644
--- a/flang/lib/Semantics/program-tree.h
+++ b/flang/lib/Semantics/program-tree.h
@@ -39,9 +39,9 @@ public:
   static ProgramTree Build(const parser::Submodule &);
   static ProgramTree Build(const parser::BlockData &);
 
-  ENUM_CLASS(Kind,  // kind of node
+  ENUM_CLASS(Kind, // kind of node
       Program, Function, Subroutine, MpSubprogram, Module, Submodule, BlockData)
-  using Stmt = std::variant<  // the statement that introduces the program unit
+  using Stmt = std::variant< // the statement that introduces the program unit
       const parser::Statement<parser::ProgramStmt> *,
       const parser::Statement<parser::FunctionStmt> *,
       const parser::Statement<parser::SubroutineStmt> *,
@@ -52,7 +52,7 @@ public:
 
   ProgramTree(const parser::Name &name, const parser::SpecificationPart &spec,
       const parser::ExecutionPart *exec = nullptr)
-    : name_{name}, spec_{spec}, exec_{exec} {}
+      : name_{name}, spec_{spec}, exec_{exec} {}
 
   const parser::Name &name() const { return name_; }
   Kind GetKind() const;
@@ -63,23 +63,24 @@ public:
   void set_isSpecificationPartResolved(bool yes = true) {
     isSpecificationPartResolved_ = yes;
   }
-  const parser::ParentIdentifier &GetParentId() const;  // only for Submodule
+  const parser::ParentIdentifier &GetParentId() const; // only for Submodule
   const parser::SpecificationPart &spec() const { return spec_; }
   const parser::ExecutionPart *exec() const { return exec_; }
   std::list<ProgramTree> &children() { return children_; }
   const std::list<ProgramTree> &children() const { return children_; }
   Symbol::Flag GetSubpFlag() const;
-  bool IsModule() const;  // Module or Submodule
-  bool HasModulePrefix() const;  // in function or subroutine stmt
+  bool IsModule() const; // Module or Submodule
+  bool HasModulePrefix() const; // in function or subroutine stmt
   Scope *scope() const { return scope_; }
   void set_scope(Scope &);
   void AddChild(ProgramTree &&);
 
-  template<typename T> ProgramTree &set_stmt(const parser::Statement<T> &stmt) {
+  template <typename T>
+  ProgramTree &set_stmt(const parser::Statement<T> &stmt) {
     stmt_ = &stmt;
     return *this;
   }
-  template<typename T>
+  template <typename T>
   ProgramTree &set_endStmt(const parser::Statement<T> &stmt) {
     endStmt_ = &stmt.source;
     return *this;
@@ -97,5 +98,5 @@ private:
   bool isSpecificationPartResolved_{false};
 };
 
-}
-#endif  // FORTRAN_SEMANTICS_PROGRAM_TREE_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_PROGRAM_TREE_H_
diff --git a/flang/lib/Semantics/resolve-labels.cpp b/flang/lib/Semantics/resolve-labels.cpp
index 55d60ac1729a..66f86c6c4e51 100644
--- a/flang/lib/Semantics/resolve-labels.cpp
+++ b/flang/lib/Semantics/resolve-labels.cpp
@@ -39,8 +39,8 @@ struct SourceStatementInfoTuplePOD {
   SourceStatementInfoTuplePOD(const parser::Label &parserLabel,
       const ProxyForScope &proxyForScope,
       const parser::CharBlock &parserCharBlock)
-    : parserLabel{parserLabel}, proxyForScope{proxyForScope},
-      parserCharBlock{parserCharBlock} {}
+      : parserLabel{parserLabel}, proxyForScope{proxyForScope},
+        parserCharBlock{parserCharBlock} {}
   parser::Label parserLabel;
   ProxyForScope proxyForScope;
   parser::CharBlock parserCharBlock;
@@ -51,7 +51,7 @@ enum class Legality { never, always, formerly };
 bool HasScope(ProxyForScope scope) { return scope != ProxyForScope{0u}; }
 
 // F18:R1131
-template<typename A>
+template <typename A>
 constexpr Legality IsLegalDoTerm(const parser::Statement<A> &) {
   if (std::is_same_v<A, common::Indirection<parser::EndDoStmt>> ||
       std::is_same_v<A, parser::EndDoStmt>) {
@@ -92,11 +92,11 @@ constexpr Legality IsLegalDoTerm(
   }
 }
 
-template<typename A> constexpr bool IsFormat(const parser::Statement<A> &) {
+template <typename A> constexpr bool IsFormat(const parser::Statement<A> &) {
   return std::is_same_v<A, common::Indirection<parser::FormatStmt>>;
 }
 
-template<typename A>
+template <typename A>
 constexpr Legality IsLegalBranchTarget(const parser::Statement<A> &) {
   if (std::is_same_v<A, parser::ActionStmt> ||
       std::is_same_v<A, parser::AssociateStmt> ||
@@ -128,7 +128,7 @@ constexpr Legality IsLegalBranchTarget(const parser::Statement<A> &) {
   }
 }
 
-template<typename A>
+template <typename A>
 constexpr LabeledStmtClassificationSet ConstructBranchTargetFlags(
     const parser::Statement<A> &statement) {
   LabeledStmtClassificationSet labeledStmtClassificationSet{};
@@ -155,11 +155,11 @@ static unsigned SayLabel(parser::Label label) {
 struct UnitAnalysis {
   UnitAnalysis() { scopeModel.push_back(0); }
   UnitAnalysis(UnitAnalysis &&that)
-    : doStmtSources{std::move(that.doStmtSources)},
-      formatStmtSources{std::move(that.formatStmtSources)},
-      otherStmtSources{std::move(that.otherStmtSources)},
-      targetStmts{std::move(that.targetStmts)}, scopeModel{std::move(
-                                                    that.scopeModel)} {}
+      : doStmtSources{std::move(that.doStmtSources)},
+        formatStmtSources{std::move(that.formatStmtSources)},
+        otherStmtSources{std::move(that.otherStmtSources)},
+        targetStmts{std::move(that.targetStmts)}, scopeModel{std::move(
+                                                      that.scopeModel)} {}
 
   SourceStmtList doStmtSources;
   SourceStmtList formatStmtSources;
@@ -171,7 +171,7 @@ struct UnitAnalysis {
 // Some parse tree record for statements simply wrap construct names;
 // others include them as tuple components.  Given a statement,
 // return a pointer to its name if it has one.
-template<typename A>
+template <typename A>
 const parser::CharBlock *GetStmtName(const parser::Statement<A> &stmt) {
   const std::optional<parser::Name> *name{nullptr};
   if constexpr (WrapperTrait<A>) {
@@ -199,7 +199,7 @@ using ExecutableConstructEndStmts = std::tuple<parser::EndIfStmt,
     parser::EndDoStmt, parser::EndSelectStmt, parser::EndChangeTeamStmt,
     parser::EndBlockStmt, parser::EndCriticalStmt, parser::EndAssociateStmt>;
 
-template<typename A>
+template <typename A>
 static constexpr bool IsExecutableConstructEndStmt{
     common::HasMember<A, ExecutableConstructEndStmts>};
 
@@ -208,10 +208,10 @@ public:
   ParseTreeAnalyzer(ParseTreeAnalyzer &&that) = default;
   ParseTreeAnalyzer(SemanticsContext &context) : context_{context} {}
 
-  template<typename A> constexpr bool Pre(const A &) { return true; }
-  template<typename A> constexpr void Post(const A &) {}
+  template <typename A> constexpr bool Pre(const A &) { return true; }
+  template <typename A> constexpr void Post(const A &) {}
 
-  template<typename A> bool Pre(const parser::Statement<A> &statement) {
+  template <typename A> bool Pre(const parser::Statement<A> &statement) {
     currentPosition_ = statement.source;
     if (statement.label) {
       auto label{statement.label.value()};
@@ -331,7 +331,7 @@ public:
   // and their intermediate or terminal statements that allow optional
   // construct names(e.g., ELSE).  When an optional construct name is present,
   // the construct as a whole must have a name that matches.
-  template<typename FIRST, typename CONSTRUCT, typename STMT>
+  template <typename FIRST, typename CONSTRUCT, typename STMT>
   void CheckOptionalName(const char *constructTag, const CONSTRUCT &a,
       const parser::Statement<STMT> &stmt) {
     if (const parser::CharBlock * name{GetStmtName(stmt)}) {
@@ -520,7 +520,7 @@ private:
     return PushSubscope();
   }
 
-  template<typename A> bool PushConstructName(const A &a) {
+  template <typename A> bool PushConstructName(const A &a) {
     const auto &optionalName{std::get<0>(std::get<0>(a.t).statement.t)};
     if (optionalName) {
       constructNames_.emplace_back(optionalName->ToString());
@@ -536,7 +536,7 @@ private:
     }
     return PushSubscope();
   }
-  template<typename A> bool PushConstructNameWithoutBlock(const A &a) {
+  template <typename A> bool PushConstructNameWithoutBlock(const A &a) {
     const auto &optionalName{std::get<0>(std::get<0>(a.t).statement.t)};
     if (optionalName) {
       constructNames_.emplace_back(optionalName->ToString());
@@ -544,11 +544,11 @@ private:
     return true;
   }
 
-  template<typename A> void PopConstructNameWithoutBlock(const A &a) {
+  template <typename A> void PopConstructNameWithoutBlock(const A &a) {
     CheckName(a);
     PopConstructNameIfPresent(a);
   }
-  template<typename A> void PopConstructNameIfPresent(const A &a) {
+  template <typename A> void PopConstructNameIfPresent(const A &a) {
     const auto &optionalName{std::get<0>(std::get<0>(a.t).statement.t)};
     if (optionalName) {
       constructNames_.pop_back();
@@ -563,13 +563,13 @@ private:
     }
   }
 
-  template<typename A> void PopConstructName(const A &a) {
+  template <typename A> void PopConstructName(const A &a) {
     CheckName(a);
     PopScope();
     PopConstructNameIfPresent(a);
   }
 
-  template<typename FIRST, typename CASEBLOCK, typename CASE,
+  template <typename FIRST, typename CASEBLOCK, typename CASE,
       typename CONSTRUCT>
   void CheckSelectNames(const char *tag, const CONSTRUCT &construct) {
     CheckEndName<FIRST, parser::EndSelectStmt>(tag, construct);
@@ -609,7 +609,7 @@ private:
 
   // Checks for missing or mismatching names on various constructs (e.g., BLOCK)
   // and their END statements.  Both names must be present if either one is.
-  template<typename FIRST, typename END, typename CONSTRUCT>
+  template <typename FIRST, typename END, typename CONSTRUCT>
   void CheckEndName(const char *constructTag, const CONSTRUCT &a) {
     const auto &constructStmt{std::get<parser::Statement<FIRST>>(a.t)};
     const auto &endStmt{std::get<parser::Statement<END>>(a.t)};
@@ -1024,4 +1024,4 @@ bool CheckConstraints(ParseTreeAnalyzer &&parseTreeAnalysis) {
 bool ValidateLabels(SemanticsContext &context, const parser::Program &program) {
   return CheckConstraints(LabelAnalysis(context, program));
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/resolve-labels.h b/flang/lib/Semantics/resolve-labels.h
index 6538a00cf18d..296a90305a41 100644
--- a/flang/lib/Semantics/resolve-labels.h
+++ b/flang/lib/Semantics/resolve-labels.h
@@ -21,5 +21,5 @@ class SemanticsContext;
 /// \param program    the parse tree of the program
 /// \return true, iff the program's labels pass semantics checks
 bool ValidateLabels(SemanticsContext &context, const parser::Program &program);
-}
-#endif  // FORTRAN_SEMANTICS_RESOLVE_LABELS_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_RESOLVE_LABELS_H_
diff --git a/flang/lib/Semantics/resolve-names-utils.cpp b/flang/lib/Semantics/resolve-names-utils.cpp
index 4c0e70e8caf4..5d1014aacec5 100644
--- a/flang/lib/Semantics/resolve-names-utils.cpp
+++ b/flang/lib/Semantics/resolve-names-utils.cpp
@@ -172,23 +172,40 @@ void GenericSpecInfo::Analyze(const parser::GenericSpec &x) {
 static GenericKind MapIntrinsicOperator(IntrinsicOperator op) {
   switch (op) {
     SWITCH_COVERS_ALL_CASES
-  case IntrinsicOperator::Concat: return GenericKind::OtherKind::Concat;
-  case IntrinsicOperator::Power: return NumericOperator::Power;
-  case IntrinsicOperator::Multiply: return NumericOperator::Multiply;
-  case IntrinsicOperator::Divide: return NumericOperator::Divide;
-  case IntrinsicOperator::Add: return NumericOperator::Add;
-  case IntrinsicOperator::Subtract: return NumericOperator::Subtract;
-  case IntrinsicOperator::AND: return LogicalOperator::And;
-  case IntrinsicOperator::OR: return LogicalOperator::Or;
-  case IntrinsicOperator::EQV: return LogicalOperator::Eqv;
-  case IntrinsicOperator::NEQV: return LogicalOperator::Neqv;
-  case IntrinsicOperator::NOT: return LogicalOperator::Not;
-  case IntrinsicOperator::LT: return RelationalOperator::LT;
-  case IntrinsicOperator::LE: return RelationalOperator::LE;
-  case IntrinsicOperator::EQ: return RelationalOperator::EQ;
-  case IntrinsicOperator::NE: return RelationalOperator::NE;
-  case IntrinsicOperator::GE: return RelationalOperator::GE;
-  case IntrinsicOperator::GT: return RelationalOperator::GT;
+  case IntrinsicOperator::Concat:
+    return GenericKind::OtherKind::Concat;
+  case IntrinsicOperator::Power:
+    return NumericOperator::Power;
+  case IntrinsicOperator::Multiply:
+    return NumericOperator::Multiply;
+  case IntrinsicOperator::Divide:
+    return NumericOperator::Divide;
+  case IntrinsicOperator::Add:
+    return NumericOperator::Add;
+  case IntrinsicOperator::Subtract:
+    return NumericOperator::Subtract;
+  case IntrinsicOperator::AND:
+    return LogicalOperator::And;
+  case IntrinsicOperator::OR:
+    return LogicalOperator::Or;
+  case IntrinsicOperator::EQV:
+    return LogicalOperator::Eqv;
+  case IntrinsicOperator::NEQV:
+    return LogicalOperator::Neqv;
+  case IntrinsicOperator::NOT:
+    return LogicalOperator::Not;
+  case IntrinsicOperator::LT:
+    return RelationalOperator::LT;
+  case IntrinsicOperator::LE:
+    return RelationalOperator::LE;
+  case IntrinsicOperator::EQ:
+    return RelationalOperator::EQ;
+  case IntrinsicOperator::NE:
+    return RelationalOperator::NE;
+  case IntrinsicOperator::GE:
+    return RelationalOperator::GE;
+  case IntrinsicOperator::GT:
+    return RelationalOperator::GT;
   }
 }
 
@@ -203,7 +220,7 @@ private:
   SemanticsContext &context_;
   ArraySpec arraySpec_;
 
-  template<typename T> void Analyze(const std::list<T> &list) {
+  template <typename T> void Analyze(const std::list<T> &list) {
     for (const auto &elem : list) {
       Analyze(elem);
     }
@@ -240,15 +257,14 @@ ArraySpec ArraySpecAnalyzer::Analyze(const parser::ComponentArraySpec &x) {
   return arraySpec_;
 }
 ArraySpec ArraySpecAnalyzer::Analyze(const parser::ArraySpec &x) {
-  std::visit(
-      common::visitors{
-          [&](const parser::AssumedSizeSpec &y) {
-            Analyze(std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
-            Analyze(std::get<parser::AssumedImpliedSpec>(y.t));
-          },
-          [&](const parser::ImpliedShapeSpec &y) { Analyze(y.v); },
-          [&](const auto &y) { Analyze(y); },
-      },
+  std::visit(common::visitors{
+                 [&](const parser::AssumedSizeSpec &y) {
+                   Analyze(std::get<std::list<parser::ExplicitShapeSpec>>(y.t));
+                   Analyze(std::get<parser::AssumedImpliedSpec>(y.t));
+                 },
+                 [&](const parser::ImpliedShapeSpec &y) { Analyze(y.v); },
+                 [&](const auto &y) { Analyze(y); },
+             },
       x.u);
   CHECK(!arraySpec_.empty());
   return arraySpec_;
@@ -356,15 +372,15 @@ void EquivalenceSets::AddToSet(const parser::Designator &designator) {
 }
 
 void EquivalenceSets::FinishSet(const parser::CharBlock &source) {
-  std::set<std::size_t> existing;  // indices of sets intersecting this one
+  std::set<std::size_t> existing; // indices of sets intersecting this one
   for (auto &obj : currSet_) {
     auto it{objectToSet_.find(obj)};
     if (it != objectToSet_.end()) {
-      existing.insert(it->second);  // symbol already in this set
+      existing.insert(it->second); // symbol already in this set
     }
   }
   if (existing.empty()) {
-    sets_.push_back({});  // create a new equivalence set
+    sets_.push_back({}); // create a new equivalence set
     MergeInto(source, currSet_, sets_.size() - 1);
   } else {
     auto it{existing.begin()};
@@ -388,7 +404,7 @@ bool EquivalenceSets::CheckCanEquivalence(
   bool isChar1{IsCharacterSequenceType(type1)};
   bool isChar2{IsCharacterSequenceType(type2)};
   if (sym1.attrs().test(Attr::PROTECTED) &&
-      !sym2.attrs().test(Attr::PROTECTED)) {  // C8114
+      !sym2.attrs().test(Attr::PROTECTED)) { // C8114
     msg = "Equivalence set cannot contain '%s'"
           " with PROTECTED attribute and '%s' without"_err_en_US;
   } else if (isNum1) {
@@ -398,7 +414,7 @@ bool EquivalenceSets::CheckCanEquivalence(
         msg = "Equivalence set contains '%s' that is numeric sequence "
               "type and '%s' that is character"_en_US;
       }
-    } else if (!isNum2) {  // C8110
+    } else if (!isNum2) { // C8110
       msg = "Equivalence set cannot contain '%s'"
             " that is numeric sequence type and '%s' that is not"_err_en_US;
     }
@@ -409,11 +425,11 @@ bool EquivalenceSets::CheckCanEquivalence(
         msg = "Equivalence set contains '%s' that is character sequence "
               "type and '%s' that is numeric"_en_US;
       }
-    } else if (!isChar2) {  // C8111
+    } else if (!isChar2) { // C8111
       msg = "Equivalence set cannot contain '%s'"
             " that is character sequence type and '%s' that is not"_err_en_US;
     }
-  } else if (!isNum2 && !isChar2 && *type1 != *type2) {  // C8112, C8113
+  } else if (!isNum2 && !isChar2 && *type1 != *type2) { // C8112, C8113
     msg = "Equivalence set cannot contain '%s' and '%s' with different types"
           " that are neither numeric nor character sequence types"_err_en_US;
   }
@@ -432,7 +448,7 @@ void EquivalenceSets::MergeInto(const parser::CharBlock &source,
   for (const auto &obj : src) {
     if (const auto *obj2{Find(dst, obj.symbol)}) {
       if (obj == *obj2) {
-        continue;  // already there
+        continue; // already there
       }
       context_.Say(source,
           "'%s' and '%s' cannot have the same first storage unit"_err_en_US,
@@ -487,7 +503,7 @@ bool EquivalenceSets::CheckDataRef(
       common::visitors{
           [&](const parser::Name &name) { return CheckObject(name); },
           [&](const common::Indirection<parser::StructureComponent> &) {
-            context_.Say(source,  // C8107
+            context_.Say(source, // C8107
                 "Derived type component '%s' is not allowed in an equivalence set"_err_en_US,
                 source);
             return false;
@@ -498,7 +514,7 @@ bool EquivalenceSets::CheckDataRef(
               ok &= std::visit(
                   common::visitors{
                       [&](const parser::SubscriptTriplet &) {
-                        context_.Say(source,  // C924, R872
+                        context_.Say(source, // C924, R872
                             "Array section '%s' is not allowed in an equivalence set"_err_en_US,
                             source);
                         return false;
@@ -512,7 +528,7 @@ bool EquivalenceSets::CheckDataRef(
             return ok;
           },
           [&](const common::Indirection<parser::CoindexedNamedObject> &) {
-            context_.Say(source,  // C924 (R872)
+            context_.Say(source, // C924 (R872)
                 "Coindexed object '%s' is not allowed in an equivalence set"_err_en_US,
                 source);
             return false;
@@ -533,43 +549,43 @@ static bool InCommonWithBind(const Symbol &symbol) {
 // If symbol can't be in equivalence set report error and return false;
 bool EquivalenceSets::CheckObject(const parser::Name &name) {
   if (!name.symbol) {
-    return false;  // an error has already occurred
+    return false; // an error has already occurred
   }
   currObject_.symbol = name.symbol;
   parser::MessageFixedText msg{"", 0};
   const Symbol &symbol{*name.symbol};
-  if (symbol.owner().IsDerivedType()) {  // C8107
+  if (symbol.owner().IsDerivedType()) { // C8107
     msg = "Derived type component '%s'"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.IsDummy()) {  // C8106
+  } else if (symbol.IsDummy()) { // C8106
     msg = "Dummy argument '%s' is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.IsFuncResult()) {  // C8106
+  } else if (symbol.IsFuncResult()) { // C8106
     msg = "Function result '%s' is not allow in an equivalence set"_err_en_US;
-  } else if (IsPointer(symbol)) {  // C8106
+  } else if (IsPointer(symbol)) { // C8106
     msg = "Pointer '%s' is not allowed in an equivalence set"_err_en_US;
-  } else if (IsAllocatable(symbol)) {  // C8106
+  } else if (IsAllocatable(symbol)) { // C8106
     msg = "Allocatable variable '%s'"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.Corank() > 0) {  // C8106
+  } else if (symbol.Corank() > 0) { // C8106
     msg = "Coarray '%s' is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.has<UseDetails>()) {  // C8115
+  } else if (symbol.has<UseDetails>()) { // C8115
     msg = "Use-associated variable '%s'"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.attrs().test(Attr::BIND_C)) {  // C8106
+  } else if (symbol.attrs().test(Attr::BIND_C)) { // C8106
     msg = "Variable '%s' with BIND attribute"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (symbol.attrs().test(Attr::TARGET)) {  // C8108
+  } else if (symbol.attrs().test(Attr::TARGET)) { // C8108
     msg = "Variable '%s' with TARGET attribute"
           " is not allowed in an equivalence set"_err_en_US;
-  } else if (IsNamedConstant(symbol)) {  // C8106
+  } else if (IsNamedConstant(symbol)) { // C8106
     msg = "Named constant '%s' is not allowed in an equivalence set"_err_en_US;
-  } else if (InCommonWithBind(symbol)) {  // C8106
+  } else if (InCommonWithBind(symbol)) { // C8106
     msg = "Variable '%s' in common block with BIND attribute"
           " is not allowed in an equivalence set"_err_en_US;
   } else if (const auto *type{symbol.GetType()}) {
     if (const auto *derived{type->AsDerived()}) {
       if (const auto *comp{FindUltimateComponent(
-              *derived, IsAllocatableOrPointer)}) {  // C8106
+              *derived, IsAllocatableOrPointer)}) { // C8106
         msg = IsPointer(*comp)
             ? "Derived type object '%s' with pointer ultimate component"
               " is not allowed in an equivalence set"_err_en_US
@@ -605,14 +621,14 @@ bool EquivalenceSets::CheckArrayBound(const parser::Expr &bound) {
     return false;
   }
   if (expr->Rank() > 0) {
-    context_.Say(bound.source,  // C924, R872
+    context_.Say(bound.source, // C924, R872
         "Array with vector subscript '%s' is not allowed in an equivalence set"_err_en_US,
         bound.source);
     return false;
   }
   auto subscript{evaluate::ToInt64(*expr)};
   if (!subscript) {
-    context_.Say(bound.source,  // C8109
+    context_.Say(bound.source, // C8109
         "Array with nonconstant subscript '%s' is not allowed in an equivalence set"_err_en_US,
         bound.source);
     return false;
@@ -630,7 +646,7 @@ bool EquivalenceSets::CheckSubstringBound(
   }
   auto subscript{evaluate::ToInt64(*expr)};
   if (!subscript) {
-    context_.Say(bound.source,  // C8109
+    context_.Say(bound.source, // C8109
         "Substring with nonconstant bound '%s' is not allowed in an equivalence set"_err_en_US,
         bound.source);
     return false;
@@ -638,7 +654,7 @@ bool EquivalenceSets::CheckSubstringBound(
   if (!isStart) {
     auto start{currObject_.substringStart};
     if (*subscript < (start ? *start : 1)) {
-      context_.Say(bound.source,  // C8116
+      context_.Say(bound.source, // C8116
           "Substring with zero length is not allowed in an equivalence set"_err_en_US);
       return false;
     }
@@ -663,11 +679,13 @@ bool EquivalenceSets::IsDefaultKindNumericType(const IntrinsicTypeSpec &type) {
     auto defaultKind{context_.GetDefaultKind(category)};
     switch (category) {
     case TypeCategory::Integer:
-    case TypeCategory::Logical: return *kind == defaultKind;
+    case TypeCategory::Logical:
+      return *kind == defaultKind;
     case TypeCategory::Real:
     case TypeCategory::Complex:
       return *kind == defaultKind || *kind == context_.doublePrecisionKind();
-    default: return false;
+    default:
+      return false;
     }
   }
   return false;
@@ -701,4 +719,4 @@ bool EquivalenceSets::IsSequenceType(const DeclTypeSpec *type,
   }
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/resolve-names-utils.h b/flang/lib/Semantics/resolve-names-utils.h
index 055e47db1253..e04f58f1cc57 100644
--- a/flang/lib/Semantics/resolve-names-utils.h
+++ b/flang/lib/Semantics/resolve-names-utils.h
@@ -28,7 +28,7 @@ struct Designator;
 struct Expr;
 struct GenericSpec;
 struct Name;
-}
+} // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
@@ -108,16 +108,16 @@ private:
       const DeclTypeSpec *, std::function<bool(const IntrinsicTypeSpec &)>);
 
   SemanticsContext &context_;
-  std::vector<EquivalenceSet> sets_;  // all equivalence sets in this scope
+  std::vector<EquivalenceSet> sets_; // all equivalence sets in this scope
   // Map object to index of set it is in
   std::map<EquivalenceObject, std::size_t> objectToSet_;
-  EquivalenceSet currSet_;  // equivalence set currently being constructed
+  EquivalenceSet currSet_; // equivalence set currently being constructed
   struct {
     Symbol *symbol{nullptr};
     std::vector<ConstantSubscript> subscripts;
     std::optional<ConstantSubscript> substringStart;
-  } currObject_;  // equivalence object currently being constructed
+  } currObject_; // equivalence object currently being constructed
 };
 
-}
-#endif  // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_
+} // namespace Fortran::semantics
+#endif // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_
diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp
index 22f37a0347ec..805a9c7a9979 100644
--- a/flang/lib/Semantics/resolve-names.cpp
+++ b/flang/lib/Semantics/resolve-names.cpp
@@ -1544,12 +1544,11 @@ bool AttrsVisitor::SetPassNameOn(Symbol &symbol) {
   if (!passName_) {
     return false;
   }
-  std::visit(
-      common::visitors{
-          [&](ProcEntityDetails &x) { x.set_passName(*passName_); },
-          [&](ProcBindingDetails &x) { x.set_passName(*passName_); },
-          [](auto &) { common::die("unexpected pass name"); },
-      },
+  std::visit(common::visitors{
+                 [&](ProcEntityDetails &x) { x.set_passName(*passName_); },
+                 [&](ProcBindingDetails &x) { x.set_passName(*passName_); },
+                 [](auto &) { common::die("unexpected pass name"); },
+             },
       symbol.details());
   return true;
 }
@@ -1747,23 +1746,23 @@ void ImplicitRulesVisitor::Post(const parser::ParameterStmt &) {
 }
 
 bool ImplicitRulesVisitor::Pre(const parser::ImplicitStmt &x) {
-  bool result{std::visit(
-      common::visitors{
-          [&](const std::list<ImplicitNoneNameSpec> &y) {
-            return HandleImplicitNone(y);
-          },
-          [&](const std::list<parser::ImplicitSpec> &) {
-            if (prevImplicitNoneType_) {
-              Say("IMPLICIT statement after IMPLICIT NONE or "
-                  "IMPLICIT NONE(TYPE) statement"_err_en_US);
-              return false;
-            } else {
-              implicitRules().set_isImplicitNoneType(false);
-            }
-            return true;
-          },
-      },
-      x.u)};
+  bool result{
+      std::visit(common::visitors{
+                     [&](const std::list<ImplicitNoneNameSpec> &y) {
+                       return HandleImplicitNone(y);
+                     },
+                     [&](const std::list<parser::ImplicitSpec> &) {
+                       if (prevImplicitNoneType_) {
+                         Say("IMPLICIT statement after IMPLICIT NONE or "
+                             "IMPLICIT NONE(TYPE) statement"_err_en_US);
+                         return false;
+                       } else {
+                         implicitRules().set_isImplicitNoneType(false);
+                       }
+                       return true;
+                     },
+                 },
+          x.u)};
   prevImplicit_ = currStmtSource();
   return result;
 }
@@ -2107,18 +2106,17 @@ void ScopeHandler::EraseSymbol(const parser::Name &name) {
 
 static bool NeedsType(const Symbol &symbol) {
   return !symbol.GetType() &&
-      std::visit(
-          common::visitors{
-              [](const EntityDetails &) { return true; },
-              [](const ObjectEntityDetails &) { return true; },
-              [](const AssocEntityDetails &) { return true; },
-              [&](const ProcEntityDetails &p) {
-                return symbol.test(Symbol::Flag::Function) &&
-                    !symbol.attrs().test(Attr::INTRINSIC) &&
-                    !p.interface().type() && !p.interface().symbol();
-              },
-              [](const auto &) { return false; },
-          },
+      std::visit(common::visitors{
+                     [](const EntityDetails &) { return true; },
+                     [](const ObjectEntityDetails &) { return true; },
+                     [](const AssocEntityDetails &) { return true; },
+                     [&](const ProcEntityDetails &p) {
+                       return symbol.test(Symbol::Flag::Function) &&
+                           !symbol.attrs().test(Attr::INTRINSIC) &&
+                           !p.interface().type() && !p.interface().symbol();
+                     },
+                     [](const auto &) { return false; },
+                 },
           symbol.details());
 }
 void ScopeHandler::ApplyImplicitRules(Symbol &symbol) {
@@ -2216,16 +2214,15 @@ void ScopeHandler::MakeExternal(Symbol &symbol) {
 // ModuleVisitor implementation
 
 bool ModuleVisitor::Pre(const parser::Only &x) {
-  std::visit(
-      common::visitors{
-          [&](const Indirection<parser::GenericSpec> &generic) {
-            AddUse(GenericSpecInfo{generic.value()});
-          },
-          [&](const parser::Name &name) {
-            Resolve(name, AddUse(name.source, name.source).use);
-          },
-          [&](const parser::Rename &rename) { Walk(rename); },
-      },
+  std::visit(common::visitors{
+                 [&](const Indirection<parser::GenericSpec> &generic) {
+                   AddUse(GenericSpecInfo{generic.value()});
+                 },
+                 [&](const parser::Name &name) {
+                   Resolve(name, AddUse(name.source, name.source).use);
+                 },
+                 [&](const parser::Rename &rename) { Walk(rename); },
+             },
       x.u);
   return false;
 }
@@ -2268,15 +2265,14 @@ void ModuleVisitor::Post(const parser::UseStmt &x) {
     // then add a use for each public name that was not renamed.
     std::set<SourceName> useNames;
     for (const auto &rename : *list) {
-      std::visit(
-          common::visitors{
-              [&](const parser::Rename::Names &names) {
-                useNames.insert(std::get<1>(names.t).source);
-              },
-              [&](const parser::Rename::Operators &ops) {
-                useNames.insert(std::get<1>(ops.t).v.source);
-              },
-          },
+      std::visit(common::visitors{
+                     [&](const parser::Rename::Names &names) {
+                       useNames.insert(std::get<1>(names.t).source);
+                     },
+                     [&](const parser::Rename::Operators &ops) {
+                       useNames.insert(std::get<1>(ops.t).v.source);
+                     },
+                 },
           rename.u);
     }
     for (const auto &[name, symbol] : *useModuleScope_) {
@@ -4905,30 +4901,30 @@ bool ConstructVisitor::Pre(const parser::DataImpliedDo &x) {
 }
 
 bool ConstructVisitor::Pre(const parser::DataStmtObject &x) {
-  std::visit(
-      common::visitors{
-          [&](const Indirection<parser::Variable> &y) {
-            Walk(y.value());
-            if (const auto *designator{
-                    std::get_if<Indirection<parser::Designator>>(
-                        &y.value().u)}) {
-              if (const parser::Name *
-                  name{ResolveDesignator(designator->value())}) {
-                if (name->symbol) {
-                  name->symbol->set(Symbol::Flag::InDataStmt);
-                }
-              }
-              // TODO check C874 - C881
-            } else {
-              // TODO report C875 error: variable is not a designator here?
-            }
-          },
-          [&](const parser::DataImpliedDo &y) {
-            PushScope(Scope::Kind::ImpliedDos, nullptr);
-            Walk(y);
-            PopScope();
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const Indirection<parser::Variable> &y) {
+                   Walk(y.value());
+                   if (const auto *designator{
+                           std::get_if<Indirection<parser::Designator>>(
+                               &y.value().u)}) {
+                     if (const parser::Name *
+                         name{ResolveDesignator(designator->value())}) {
+                       if (name->symbol) {
+                         name->symbol->set(Symbol::Flag::InDataStmt);
+                       }
+                     }
+                     // TODO check C874 - C881
+                   } else {
+                     // TODO report C875 error: variable is not a designator
+                     // here?
+                   }
+                 },
+                 [&](const parser::DataImpliedDo &y) {
+                   PushScope(Scope::Kind::ImpliedDos, nullptr);
+                   Walk(y);
+                   PopScope();
+                 },
+             },
       x.u);
   return false;
 }
@@ -5181,15 +5177,14 @@ void ConstructVisitor::SetAttrsFromAssociation(Symbol &symbol) {
 
 ConstructVisitor::Selector ConstructVisitor::ResolveSelector(
     const parser::Selector &x) {
-  return std::visit(
-      common::visitors{
-          [&](const parser::Expr &expr) {
-            return Selector{expr.source, EvaluateExpr(expr)};
-          },
-          [&](const parser::Variable &var) {
-            return Selector{var.GetSource(), EvaluateExpr(var)};
-          },
-      },
+  return std::visit(common::visitors{
+                        [&](const parser::Expr &expr) {
+                          return Selector{expr.source, EvaluateExpr(expr)};
+                        },
+                        [&](const parser::Variable &var) {
+                          return Selector{var.GetSource(), EvaluateExpr(var)};
+                        },
+                    },
       x.u);
 }
 
@@ -5365,13 +5360,12 @@ const parser::Name *DeclarationVisitor::ResolveVariable(
           [&](const Indirection<parser::FunctionReference> &y) {
             const auto &proc{
                 std::get<parser::ProcedureDesignator>(y.value().v.t)};
-            return std::visit(
-                common::visitors{
-                    [&](const parser::Name &z) { return &z; },
-                    [&](const parser::ProcComponentRef &z) {
-                      return ResolveStructureComponent(z.v.thing);
-                    },
-                },
+            return std::visit(common::visitors{
+                                  [&](const parser::Name &z) { return &z; },
+                                  [&](const parser::ProcComponentRef &z) {
+                                    return ResolveStructureComponent(z.v.thing);
+                                  },
+                              },
                 proc.u);
           },
       },
@@ -5964,23 +5958,21 @@ bool ResolveNamesVisitor::Pre(const parser::ImplicitStmt &x) {
 }
 
 void ResolveNamesVisitor::Post(const parser::PointerObject &x) {
-  std::visit(
-      common::visitors{
-          [&](const parser::Name &x) { ResolveName(x); },
-          [&](const parser::StructureComponent &x) {
-            ResolveStructureComponent(x);
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const parser::Name &x) { ResolveName(x); },
+                 [&](const parser::StructureComponent &x) {
+                   ResolveStructureComponent(x);
+                 },
+             },
       x.u);
 }
 void ResolveNamesVisitor::Post(const parser::AllocateObject &x) {
-  std::visit(
-      common::visitors{
-          [&](const parser::Name &x) { ResolveName(x); },
-          [&](const parser::StructureComponent &x) {
-            ResolveStructureComponent(x);
-          },
-      },
+  std::visit(common::visitors{
+                 [&](const parser::Name &x) { ResolveName(x); },
+                 [&](const parser::StructureComponent &x) {
+                   ResolveStructureComponent(x);
+                 },
+             },
       x.u);
 }
 
diff --git a/flang/lib/Semantics/resolve-names.h b/flang/lib/Semantics/resolve-names.h
index 218dc9c63eae..1a16f0936c66 100644
--- a/flang/lib/Semantics/resolve-names.h
+++ b/flang/lib/Semantics/resolve-names.h
@@ -30,6 +30,6 @@ bool ResolveNames(SemanticsContext &, const parser::Program &);
 void ResolveSpecificationParts(SemanticsContext &, const Symbol &);
 void DumpSymbols(llvm::raw_ostream &);
 
-}
+} // namespace Fortran::semantics
 
-#endif  // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_
+#endif // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_
diff --git a/flang/lib/Semantics/rewrite-parse-tree.cpp b/flang/lib/Semantics/rewrite-parse-tree.cpp
index 761621cf58f0..046c61e33b36 100644
--- a/flang/lib/Semantics/rewrite-parse-tree.cpp
+++ b/flang/lib/Semantics/rewrite-parse-tree.cpp
@@ -28,12 +28,12 @@ using namespace parser::literals;
 class RewriteMutator {
 public:
   RewriteMutator(SemanticsContext &context)
-    : errorOnUnresolvedName_{!context.AnyFatalError()},
-      messages_{context.messages()} {}
+      : errorOnUnresolvedName_{!context.AnyFatalError()},
+        messages_{context.messages()} {}
 
   // Default action for a parse tree node is to visit children.
-  template<typename T> bool Pre(T &) { return true; }
-  template<typename T> void Post(T &) {}
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
 
   void Post(parser::Name &);
   void Post(parser::SpecificationPart &);
@@ -94,7 +94,7 @@ void RewriteMutator::Post(parser::SpecificationPart &x) {
 
 // Insert converted assignments at start of ExecutionPart.
 bool RewriteMutator::Pre(parser::ExecutionPart &x) {
-  auto origFirst{x.v.begin()};  // insert each elem before origFirst
+  auto origFirst{x.v.begin()}; // insert each elem before origFirst
   for (stmtFuncType &sf : stmtFuncsToConvert_) {
     auto stmt{sf.statement.value().ConvertToAssignment()};
     stmt.source = sf.source;
@@ -129,7 +129,7 @@ void RewriteMutator::Post(parser::IoUnit &x) {
 // statement in such a way that it can be misparsed as a format expression,
 // rewrite the I/O statement's parse tree node as if the namelist group
 // name had appeared with NML=.
-template<typename READ_OR_WRITE>
+template <typename READ_OR_WRITE>
 void FixMisparsedUntaggedNamelistName(READ_OR_WRITE &x) {
   if (x.iounit && x.format &&
       std::holds_alternative<parser::DefaultCharExpr>(x.format->u)) {
@@ -156,4 +156,4 @@ bool RewriteParseTree(SemanticsContext &context, parser::Program &program) {
   return !context.AnyFatalError();
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/rewrite-parse-tree.h b/flang/lib/Semantics/rewrite-parse-tree.h
index 7978fd60edda..313276db481d 100644
--- a/flang/lib/Semantics/rewrite-parse-tree.h
+++ b/flang/lib/Semantics/rewrite-parse-tree.h
@@ -12,7 +12,7 @@
 namespace Fortran::parser {
 class Messages;
 struct Program;
-}
+} // namespace Fortran::parser
 namespace Fortran::semantics {
 class SemanticsContext;
 }
@@ -21,4 +21,4 @@ namespace Fortran::semantics {
 bool RewriteParseTree(SemanticsContext &, parser::Program &);
 }
 
-#endif  // FORTRAN_SEMANTICS_REWRITE_PARSE_TREE_H_
+#endif // FORTRAN_SEMANTICS_REWRITE_PARSE_TREE_H_
diff --git a/flang/lib/Semantics/scope.cpp b/flang/lib/Semantics/scope.cpp
index c25ce1114ddc..dc934a51190d 100644
--- a/flang/lib/Semantics/scope.cpp
+++ b/flang/lib/Semantics/scope.cpp
@@ -117,7 +117,7 @@ bool Scope::Contains(const Scope &that) const {
 Symbol *Scope::CopySymbol(const Symbol &symbol) {
   auto pair{try_emplace(symbol.name(), symbol.attrs())};
   if (!pair.second) {
-    return nullptr;  // already exists
+    return nullptr; // already exists
   } else {
     Symbol &result{*pair.first->second};
     result.flags() = symbol.flags();
@@ -216,7 +216,7 @@ Scope::ImportKind Scope::GetImportKind() const {
   if (symbol_ && !symbol_->attrs().test(Attr::MODULE)) {
     if (auto *details{symbol_->detailsIf<SubprogramDetails>()}) {
       if (details->isInterface()) {
-        return ImportKind::None;  // default for non-mod-proc interface body
+        return ImportKind::None; // default for non-mod-proc interface body
       }
     }
   }
@@ -254,10 +254,13 @@ bool Scope::CanImport(const SourceName &name) const {
   }
   switch (GetImportKind()) {
     SWITCH_COVERS_ALL_CASES
-  case ImportKind::None: return false;
+  case ImportKind::None:
+    return false;
   case ImportKind::All:
-  case ImportKind::Default: return true;
-  case ImportKind::Only: return importNames_.count(name) > 0;
+  case ImportKind::Default:
+    return true;
+  case ImportKind::Only:
+    return importNames_.count(name) > 0;
   }
 }
 
@@ -367,4 +370,4 @@ void Scope::InstantiateDerivedTypes(SemanticsContext &context) {
     }
   }
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/symbol.cpp b/flang/lib/Semantics/symbol.cpp
index ecda5d1f6303..e48b7b950a6d 100644
--- a/flang/lib/Semantics/symbol.cpp
+++ b/flang/lib/Semantics/symbol.cpp
@@ -17,13 +17,13 @@
 
 namespace Fortran::semantics {
 
-template<typename T>
+template <typename T>
 static void DumpOptional(llvm::raw_ostream &os, const char *label, const T &x) {
   if (x) {
     os << ' ' << label << ':' << *x;
   }
 }
-template<typename T>
+template <typename T>
 static void DumpExpr(llvm::raw_ostream &os, const char *label,
     const std::optional<evaluate::Expr<T>> &x) {
   if (x) {
@@ -56,7 +56,7 @@ static void DumpType(llvm::raw_ostream &os, const DeclTypeSpec *type) {
   }
 }
 
-template<typename T>
+template <typename T>
 static void DumpList(llvm::raw_ostream &os, const char *label, const T &list) {
   if (!list.empty()) {
     os << ' ' << label << ':';
@@ -155,7 +155,7 @@ UseErrorDetails &UseErrorDetails::add_occurrence(
 }
 
 GenericDetails::GenericDetails(const SymbolVector &specificProcs)
-  : specificProcs_{specificProcs} {}
+    : specificProcs_{specificProcs} {}
 
 void GenericDetails::AddSpecificProc(
     const Symbol &proc, SourceName bindingName) {
@@ -247,7 +247,7 @@ void Symbol::set_details(Details &&details) {
 
 bool Symbol::CanReplaceDetails(const Details &details) const {
   if (has<UnknownDetails>()) {
-    return true;  // can always replace UnknownDetails
+    return true; // can always replace UnknownDetails
   } else {
     return std::visit(
         common::visitors{
@@ -275,15 +275,14 @@ void Symbol::ReplaceName(const SourceName &name) {
 }
 
 void Symbol::SetType(const DeclTypeSpec &type) {
-  std::visit(
-      common::visitors{
-          [&](EntityDetails &x) { x.set_type(type); },
-          [&](ObjectEntityDetails &x) { x.set_type(type); },
-          [&](AssocEntityDetails &x) { x.set_type(type); },
-          [&](ProcEntityDetails &x) { x.interface().set_type(type); },
-          [&](TypeParamDetails &x) { x.set_type(type); },
-          [](auto &) {},
-      },
+  std::visit(common::visitors{
+                 [&](EntityDetails &x) { x.set_type(type); },
+                 [&](ObjectEntityDetails &x) { x.set_type(type); },
+                 [&](AssocEntityDetails &x) { x.set_type(type); },
+                 [&](ProcEntityDetails &x) { x.interface().set_type(type); },
+                 [&](TypeParamDetails &x) { x.set_type(type); },
+                 [](auto &) {},
+             },
       details_);
 }
 
@@ -330,7 +329,7 @@ bool Symbol::IsFromModFile() const {
 }
 
 ObjectEntityDetails::ObjectEntityDetails(EntityDetails &&d)
-  : EntityDetails(d) {}
+    : EntityDetails(d) {}
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const EntityDetails &x) {
   DumpBool(os, "dummy", x.isDummy());
@@ -557,7 +556,7 @@ static const DeclTypeSpec &InstantiateIntrinsicType(Scope &scope,
     const DeclTypeSpec &spec, SemanticsContext &semanticsContext) {
   const IntrinsicTypeSpec &intrinsic{DEREF(spec.AsIntrinsic())};
   if (evaluate::ToInt64(intrinsic.kind())) {
-    return spec;  // KIND is already a known constant
+    return spec; // KIND is already a known constant
   }
   // The expression was not originally constant, but now it must be so
   // in the context of a parameterized derived type instantiation.
@@ -580,12 +579,13 @@ static const DeclTypeSpec &InstantiateIntrinsicType(Scope &scope,
   switch (spec.category()) {
   case DeclTypeSpec::Numeric:
     return scope.MakeNumericType(intrinsic.category(), KindExpr{kind});
-  case DeclTypeSpec::Logical:  //
+  case DeclTypeSpec::Logical: //
     return scope.MakeLogicalType(KindExpr{kind});
   case DeclTypeSpec::Character:
     return scope.MakeCharacterType(
         ParamValue{spec.characterTypeSpec().length()}, KindExpr{kind});
-  default: CRASH_NO_CASE;
+  default:
+    CRASH_NO_CASE;
   }
 }
 
@@ -607,7 +607,7 @@ Symbol &Symbol::InstantiateComponent(
     if (DeclTypeSpec * origType{result.GetType()}) {
       if (const DerivedTypeSpec * derived{origType->AsDerived()}) {
         DerivedTypeSpec newSpec{*derived};
-        newSpec.CookParameters(foldingContext);  // enables AddParamValue()
+        newSpec.CookParameters(foldingContext); // enables AddParamValue()
         if (test(Symbol::Flag::ParentComp)) {
           // Forward any explicit type parameter values from the
           // derived type spec under instantiation that define type parameters
@@ -728,4 +728,4 @@ bool GenericKind::Is(GenericKind::OtherKind x) const {
   return y && *y == x;
 }
 
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/type.cpp b/flang/lib/Semantics/type.cpp
index cba4d3ce9b0c..108d04a1c403 100644
--- a/flang/lib/Semantics/type.cpp
+++ b/flang/lib/Semantics/type.cpp
@@ -17,7 +17,7 @@
 namespace Fortran::semantics {
 
 DerivedTypeSpec::DerivedTypeSpec(SourceName name, const Symbol &typeSymbol)
-  : name_{name}, typeSymbol_{typeSymbol} {
+    : name_{name}, typeSymbol_{typeSymbol} {
   CHECK(typeSymbol.has<DerivedTypeDetails>());
 }
 DerivedTypeSpec::DerivedTypeSpec(const DerivedTypeSpec &that) = default;
@@ -157,7 +157,7 @@ void DerivedTypeSpec::EvaluateParameters(
 void DerivedTypeSpec::AddParamValue(SourceName name, ParamValue &&value) {
   CHECK(cooked_);
   auto pair{parameters_.insert(std::make_pair(name, std::move(value)))};
-  CHECK(pair.second);  // name was not already present
+  CHECK(pair.second); // name was not already present
 }
 
 bool DerivedTypeSpec::MightBeParameterized() const {
@@ -379,13 +379,13 @@ llvm::raw_ostream &operator<<(
 }
 
 ParamValue::ParamValue(MaybeIntExpr &&expr, common::TypeParamAttr attr)
-  : attr_{attr}, expr_{std::move(expr)} {}
+    : attr_{attr}, expr_{std::move(expr)} {}
 ParamValue::ParamValue(SomeIntExpr &&expr, common::TypeParamAttr attr)
-  : attr_{attr}, expr_{std::move(expr)} {}
+    : attr_{attr}, expr_{std::move(expr)} {}
 ParamValue::ParamValue(
     common::ConstantSubscript value, common::TypeParamAttr attr)
-  : ParamValue(
-        SomeIntExpr{evaluate::Expr<evaluate::SubscriptInteger>{value}}, attr) {}
+    : ParamValue(SomeIntExpr{evaluate::Expr<evaluate::SubscriptInteger>{value}},
+          attr) {}
 
 void ParamValue::SetExplicit(SomeIntExpr &&x) {
   category_ = Category::Explicit;
@@ -395,8 +395,10 @@ void ParamValue::SetExplicit(SomeIntExpr &&x) {
 std::string ParamValue::AsFortran() const {
   switch (category_) {
     SWITCH_COVERS_ALL_CASES
-  case Category::Assumed: return "*";
-  case Category::Deferred: return ":";
+  case Category::Assumed:
+    return "*";
+  case Category::Deferred:
+    return ":";
   case Category::Explicit:
     if (expr_) {
       std::string buf;
@@ -414,7 +416,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &o, const ParamValue &x) {
 }
 
 IntrinsicTypeSpec::IntrinsicTypeSpec(TypeCategory category, KindExpr &&kind)
-  : category_{category}, kind_{std::move(kind)} {
+    : category_{category}, kind_{std::move(kind)} {
   CHECK(category != TypeCategory::Derived);
 }
 
@@ -422,7 +424,7 @@ static std::string KindAsFortran(const KindExpr &kind) {
   std::string buf;
   llvm::raw_string_ostream ss{buf};
   if (auto k{evaluate::ToInt64(kind)}) {
-    ss << *k;  // emit unsuffixed kind code
+    ss << *k; // emit unsuffixed kind code
   } else {
     kind.AsFortran(ss);
   }
@@ -449,19 +451,19 @@ llvm::raw_ostream &operator<<(
 }
 
 DeclTypeSpec::DeclTypeSpec(NumericTypeSpec &&typeSpec)
-  : category_{Numeric}, typeSpec_{std::move(typeSpec)} {}
+    : category_{Numeric}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(LogicalTypeSpec &&typeSpec)
-  : category_{Logical}, typeSpec_{std::move(typeSpec)} {}
+    : category_{Logical}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(const CharacterTypeSpec &typeSpec)
-  : category_{Character}, typeSpec_{typeSpec} {}
+    : category_{Character}, typeSpec_{typeSpec} {}
 DeclTypeSpec::DeclTypeSpec(CharacterTypeSpec &&typeSpec)
-  : category_{Character}, typeSpec_{std::move(typeSpec)} {}
+    : category_{Character}, typeSpec_{std::move(typeSpec)} {}
 DeclTypeSpec::DeclTypeSpec(Category category, const DerivedTypeSpec &typeSpec)
-  : category_{category}, typeSpec_{typeSpec} {
+    : category_{category}, typeSpec_{typeSpec} {
   CHECK(category == TypeDerived || category == ClassDerived);
 }
 DeclTypeSpec::DeclTypeSpec(Category category, DerivedTypeSpec &&typeSpec)
-  : category_{category}, typeSpec_{std::move(typeSpec)} {
+    : category_{category}, typeSpec_{std::move(typeSpec)} {
   CHECK(category == TypeDerived || category == ClassDerived);
 }
 DeclTypeSpec::DeclTypeSpec(Category category) : category_{category} {
@@ -489,13 +491,20 @@ bool DeclTypeSpec::operator==(const DeclTypeSpec &that) const {
 std::string DeclTypeSpec::AsFortran() const {
   switch (category_) {
     SWITCH_COVERS_ALL_CASES
-  case Numeric: return numericTypeSpec().AsFortran();
-  case Logical: return logicalTypeSpec().AsFortran();
-  case Character: return characterTypeSpec().AsFortran();
-  case TypeDerived: return "TYPE(" + derivedTypeSpec().AsFortran() + ')';
-  case ClassDerived: return "CLASS(" + derivedTypeSpec().AsFortran() + ')';
-  case TypeStar: return "TYPE(*)";
-  case ClassStar: return "CLASS(*)";
+  case Numeric:
+    return numericTypeSpec().AsFortran();
+  case Logical:
+    return logicalTypeSpec().AsFortran();
+  case Character:
+    return characterTypeSpec().AsFortran();
+  case TypeDerived:
+    return "TYPE(" + derivedTypeSpec().AsFortran() + ')';
+  case ClassDerived:
+    return "CLASS(" + derivedTypeSpec().AsFortran() + ')';
+  case TypeStar:
+    return "TYPE(*)";
+  case ClassStar:
+    return "CLASS(*)";
   }
 }
 
@@ -511,4 +520,4 @@ void ProcInterface::set_type(const DeclTypeSpec &type) {
   CHECK(!symbol_);
   type_ = &type;
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/lib/Semantics/unparse-with-symbols.cpp b/flang/lib/Semantics/unparse-with-symbols.cpp
index b8e5e8837b3d..44ceb9fe08bb 100644
--- a/flang/lib/Semantics/unparse-with-symbols.cpp
+++ b/flang/lib/Semantics/unparse-with-symbols.cpp
@@ -26,13 +26,13 @@ public:
   // Write out symbols referenced at this statement.
   void PrintSymbols(const parser::CharBlock &, llvm::raw_ostream &, int);
 
-  template<typename T> bool Pre(const T &) { return true; }
-  template<typename T> void Post(const T &) {}
-  template<typename T> bool Pre(const parser::Statement<T> &stmt) {
+  template <typename T> bool Pre(const T &) { return true; }
+  template <typename T> void Post(const T &) {}
+  template <typename T> bool Pre(const parser::Statement<T> &stmt) {
     currStmt_ = stmt.source;
     return true;
   }
-  template<typename T> void Post(const parser::Statement<T> &) {
+  template <typename T> void Post(const parser::Statement<T> &) {
     currStmt_ = std::nullopt;
   }
   bool Pre(const parser::OmpClause &clause) {
@@ -48,15 +48,15 @@ public:
   void Post(const parser::Name &name);
 
 private:
-  std::optional<SourceName> currStmt_;  // current statement we are processing
-  std::multimap<const char *, const Symbol *> symbols_;  // location to symbol
-  std::set<const Symbol *> symbolsDefined_;  // symbols that have been processed
+  std::optional<SourceName> currStmt_; // current statement we are processing
+  std::multimap<const char *, const Symbol *> symbols_; // location to symbol
+  std::set<const Symbol *> symbolsDefined_; // symbols that have been processed
   void Indent(llvm::raw_ostream &, int) const;
 };
 
 void SymbolDumpVisitor::PrintSymbols(
     const parser::CharBlock &location, llvm::raw_ostream &out, int indent) {
-  std::set<const Symbol *> done;  // prevent duplicates on this line
+  std::set<const Symbol *> done; // prevent duplicates on this line
   auto range{symbols_.equal_range(location.begin())};
   for (auto it{range.first}; it != range.second; ++it) {
     const auto *symbol{it->second};
@@ -93,4 +93,4 @@ void UnparseWithSymbols(llvm::raw_ostream &out, const parser::Program &program,
           int indent) { visitor.PrintSymbols(location, out, indent); }};
   parser::Unparse(out, program, encoding, false, true, &preStatement);
 }
-}
+} // namespace Fortran::semantics
diff --git a/flang/runtime/ISO_Fortran_binding.cpp b/flang/runtime/ISO_Fortran_binding.cpp
index 1ebaa5858349..853d1f7b6f58 100644
--- a/flang/runtime/ISO_Fortran_binding.cpp
+++ b/flang/runtime/ISO_Fortran_binding.cpp
@@ -108,41 +108,99 @@ int CFI_deallocate(CFI_cdesc_t *descriptor) {
 static constexpr std::size_t MinElemLen(CFI_type_t type) {
   std::size_t minElemLen{0};
   switch (type) {
-  case CFI_type_signed_char: minElemLen = sizeof(signed char); break;
-  case CFI_type_short: minElemLen = sizeof(short); break;
-  case CFI_type_int: minElemLen = sizeof(int); break;
-  case CFI_type_long: minElemLen = sizeof(long); break;
-  case CFI_type_long_long: minElemLen = sizeof(long long); break;
-  case CFI_type_size_t: minElemLen = sizeof(std::size_t); break;
-  case CFI_type_int8_t: minElemLen = sizeof(std::int8_t); break;
-  case CFI_type_int16_t: minElemLen = sizeof(std::int16_t); break;
-  case CFI_type_int32_t: minElemLen = sizeof(std::int32_t); break;
-  case CFI_type_int64_t: minElemLen = sizeof(std::int64_t); break;
-  case CFI_type_int128_t: minElemLen = 2 * sizeof(std::int64_t); break;
-  case CFI_type_int_least8_t: minElemLen = sizeof(std::int_least8_t); break;
-  case CFI_type_int_least16_t: minElemLen = sizeof(std::int_least16_t); break;
-  case CFI_type_int_least32_t: minElemLen = sizeof(std::int_least32_t); break;
-  case CFI_type_int_least64_t: minElemLen = sizeof(std::int_least64_t); break;
+  case CFI_type_signed_char:
+    minElemLen = sizeof(signed char);
+    break;
+  case CFI_type_short:
+    minElemLen = sizeof(short);
+    break;
+  case CFI_type_int:
+    minElemLen = sizeof(int);
+    break;
+  case CFI_type_long:
+    minElemLen = sizeof(long);
+    break;
+  case CFI_type_long_long:
+    minElemLen = sizeof(long long);
+    break;
+  case CFI_type_size_t:
+    minElemLen = sizeof(std::size_t);
+    break;
+  case CFI_type_int8_t:
+    minElemLen = sizeof(std::int8_t);
+    break;
+  case CFI_type_int16_t:
+    minElemLen = sizeof(std::int16_t);
+    break;
+  case CFI_type_int32_t:
+    minElemLen = sizeof(std::int32_t);
+    break;
+  case CFI_type_int64_t:
+    minElemLen = sizeof(std::int64_t);
+    break;
+  case CFI_type_int128_t:
+    minElemLen = 2 * sizeof(std::int64_t);
+    break;
+  case CFI_type_int_least8_t:
+    minElemLen = sizeof(std::int_least8_t);
+    break;
+  case CFI_type_int_least16_t:
+    minElemLen = sizeof(std::int_least16_t);
+    break;
+  case CFI_type_int_least32_t:
+    minElemLen = sizeof(std::int_least32_t);
+    break;
+  case CFI_type_int_least64_t:
+    minElemLen = sizeof(std::int_least64_t);
+    break;
   case CFI_type_int_least128_t:
     minElemLen = 2 * sizeof(std::int_least64_t);
     break;
-  case CFI_type_int_fast8_t: minElemLen = sizeof(std::int_fast8_t); break;
-  case CFI_type_int_fast16_t: minElemLen = sizeof(std::int_fast16_t); break;
-  case CFI_type_int_fast32_t: minElemLen = sizeof(std::int_fast32_t); break;
-  case CFI_type_int_fast64_t: minElemLen = sizeof(std::int_fast64_t); break;
-  case CFI_type_intmax_t: minElemLen = sizeof(std::intmax_t); break;
-  case CFI_type_intptr_t: minElemLen = sizeof(std::intptr_t); break;
-  case CFI_type_ptrdiff_t: minElemLen = sizeof(std::ptrdiff_t); break;
-  case CFI_type_float: minElemLen = sizeof(float); break;
-  case CFI_type_double: minElemLen = sizeof(double); break;
-  case CFI_type_long_double: minElemLen = sizeof(long double); break;
-  case CFI_type_float_Complex: minElemLen = 2 * sizeof(float); break;
-  case CFI_type_double_Complex: minElemLen = 2 * sizeof(double); break;
+  case CFI_type_int_fast8_t:
+    minElemLen = sizeof(std::int_fast8_t);
+    break;
+  case CFI_type_int_fast16_t:
+    minElemLen = sizeof(std::int_fast16_t);
+    break;
+  case CFI_type_int_fast32_t:
+    minElemLen = sizeof(std::int_fast32_t);
+    break;
+  case CFI_type_int_fast64_t:
+    minElemLen = sizeof(std::int_fast64_t);
+    break;
+  case CFI_type_intmax_t:
+    minElemLen = sizeof(std::intmax_t);
+    break;
+  case CFI_type_intptr_t:
+    minElemLen = sizeof(std::intptr_t);
+    break;
+  case CFI_type_ptrdiff_t:
+    minElemLen = sizeof(std::ptrdiff_t);
+    break;
+  case CFI_type_float:
+    minElemLen = sizeof(float);
+    break;
+  case CFI_type_double:
+    minElemLen = sizeof(double);
+    break;
+  case CFI_type_long_double:
+    minElemLen = sizeof(long double);
+    break;
+  case CFI_type_float_Complex:
+    minElemLen = 2 * sizeof(float);
+    break;
+  case CFI_type_double_Complex:
+    minElemLen = 2 * sizeof(double);
+    break;
   case CFI_type_long_double_Complex:
     minElemLen = 2 * sizeof(long double);
     break;
-  case CFI_type_Bool: minElemLen = 1; break;
-  case CFI_type_cptr: minElemLen = sizeof(void *); break;
+  case CFI_type_Bool:
+    minElemLen = 1;
+    break;
+  case CFI_type_cptr:
+    minElemLen = sizeof(void *);
+    break;
   }
   return minElemLen;
 }
@@ -353,5 +411,5 @@ int CFI_setpointer(CFI_cdesc_t *result, const CFI_cdesc_t *source,
   }
   return CFI_SUCCESS;
 }
-}  // extern "C"
-}
+} // extern "C"
+} // namespace Fortran::ISO
diff --git a/flang/runtime/allocatable.h b/flang/runtime/allocatable.h
index bcb70356f322..d63bd2c482af 100644
--- a/flang/runtime/allocatable.h
+++ b/flang/runtime/allocatable.h
@@ -111,5 +111,5 @@ int RTNAME(AllocatableDeallocate)(Descriptor &, bool hasStat = false,
     Descriptor *errMsg = nullptr, const char *sourceFile = nullptr,
     int sourceLine = 0);
 }
-}
-#endif  // FORTRAN_RUNTIME_ALLOCATABLE_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_ALLOCATABLE_H_
diff --git a/flang/runtime/buffer.cpp b/flang/runtime/buffer.cpp
index 607bbfcc9ec2..d5081ee7a182 100644
--- a/flang/runtime/buffer.cpp
+++ b/flang/runtime/buffer.cpp
@@ -16,8 +16,8 @@ namespace Fortran::runtime::io {
 void LeftShiftBufferCircularly(
     char *buffer, std::size_t bytes, std::size_t shift) {
   // Assume that we start with "efgabcd" and the left shift is 3.
-  std::reverse(buffer, buffer + shift);  // "gfeabcd"
-  std::reverse(buffer, buffer + bytes);  // "dcbaefg"
-  std::reverse(buffer, buffer + bytes - shift);  // "abcdefg"
-}
+  std::reverse(buffer, buffer + shift); // "gfeabcd"
+  std::reverse(buffer, buffer + bytes); // "dcbaefg"
+  std::reverse(buffer, buffer + bytes - shift); // "abcdefg"
 }
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/buffer.h b/flang/runtime/buffer.h
index 63bbbdc26c02..27e0ac31579d 100644
--- a/flang/runtime/buffer.h
+++ b/flang/runtime/buffer.h
@@ -27,7 +27,7 @@ void LeftShiftBufferCircularly(char *, std::size_t bytes, std::size_t shift);
 // preserve read data that may be reused by means of Tn/TLn edit descriptors
 // without needing to position the file (which may not always be possible,
 // e.g. a socket) and a general desire to reduce system call counts.
-template<typename STORE> class FileFrame {
+template <typename STORE> class FileFrame {
 public:
   using FileOffset = std::int64_t;
 
@@ -65,10 +65,10 @@ public:
           std::memmove(buffer_, buffer_ + start_, length_);
         } else {
           // [cde........ab] -> [abcde........]
-          auto n{start_ + length_ - size_};  // 3 for cde
+          auto n{start_ + length_ - size_}; // 3 for cde
           RUNTIME_CHECK(handler, length_ >= n);
-          std::memmove(buffer_ + n, buffer_ + start_, length_ - n);  // cdeab
-          LeftShiftBufferCircularly(buffer_, length_, n);  // abcde
+          std::memmove(buffer_ + n, buffer_ + start_, length_ - n); // cdeab
+          LeftShiftBufferCircularly(buffer_, length_, n); // abcde
         }
         start_ = 0;
       }
@@ -83,7 +83,7 @@ public:
       length_ += got;
       RUNTIME_CHECK(handler, length_ < size_);
       if (got < minBytes) {
-        break;  // error or EOF & program can handle it
+        break; // error or EOF & program can handle it
       }
     }
     return FrameLength();
@@ -165,12 +165,12 @@ private:
   static constexpr std::size_t minBuffer{64 << 10};
 
   char *buffer_{nullptr};
-  std::int64_t size_{0};  // current allocated buffer size
-  FileOffset fileOffset_{0};  // file offset corresponding to buffer valid data
-  std::int64_t start_{0};  // buffer_[] offset of valid data
-  std::int64_t length_{0};  // valid data length (can wrap)
-  std::int64_t frame_{0};  // offset of current frame in valid data
+  std::int64_t size_{0}; // current allocated buffer size
+  FileOffset fileOffset_{0}; // file offset corresponding to buffer valid data
+  std::int64_t start_{0}; // buffer_[] offset of valid data
+  std::int64_t length_{0}; // valid data length (can wrap)
+  std::int64_t frame_{0}; // offset of current frame in valid data
   bool dirty_{false};
 };
-}
-#endif  // FORTRAN_RUNTIME_BUFFER_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_BUFFER_H_
diff --git a/flang/runtime/c-or-cpp.h b/flang/runtime/c-or-cpp.h
index d9029261ae4a..016bce07956d 100644
--- a/flang/runtime/c-or-cpp.h
+++ b/flang/runtime/c-or-cpp.h
@@ -26,4 +26,4 @@
 #define NORETURN IF_CPLUSPLUS([[noreturn]])
 #define NO_ARGUMENTS IF_NOT_CPLUSPLUS(void)
 
-#endif  // FORTRAN_RUNTIME_C_OR_CPP_H_
+#endif // FORTRAN_RUNTIME_C_OR_CPP_H_
diff --git a/flang/runtime/connection.cpp b/flang/runtime/connection.cpp
index e4a716560a45..d61f4ce5e08d 100644
--- a/flang/runtime/connection.cpp
+++ b/flang/runtime/connection.cpp
@@ -29,4 +29,4 @@ void ConnectionState::HandleAbsolutePosition(std::int64_t n) {
 void ConnectionState::HandleRelativePosition(std::int64_t n) {
   positionInRecord = std::max(leftTabLimit.value_or(0), positionInRecord + n);
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/connection.h b/flang/runtime/connection.h
index 1c0716145b47..67d4d77fd4fb 100644
--- a/flang/runtime/connection.h
+++ b/flang/runtime/connection.h
@@ -25,33 +25,33 @@ inline bool IsRecordFile(Access a) { return a != Access::Stream; }
 // These characteristics of a connection are immutable after being
 // established in an OPEN statement.
 struct ConnectionAttributes {
-  Access access{Access::Sequential};  // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
-  std::optional<std::int64_t> recordLength;  // RECL= when fixed-length
-  bool isUnformatted{false};  // FORM='UNFORMATTED'
-  bool isUTF8{false};  // ENCODING='UTF-8'
+  Access access{Access::Sequential}; // ACCESS='SEQUENTIAL', 'DIRECT', 'STREAM'
+  std::optional<std::int64_t> recordLength; // RECL= when fixed-length
+  bool isUnformatted{false}; // FORM='UNFORMATTED'
+  bool isUTF8{false}; // ENCODING='UTF-8'
 };
 
 struct ConnectionState : public ConnectionAttributes {
-  bool IsAtEOF() const;  // true when read has hit EOF or endfile record
+  bool IsAtEOF() const; // true when read has hit EOF or endfile record
   std::size_t RemainingSpaceInRecord() const;
   void HandleAbsolutePosition(std::int64_t);
   void HandleRelativePosition(std::int64_t);
 
   // Positions in a record file (sequential or direct, not stream)
-  std::int64_t currentRecordNumber{1};  // 1 is first
-  std::int64_t positionInRecord{0};  // offset in current record
-  std::int64_t furthestPositionInRecord{0};  // max(positionInRecord)
-  bool nonAdvancing{false};  // ADVANCE='NO'
+  std::int64_t currentRecordNumber{1}; // 1 is first
+  std::int64_t positionInRecord{0}; // offset in current record
+  std::int64_t furthestPositionInRecord{0}; // max(positionInRecord)
+  bool nonAdvancing{false}; // ADVANCE='NO'
 
   // Set at end of non-advancing I/O data transfer
-  std::optional<std::int64_t> leftTabLimit;  // offset in current record
+  std::optional<std::int64_t> leftTabLimit; // offset in current record
 
   // currentRecordNumber value captured after ENDFILE/REWIND/BACKSPACE statement
   // or an end-of-file READ condition on a sequential access file
   std::optional<std::int64_t> endfileRecordNumber;
 
   // Mutable modes set at OPEN() that can be overridden in READ/WRITE & FORMAT
-  MutableModes modes;  // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
+  MutableModes modes; // BLANK=, DECIMAL=, SIGN=, ROUND=, PAD=, DELIM=, kP
 };
-}
-#endif  // FORTRAN_RUNTIME_IO_CONNECTION_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_CONNECTION_H_
diff --git a/flang/runtime/derived-type.cpp b/flang/runtime/derived-type.cpp
index fb0e5a88277d..e04488b66fab 100644
--- a/flang/runtime/derived-type.cpp
+++ b/flang/runtime/derived-type.cpp
@@ -48,7 +48,7 @@ void DerivedType::Initialize(char *instance) const {
       f(instance);
     }
   }
-#if 0  // TODO
+#if 0 // TODO
   for (std::size_t j{0}; j < components_; ++j) {
     if (const Descriptor * descriptor{component_[j].GetDescriptor(instance)}) {
       // invoke initialization TBP
@@ -74,4 +74,4 @@ void DerivedType::Destroy(char *instance, bool finalize) const {
     }
   }
 }
-}
+} // namespace Fortran::runtime
diff --git a/flang/runtime/derived-type.h b/flang/runtime/derived-type.h
index 1d0e8502745e..1cb5ba96c00e 100644
--- a/flang/runtime/derived-type.h
+++ b/flang/runtime/derived-type.h
@@ -40,9 +40,9 @@ public:
 
 private:
   const char *name_;
-  TypeCode typeCode_;  // INTEGER, but not necessarily default kind
-  int which_{-1};  // index into DescriptorAddendum LEN type parameter values
-  TypeParameterValue value_;  // default in the case of LEN type parameter
+  TypeCode typeCode_; // INTEGER, but not necessarily default kind
+  int which_{-1}; // index into DescriptorAddendum LEN type parameter values
+  TypeParameterValue value_; // default in the case of LEN type parameter
 };
 
 // Components that have any need for a descriptor will either reference
@@ -64,10 +64,10 @@ public:
   bool IsPrivate() const { return (flags_ & PRIVATE) != 0; }
   bool IsDescriptor() const { return (flags_ & IS_DESCRIPTOR) != 0; }
 
-  template<typename A> A *Locate(char *dtInstance) const {
+  template <typename A> A *Locate(char *dtInstance) const {
     return reinterpret_cast<A *>(dtInstance + offset_);
   }
-  template<typename A> const A *Locate(const char *dtInstance) const {
+  template <typename A> const A *Locate(const char *dtInstance) const {
     return reinterpret_cast<const A *>(dtInstance + offset_);
   }
 
@@ -95,7 +95,7 @@ private:
   std::uint32_t flags_{0};
   TypeCode typeCode_{CFI_type_other};
   const Descriptor *staticDescriptor_{nullptr};
-  std::size_t offset_{0};  // byte offset in derived type instance
+  std::size_t offset_{0}; // byte offset in derived type instance
 };
 
 struct ExecutableCode {
@@ -121,9 +121,9 @@ public:
   DerivedType(const char *n, std::size_t kps, std::size_t lps,
       const TypeParameter *tp, std::size_t cs, const Component *ca,
       std::size_t tbps, const TypeBoundProcedure *tbp, std::size_t sz)
-    : name_{n}, kindParameters_{kps}, lenParameters_{lps}, typeParameter_{tp},
-      components_{cs}, component_{ca}, typeBoundProcedures_{tbps},
-      typeBoundProcedure_{tbp}, bytes_{sz} {
+      : name_{n}, kindParameters_{kps}, lenParameters_{lps}, typeParameter_{tp},
+        components_{cs}, component_{ca}, typeBoundProcedures_{tbps},
+        typeBoundProcedure_{tbp}, bytes_{sz} {
     if (IsNontrivialAnalysis()) {
       flags_ |= NONTRIVIAL;
     }
@@ -175,16 +175,16 @@ private:
   // LEN type parameters.  Conservative.
   bool IsNontrivialAnalysis() const;
 
-  const char *name_{""};  // NUL-terminated constant text
+  const char *name_{""}; // NUL-terminated constant text
   std::size_t kindParameters_{0};
   std::size_t lenParameters_{0};
-  const TypeParameter *typeParameter_{nullptr};  // array
-  std::size_t components_{0};  // *not* including type parameters
-  const Component *component_{nullptr};  // array
+  const TypeParameter *typeParameter_{nullptr}; // array
+  std::size_t components_{0}; // *not* including type parameters
+  const Component *component_{nullptr}; // array
   std::size_t typeBoundProcedures_{0};
-  const TypeBoundProcedure *typeBoundProcedure_{nullptr};  // array
+  const TypeBoundProcedure *typeBoundProcedure_{nullptr}; // array
   std::uint64_t flags_{0};
   std::size_t bytes_{0};
 };
-}
-#endif  // FORTRAN_RUNTIME_DERIVED_TYPE_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_DERIVED_TYPE_H_
diff --git a/flang/runtime/descriptor.cpp b/flang/runtime/descriptor.cpp
index 00a57cd1e216..9b3555a4723f 100644
--- a/flang/runtime/descriptor.cpp
+++ b/flang/runtime/descriptor.cpp
@@ -200,7 +200,7 @@ bool Descriptor::SubscriptsForZeroBasedElementNumber(SubscriptValue *subscript,
     coefficient *= dim.Extent();
   }
   if (elementNumber >= coefficient) {
-    return false;  // out of range
+    return false; // out of range
   }
   for (int j{raw_.rank - 1}; j >= 0; --j) {
     int k{permutation ? permutation[j] : j};
@@ -249,4 +249,4 @@ void DescriptorAddendum::Dump(FILE *f) const {
   std::fprintf(f, "  flags 0x%jx\n", static_cast<std::intmax_t>(flags_));
   // TODO: LEN parameter values
 }
-}
+} // namespace Fortran::runtime
diff --git a/flang/runtime/descriptor.h b/flang/runtime/descriptor.h
index 8f7a88e10731..d45cbe893951 100644
--- a/flang/runtime/descriptor.h
+++ b/flang/runtime/descriptor.h
@@ -58,14 +58,14 @@ class DescriptorAddendum {
 public:
   enum Flags {
     StaticDescriptor = 0x001,
-    ImplicitAllocatable = 0x002,  // compiler-created allocatable
-    DoNotFinalize = 0x004,  // compiler temporary
-    Target = 0x008,  // TARGET attribute
+    ImplicitAllocatable = 0x002, // compiler-created allocatable
+    DoNotFinalize = 0x004, // compiler temporary
+    Target = 0x008, // TARGET attribute
   };
 
   explicit DescriptorAddendum(
       const DerivedType *dt = nullptr, std::uint64_t flags = 0)
-    : derivedType_{dt}, flags_{flags} {}
+      : derivedType_{dt}, flags_{flags} {}
 
   const DerivedType *derivedType() const { return derivedType_; }
   DescriptorAddendum &set_derivedType(const DerivedType *dt) {
@@ -98,7 +98,7 @@ public:
 private:
   const DerivedType *derivedType_{nullptr};
   std::uint64_t flags_{0};
-  TypeParameterValue len_[1];  // must be the last component
+  TypeParameterValue len_[1]; // must be the last component
   // The LEN type parameter values can also include captured values of
   // specification expressions that were used for bounds and for LEN type
   // parameters of components.  The values have been truncated to the LEN
@@ -190,16 +190,16 @@ public:
     return offset;
   }
 
-  template<typename A> A *OffsetElement(std::size_t offset) const {
+  template <typename A> A *OffsetElement(std::size_t offset) const {
     return reinterpret_cast<A *>(
         reinterpret_cast<char *>(raw_.base_addr) + offset);
   }
 
-  template<typename A> A *Element(const SubscriptValue *subscript) const {
+  template <typename A> A *Element(const SubscriptValue *subscript) const {
     return OffsetElement<A>(SubscriptsToByteOffset(subscript));
   }
 
-  template<typename A> A *ZeroBasedIndexedElement(std::size_t n) const {
+  template <typename A> A *ZeroBasedIndexedElement(std::size_t n) const {
     SubscriptValue at[maxRank];
     if (SubscriptsForZeroBasedElementNumber(at, n)) {
       return Element<A>(at);
@@ -257,7 +257,7 @@ public:
   std::size_t Elements() const;
 
   int Allocate(const SubscriptValue lb[], const SubscriptValue ub[],
-      std::size_t charLen = 0);  // TODO: SOURCE= and MOLD=
+      std::size_t charLen = 0); // TODO: SOURCE= and MOLD=
   int Deallocate(bool finalize = true);
   void Destroy(char *data, bool finalize = true) const;
 
@@ -293,7 +293,7 @@ static_assert(sizeof(Descriptor) == sizeof(ISO::CFI_cdesc_t));
 //   StaticDescriptor<R,A,LP> statDesc;
 //   Descriptor &descriptor{statDesc.descriptor()};
 //   descriptor.Establish( ... );
-template<int MAX_RANK = maxRank, bool ADDENDUM = false, int MAX_LEN_PARMS = 0>
+template <int MAX_RANK = maxRank, bool ADDENDUM = false, int MAX_LEN_PARMS = 0>
 class alignas(Descriptor) StaticDescriptor {
 public:
   static constexpr int maxRank{MAX_RANK};
@@ -331,5 +331,5 @@ public:
 private:
   char storage_[byteSize];
 };
-}
-#endif  // FORTRAN_RUNTIME_DESCRIPTOR_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_DESCRIPTOR_H_
diff --git a/flang/runtime/edit-input.cpp b/flang/runtime/edit-input.cpp
index dd7a804da2f8..77bf100d2e21 100644
--- a/flang/runtime/edit-input.cpp
+++ b/flang/runtime/edit-input.cpp
@@ -78,10 +78,14 @@ bool EditIntegerInput(
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
   case 'G':
-  case 'I': break;
-  case 'B': return EditBOZInput(io, edit, n, 2, kind << 3);
-  case 'O': return EditBOZInput(io, edit, n, 8, kind << 3);
-  case 'Z': return EditBOZInput(io, edit, n, 16, kind << 3);
+  case 'I':
+    break;
+  case 'B':
+    return EditBOZInput(io, edit, n, 2, kind << 3);
+  case 'O':
+    return EditBOZInput(io, edit, n, 8, kind << 3);
+  case 'Z':
+    return EditBOZInput(io, edit, n, 16, kind << 3);
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with an INTEGER data item",
@@ -96,7 +100,7 @@ bool EditIntegerInput(
     char32_t ch{*next};
     if (ch == ' ') {
       if (edit.modes.editingFlags & blankZero) {
-        ch = '0';  // BZ mode - treat blank as if it were zero
+        ch = '0'; // BZ mode - treat blank as if it were zero
       } else {
         continue;
       }
@@ -130,14 +134,14 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
       buffer[got++] = '-';
     }
   }
-  if (!next) {  // empty field means zero
+  if (!next) { // empty field means zero
     if (got < bufferSize) {
       buffer[got++] = '0';
     }
     return got;
   }
   if (got < bufferSize) {
-    buffer[got++] = '.';  // input field is normalized to a fraction
+    buffer[got++] = '.'; // input field is normalized to a fraction
   }
   char32_t decimal = edit.modes.editingFlags & decimalComma ? ',' : '.';
   auto start{got};
@@ -154,7 +158,7 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
         }
       }
     }
-    if (next && *next == '(') {  // NaN(...)
+    if (next && *next == '(') { // NaN(...)
       while (next && *next != ')') {
         next = io.NextInField(remaining);
       }
@@ -165,7 +169,7 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
       char32_t ch{*next};
       if (ch == ' ') {
         if (edit.modes.editingFlags & blankZero) {
-          ch = '0';  // BZ mode - treat blank as if it were zero
+          ch = '0'; // BZ mode - treat blank as if it were zero
         } else {
           continue;
         }
@@ -178,13 +182,13 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
         }
       } else if (ch == decimal && !decimalPoint) {
         // the decimal point is *not* copied to the buffer
-        decimalPoint = got - start;  // # of digits before the decimal point
+        decimalPoint = got - start; // # of digits before the decimal point
       } else {
         break;
       }
     }
     if (got == start && got < bufferSize) {
-      buffer[got++] = '0';  // all digits were zeroes
+      buffer[got++] = '0'; // all digits were zeroes
     }
     if (next &&
         (*next == 'e' || *next == 'E' || *next == 'd' || *next == 'D' ||
@@ -192,7 +196,7 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
       io.SkipSpaces(remaining);
       next = io.NextInField(remaining);
     }
-    exponent = -edit.modes.scale;  // default exponent is -kP
+    exponent = -edit.modes.scale; // default exponent is -kP
     if (next &&
         (*next == '-' || *next == '+' || (*next >= '0' && *next <= '9'))) {
       bool negExpo{*next == '-'};
@@ -226,13 +230,13 @@ static int ScanRealInput(char *buffer, int bufferSize, IoStatementState &io,
       next = io.NextInField(remaining);
     }
     if (next) {
-      return 0;  // error: unused nonblank character in fixed-width field
+      return 0; // error: unused nonblank character in fixed-width field
     }
   }
   return got;
 }
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool EditCommonRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   static constexpr int maxDigits{
       common::MaxDecimalConversionDigits(binaryPrecision)};
@@ -266,14 +270,15 @@ bool EditCommonRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   return true;
 }
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool EditRealInput(IoStatementState &io, const DataEdit &edit, void *n) {
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
   case 'F':
-  case 'E':  // incl. EN, ES, & EX
+  case 'E': // incl. EN, ES, & EX
   case 'D':
-  case 'G': return EditCommonRealInput<binaryPrecision>(io, edit, n);
+  case 'G':
+    return EditCommonRealInput<binaryPrecision>(io, edit, n);
   case 'B':
     return EditBOZInput(
         io, edit, n, 2, common::BitsForBinaryPrecision(binaryPrecision));
@@ -296,7 +301,8 @@ bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
   switch (edit.descriptor) {
   case DataEdit::ListDirected:
   case 'L':
-  case 'G': break;
+  case 'G':
+    break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used for LOGICAL input",
@@ -309,7 +315,7 @@ bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
   }
   io.SkipSpaces(remaining);
   std::optional<char32_t> next{io.NextInField(remaining)};
-  if (next && *next == '.') {  // skip optional period
+  if (next && *next == '.') { // skip optional period
     next = io.NextInField(remaining);
   }
   if (!next) {
@@ -318,15 +324,19 @@ bool EditLogicalInput(IoStatementState &io, const DataEdit &edit, bool &x) {
   }
   switch (*next) {
   case 'T':
-  case 't': x = true; break;
+  case 't':
+    x = true;
+    break;
   case 'F':
-  case 'f': x = false; break;
+  case 'f':
+    x = false;
+    break;
   default:
     io.GetIoErrorHandler().SignalError(
         "Bad character '%lc' in LOGICAL input field", *next);
     return false;
   }
-  if (remaining) {  // ignore the rest of the field
+  if (remaining) { // ignore the rest of the field
     io.HandleRelativePosition(*remaining);
   }
   return true;
@@ -353,7 +363,7 @@ static bool EditDelimitedCharacterInput(
         *x++ = *ch;
         --length;
       }
-    } else if (!io.AdvanceRecord()) {  // EOF
+    } else if (!io.AdvanceRecord()) { // EOF
       std::fill_n(x, length, ' ');
       return false;
     }
@@ -377,9 +387,11 @@ static bool EditListDirectedDefaultCharacterInput(
     case ',':
     case ';':
     case '/':
-      remaining = 0;  // value separator: stop
+      remaining = 0; // value separator: stop
       break;
-    default: *x++ = *next; --length;
+    default:
+      *x++ = *next;
+      --length;
     }
   }
   std::fill_n(x, length, ' ');
@@ -392,7 +404,8 @@ bool EditDefaultCharacterInput(
   case DataEdit::ListDirected:
     return EditListDirectedDefaultCharacterInput(io, x, length);
   case 'A':
-  case 'G': break;
+  case 'G':
+    break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a CHARACTER data item",
@@ -426,4 +439,4 @@ template bool EditRealInput<24>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<53>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<64>(IoStatementState &, const DataEdit &, void *);
 template bool EditRealInput<113>(IoStatementState &, const DataEdit &, void *);
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/edit-input.h b/flang/runtime/edit-input.h
index b62d81804dd6..c628b9c7e673 100644
--- a/flang/runtime/edit-input.h
+++ b/flang/runtime/edit-input.h
@@ -17,7 +17,7 @@ namespace Fortran::runtime::io {
 
 bool EditIntegerInput(IoStatementState &, const DataEdit &, void *, int kind);
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool EditRealInput(IoStatementState &, const DataEdit &, void *);
 
 bool EditLogicalInput(IoStatementState &, const DataEdit &, bool &);
@@ -36,5 +36,5 @@ extern template bool EditRealInput<64>(
     IoStatementState &, const DataEdit &, void *);
 extern template bool EditRealInput<113>(
     IoStatementState &, const DataEdit &, void *);
-}
-#endif  // FORTRAN_RUNTIME_EDIT_INPUT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_EDIT_INPUT_H_
diff --git a/flang/runtime/edit-output.cpp b/flang/runtime/edit-output.cpp
index 8206b418f3cd..d505e170c437 100644
--- a/flang/runtime/edit-output.cpp
+++ b/flang/runtime/edit-output.cpp
@@ -13,7 +13,7 @@
 
 namespace Fortran::runtime::io {
 
-template<typename INT, typename UINT>
+template <typename INT, typename UINT>
 bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit, INT n) {
   char buffer[130], *end = &buffer[sizeof buffer], *p = end;
   bool isNegative{false};
@@ -29,7 +29,7 @@ bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit, INT n) {
   case 'G':
   case 'I':
     if (isNegative || (edit.modes.editingFlags & signPlus)) {
-      signChars = 1;  // '-' or '+'
+      signChars = 1; // '-' or '+'
     }
     while (un > 0) {
       auto quotient{common::DivideUnsignedBy<UINT, 10>(un)};
@@ -63,11 +63,11 @@ bool EditIntegerOutput(IoStatementState &io, const DataEdit &edit, INT n) {
   int digits = end - p;
   int leadingZeroes{0};
   int editWidth{edit.width.value_or(0)};
-  if (edit.digits && digits <= *edit.digits) {  // Iw.m
+  if (edit.digits && digits <= *edit.digits) { // Iw.m
     if (*edit.digits == 0 && n == 0) {
       // Iw.0 with zero value: output field must be blank.  For I0.0
       // and a zero value, emit one blank character.
-      signChars = 0;  // in case of SP
+      signChars = 0; // in case of SP
       editWidth = std::max(1, editWidth);
     } else {
       leadingZeroes = *edit.digits - digits;
@@ -104,21 +104,21 @@ const char *RealOutputEditingBase::FormatExponent(
     e = quotient;
   }
   if (edit.expoDigits) {
-    if (int ed{*edit.expoDigits}) {  // Ew.dEe with e > 0
+    if (int ed{*edit.expoDigits}) { // Ew.dEe with e > 0
       while (exponent > exponent_ + 2 /*E+*/ && exponent + ed > eEnd) {
         *--exponent = '0';
       }
     } else if (exponent == eEnd) {
-      *--exponent = '0';  // Ew.dE0 with zero-valued exponent
+      *--exponent = '0'; // Ew.dE0 with zero-valued exponent
     }
-  } else {  // ensure at least two exponent digits
+  } else { // ensure at least two exponent digits
     while (exponent + 2 > eEnd) {
       *--exponent = '0';
     }
   }
   *--exponent = expo < 0 ? '-' : '+';
   if (edit.expoDigits || exponent + 3 == eEnd) {
-    *--exponent = edit.descriptor == 'D' ? 'D' : 'E';  // not 'G'
+    *--exponent = edit.descriptor == 'D' ? 'D' : 'E'; // not 'G'
   }
   length = eEnd - exponent;
   return exponent;
@@ -157,7 +157,7 @@ bool RealOutputEditingBase::EmitSuffix(const DataEdit &edit) {
   }
 }
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
     int significantDigits, const DataEdit &edit, int flags) {
   if (edit.modes.editingFlags & signPlus) {
@@ -166,7 +166,7 @@ decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
   auto converted{decimal::ConvertToDecimal<binaryPrecision>(buffer_,
       sizeof buffer_, static_cast<enum decimal::DecimalConversionFlags>(flags),
       significantDigits, edit.modes.round, x_)};
-  if (!converted.str) {  // overflow
+  if (!converted.str) { // overflow
     io_.GetIoErrorHandler().Crash(
         "RealOutputEditing::Convert : buffer size %zd was insufficient",
         sizeof buffer_);
@@ -175,24 +175,24 @@ decimal::ConversionToDecimalResult RealOutputEditing<binaryPrecision>::Convert(
 }
 
 // 13.7.2.3.3 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
-  int editDigits{edit.digits.value_or(0)};  // 'd' field
-  int editWidth{edit.width.value_or(0)};  // 'w' field
+  int editDigits{edit.digits.value_or(0)}; // 'd' field
+  int editWidth{edit.width.value_or(0)}; // 'w' field
   int significantDigits{editDigits};
   int flags{0};
-  if (editWidth == 0) {  // "the processor selects the field width"
-    if (edit.digits.has_value()) {  // E0.d
-      editWidth = editDigits + 6;  // -.666E+ee
-    } else {  // E0
+  if (editWidth == 0) { // "the processor selects the field width"
+    if (edit.digits.has_value()) { // E0.d
+      editWidth = editDigits + 6; // -.666E+ee
+    } else { // E0
       flags |= decimal::Minimize;
       significantDigits =
-          sizeof buffer_ - 5;  // sign, NUL, + 3 extra for EN scaling
+          sizeof buffer_ - 5; // sign, NUL, + 3 extra for EN scaling
     }
   }
   bool isEN{edit.variation == 'N'};
   bool isES{edit.variation == 'S'};
-  int scale{isEN || isES ? 1 : edit.modes.scale};  // 'kP' value
+  int scale{isEN || isES ? 1 : edit.modes.scale}; // 'kP' value
   int zeroesAfterPoint{0};
   if (scale < 0) {
     zeroesAfterPoint = -scale;
@@ -205,7 +205,7 @@ bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(significantDigits, edit, flags)};
-    if (converted.length > 0 && !IsDecimalNumber(converted.str)) {  // Inf, NaN
+    if (converted.length > 0 && !IsDecimalNumber(converted.str)) { // Inf, NaN
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
@@ -257,16 +257,16 @@ bool RealOutputEditing<binaryPrecision>::EditEorDOutput(const DataEdit &edit) {
 }
 
 // 13.7.2.3.2 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
-  int fracDigits{edit.digits.value_or(0)};  // 'd' field
+  int fracDigits{edit.digits.value_or(0)}; // 'd' field
   int extraDigits{0};
-  int editWidth{edit.width.value_or(0)};  // 'w' field
+  int editWidth{edit.width.value_or(0)}; // 'w' field
   int flags{0};
-  if (editWidth == 0) {  // "the processor selects the field width"
-    if (!edit.digits.has_value()) {  // F0
+  if (editWidth == 0) { // "the processor selects the field width"
+    if (!edit.digits.has_value()) { // F0
       flags |= decimal::Minimize;
-      fracDigits = sizeof buffer_ - 2;  // sign & NUL
+      fracDigits = sizeof buffer_ - 2; // sign & NUL
     }
   }
   // Multiple conversions may be needed to get the right number of
@@ -274,7 +274,7 @@ bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
   while (true) {
     decimal::ConversionToDecimalResult converted{
         Convert(extraDigits + fracDigits, edit, flags)};
-    if (converted.length > 0 && !IsDecimalNumber(converted.str)) {  // Inf, NaN
+    if (converted.length > 0 && !IsDecimalNumber(converted.str)) { // Inf, NaN
       return EmitPrefix(edit, converted.length, editWidth) &&
           io_.Emit(converted.str, converted.length) && EmitSuffix(edit);
     }
@@ -283,9 +283,9 @@ bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
     if (expo > extraDigits) {
       extraDigits = expo;
       if (flags & decimal::Minimize) {
-        fracDigits = sizeof buffer_ - extraDigits - 2;  // sign & NUL
+        fracDigits = sizeof buffer_ - extraDigits - 2; // sign & NUL
       }
-      continue;  // try again
+      continue; // try again
     }
     int signLength{*converted.str == '-' || *converted.str == '+' ? 1 : 0};
     int convertedDigits{static_cast<int>(converted.length) - signLength};
@@ -299,7 +299,7 @@ bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
     if (digitsBeforePoint + zeroesBeforePoint + zeroesAfterPoint +
             digitsAfterPoint + trailingZeroes ==
         0) {
-      ++zeroesBeforePoint;  // "." -> "0."
+      ++zeroesBeforePoint; // "." -> "0."
     }
     int totalLength{signLength + digitsBeforePoint + zeroesBeforePoint +
         1 /*'.'*/ + zeroesAfterPoint + digitsAfterPoint + trailingZeroes};
@@ -324,30 +324,30 @@ bool RealOutputEditing<binaryPrecision>::EditFOutput(const DataEdit &edit) {
 }
 
 // 13.7.5.2.3 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
   edit.descriptor = 'E';
   if (!edit.width.has_value() ||
       (*edit.width > 0 && edit.digits.value_or(-1) == 0)) {
-    return edit;  // Gw.0 -> Ew.0 for w > 0
+    return edit; // Gw.0 -> Ew.0 for w > 0
   }
   decimal::ConversionToDecimalResult converted{Convert(1, edit)};
-  if (!IsDecimalNumber(converted.str)) {  // Inf, NaN
+  if (!IsDecimalNumber(converted.str)) { // Inf, NaN
     return edit;
   }
-  int expo{IsZero() ? 1 : converted.decimalExponent};  // 's'
+  int expo{IsZero() ? 1 : converted.decimalExponent}; // 's'
   int significantDigits{
-      edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)};  // 'd'
+      edit.digits.value_or(BinaryFloatingPoint::decimalPrecision)}; // 'd'
   if (expo < 0 || expo > significantDigits) {
-    return edit;  // Ew.d
+    return edit; // Ew.d
   }
   edit.descriptor = 'F';
-  edit.modes.scale = 0;  // kP is ignored for G when no exponent field
+  edit.modes.scale = 0; // kP is ignored for G when no exponent field
   trailingBlanks_ = 0;
   int editWidth{edit.width.value_or(0)};
   if (editWidth > 0) {
     int expoDigits{edit.expoDigits.value_or(0)};
-    trailingBlanks_ = expoDigits > 0 ? expoDigits + 2 : 4;  // 'n'
+    trailingBlanks_ = expoDigits > 0 ? expoDigits + 2 : 4; // 'n'
     *edit.width = std::max(0, editWidth - trailingBlanks_);
   }
   if (edit.digits.has_value()) {
@@ -357,46 +357,49 @@ DataEdit RealOutputEditing<binaryPrecision>::EditForGOutput(DataEdit edit) {
 }
 
 // 13.10.4 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditListDirectedOutput(
     const DataEdit &edit) {
   decimal::ConversionToDecimalResult converted{Convert(1, edit)};
-  if (!IsDecimalNumber(converted.str)) {  // Inf, NaN
+  if (!IsDecimalNumber(converted.str)) { // Inf, NaN
     return EditEorDOutput(edit);
   }
   int expo{converted.decimalExponent};
   if (expo < 0 || expo > BinaryFloatingPoint::decimalPrecision) {
     DataEdit copy{edit};
-    copy.modes.scale = 1;  // 1P
+    copy.modes.scale = 1; // 1P
     return EditEorDOutput(copy);
   }
   return EditFOutput(edit);
 }
 
 // 13.7.5.2.6 in F'2018
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::EditEXOutput(const DataEdit &) {
   io_.GetIoErrorHandler().Crash(
-      "EX output editing is not yet implemented");  // TODO
+      "EX output editing is not yet implemented"); // TODO
 }
 
-template<int binaryPrecision>
+template <int binaryPrecision>
 bool RealOutputEditing<binaryPrecision>::Edit(const DataEdit &edit) {
   switch (edit.descriptor) {
-  case 'D': return EditEorDOutput(edit);
+  case 'D':
+    return EditEorDOutput(edit);
   case 'E':
     if (edit.variation == 'X') {
       return EditEXOutput(edit);
     } else {
       return EditEorDOutput(edit);
     }
-  case 'F': return EditFOutput(edit);
+  case 'F':
+    return EditFOutput(edit);
   case 'B':
   case 'O':
   case 'Z':
     return EditIntegerOutput(
         io_, edit, decimal::BinaryFloatingPointNumber<binaryPrecision>{x_}.raw);
-  case 'G': return Edit(EditForGOutput(edit));
+  case 'G':
+    return Edit(EditForGOutput(edit));
   default:
     if (edit.IsListDirected()) {
       return EditListDirectedOutput(edit);
@@ -417,7 +420,8 @@ bool ListDirectedLogicalOutput(IoStatementState &io,
 bool EditLogicalOutput(IoStatementState &io, const DataEdit &edit, bool truth) {
   switch (edit.descriptor) {
   case 'L':
-  case 'G': return io.Emit(truth ? "T" : "F", 1);
+  case 'G':
+    return io.Emit(truth ? "T" : "F", 1);
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a LOGICAL data item",
@@ -469,7 +473,8 @@ bool EditDefaultCharacterOutput(IoStatementState &io, const DataEdit &edit,
     const char *x, std::size_t length) {
   switch (edit.descriptor) {
   case 'A':
-  case 'G': break;
+  case 'G':
+    break;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInFormat,
         "Data edit descriptor '%c' may not be used with a CHARACTER data item",
@@ -493,4 +498,4 @@ template class RealOutputEditing<24>;
 template class RealOutputEditing<53>;
 template class RealOutputEditing<64>;
 template class RealOutputEditing<113>;
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/edit-output.h b/flang/runtime/edit-output.h
index 559491b584c1..aa324c3ca0d2 100644
--- a/flang/runtime/edit-output.h
+++ b/flang/runtime/edit-output.h
@@ -29,7 +29,7 @@ namespace Fortran::runtime::io {
 // The DataEdit reference is const here (and elsewhere in this header) so that
 // one edit descriptor with a repeat factor may safely serve to edit
 // multiple elements of an array.
-template<typename INT = std::int64_t, typename UINT = std::uint64_t>
+template <typename INT = std::int64_t, typename UINT = std::uint64_t>
 bool EditIntegerOutput(IoStatementState &, const DataEdit &, INT);
 
 // Encapsulates the state of a REAL output conversion.
@@ -52,16 +52,16 @@ protected:
   bool EmitSuffix(const DataEdit &);
 
   IoStatementState &io_;
-  int trailingBlanks_{0};  // created when Gw editing maps to Fw
+  int trailingBlanks_{0}; // created when Gw editing maps to Fw
   char exponent_[16];
 };
 
-template<int binaryPrecision = 53>
+template <int binaryPrecision = 53>
 class RealOutputEditing : public RealOutputEditingBase {
 public:
-  template<typename A>
+  template <typename A>
   RealOutputEditing(IoStatementState &io, A x)
-    : RealOutputEditingBase{io}, x_{x} {}
+      : RealOutputEditingBase{io}, x_{x} {}
   bool Edit(const DataEdit &);
 
 private:
@@ -73,7 +73,7 @@ private:
   // it has a repeat count.
   bool EditEorDOutput(const DataEdit &);
   bool EditFOutput(const DataEdit &);
-  DataEdit EditForGOutput(DataEdit);  // returns an E or F edit
+  DataEdit EditForGOutput(DataEdit); // returns an E or F edit
   bool EditEXOutput(const DataEdit &);
   bool EditListDirectedOutput(const DataEdit &);
 
@@ -107,5 +107,5 @@ extern template class RealOutputEditing<53>;
 extern template class RealOutputEditing<64>;
 extern template class RealOutputEditing<113>;
 
-}
-#endif  // FORTRAN_RUNTIME_EDIT_OUTPUT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_EDIT_OUTPUT_H_
diff --git a/flang/runtime/environment.cpp b/flang/runtime/environment.cpp
index 735312b9f57c..e05baa3323cd 100644
--- a/flang/runtime/environment.cpp
+++ b/flang/runtime/environment.cpp
@@ -19,9 +19,9 @@ void ExecutionEnvironment::Configure(
   argc = ac;
   argv = av;
   envp = env;
-  listDirectedOutputLineLengthLimit = 79;  // PGI default
+  listDirectedOutputLineLengthLimit = 79; // PGI default
   defaultOutputRoundingMode =
-      decimal::FortranRounding::RoundNearest;  // RP(==RN)
+      decimal::FortranRounding::RoundNearest; // RP(==RN)
 
   if (auto *x{std::getenv("FORT_FMT_RECL")}) {
     char *end;
@@ -36,4 +36,4 @@ void ExecutionEnvironment::Configure(
 
   // TODO: Set RP/ROUND='PROCESSOR_DEFINED' from environment
 }
-}
+} // namespace Fortran::runtime
diff --git a/flang/runtime/environment.h b/flang/runtime/environment.h
index 93730c180673..0d9d318915cd 100644
--- a/flang/runtime/environment.h
+++ b/flang/runtime/environment.h
@@ -22,6 +22,6 @@ struct ExecutionEnvironment {
   enum decimal::FortranRounding defaultOutputRoundingMode;
 };
 extern ExecutionEnvironment executionEnvironment;
-}
+} // namespace Fortran::runtime
 
-#endif  // FORTRAN_RUNTIME_ENVIRONMENT_H_
+#endif // FORTRAN_RUNTIME_ENVIRONMENT_H_
diff --git a/flang/runtime/file.cpp b/flang/runtime/file.cpp
index 233217c70096..677b9675f47a 100644
--- a/flang/runtime/file.cpp
+++ b/flang/runtime/file.cpp
@@ -65,7 +65,9 @@ void OpenFile::Open(
       return;
     }
     break;
-  case OpenStatus::New: flags |= O_CREAT | O_EXCL; break;
+  case OpenStatus::New:
+    flags |= O_CREAT | O_EXCL;
+    break;
   case OpenStatus::Scratch:
     if (path_.get()) {
       handler.SignalError("FILE= must not appear with STATUS='SCRATCH'");
@@ -73,7 +75,9 @@ void OpenFile::Open(
     }
     fd_ = openfile_mkstemp(handler);
     return;
-  case OpenStatus::Replace: flags |= O_CREAT | O_TRUNC; break;
+  case OpenStatus::Replace:
+    flags |= O_CREAT | O_TRUNC;
+    break;
   case OpenStatus::Unknown:
     if (fd_ >= 0) {
       return;
@@ -122,7 +126,8 @@ void OpenFile::Close(CloseStatus status, IoErrorHandler &handler) {
   pending_.reset();
   knownSize_.reset();
   switch (status) {
-  case CloseStatus::Keep: break;
+  case CloseStatus::Keep:
+    break;
   case CloseStatus::Delete:
     if (path_.get()) {
       ::unlink(path_.get());
@@ -350,4 +355,4 @@ int OpenFile::PendingResult(const Terminator &terminator, int iostat) {
   pending_.reset(&New<Pending>{}(terminator, id, iostat, std::move(pending_)));
   return id;
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/file.h b/flang/runtime/file.h
index c74da330bb7d..741a0bcffa3e 100644
--- a/flang/runtime/file.h
+++ b/flang/runtime/file.h
@@ -94,5 +94,5 @@ private:
   int nextId_;
   OwningPtr<Pending> pending_;
 };
-}
-#endif  // FORTRAN_RUNTIME_FILE_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_FILE_H_
diff --git a/flang/runtime/format-implementation.h b/flang/runtime/format-implementation.h
index 86168d0e823d..21cb41c26266 100644
--- a/flang/runtime/format-implementation.h
+++ b/flang/runtime/format-implementation.h
@@ -21,19 +21,19 @@
 
 namespace Fortran::runtime::io {
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 FormatControl<CONTEXT>::FormatControl(const Terminator &terminator,
     const CharType *format, std::size_t formatLength, int maxHeight)
-  : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
-    formatLength_{static_cast<int>(formatLength)} {
+    : maxHeight_{static_cast<std::uint8_t>(maxHeight)}, format_{format},
+      formatLength_{static_cast<int>(formatLength)} {
   RUNTIME_CHECK(terminator, maxHeight == maxHeight_);
   RUNTIME_CHECK(
       terminator, formatLength == static_cast<std::size_t>(formatLength_));
   stack_[0].start = offset_;
-  stack_[0].remaining = Iteration::unlimited;  // 13.4(8)
+  stack_[0].remaining = Iteration::unlimited; // 13.4(8)
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
     IoErrorHandler &handler, const CharType *format, std::size_t formatLength) {
   int maxNesting{0};
@@ -51,9 +51,11 @@ int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
     } else if (*p != ' ') {
       switch (*p) {
       case '\'':
-      case '"': quote = *p; break;
+      case '"':
+        quote = *p;
+        break;
       case 'h':
-      case 'H':  // 9HHOLLERITH
+      case 'H': // 9HHOLLERITH
         p += repeat;
         if (p >= end) {
           handler.SignalError(IostatErrorInFormat,
@@ -61,12 +63,15 @@ int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
           return maxNesting;
         }
         break;
-      case ' ': break;
+      case ' ':
+        break;
       case '(':
         ++nesting;
         maxNesting = std::max(nesting, maxNesting);
         break;
-      case ')': nesting = std::max(nesting - 1, 0); break;
+      case ')':
+        nesting = std::max(nesting - 1, 0);
+        break;
       }
       repeat = 0;
     }
@@ -81,7 +86,7 @@ int FormatControl<CONTEXT>::GetMaxParenthesisNesting(
   return maxNesting;
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 int FormatControl<CONTEXT>::GetIntField(
     IoErrorHandler &handler, CharType firstCh) {
   CharType ch{firstCh ? firstCh : PeekNext()};
@@ -118,7 +123,7 @@ int FormatControl<CONTEXT>::GetIntField(
   return result;
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 static void HandleControl(CONTEXT &context, char ch, char next, int n) {
   MutableModes &modes{context.mutableModes()};
   switch (ch) {
@@ -144,21 +149,32 @@ static void HandleControl(CONTEXT &context, char ch, char next, int n) {
     break;
   case 'P':
     if (!next) {
-      modes.scale = n;  // kP - decimal scaling by 10**k
+      modes.scale = n; // kP - decimal scaling by 10**k
       return;
     }
     break;
   case 'R':
     switch (next) {
-    case 'N': modes.round = decimal::RoundNearest; return;
-    case 'Z': modes.round = decimal::RoundToZero; return;
-    case 'U': modes.round = decimal::RoundUp; return;
-    case 'D': modes.round = decimal::RoundDown; return;
-    case 'C': modes.round = decimal::RoundCompatible; return;
+    case 'N':
+      modes.round = decimal::RoundNearest;
+      return;
+    case 'Z':
+      modes.round = decimal::RoundToZero;
+      return;
+    case 'U':
+      modes.round = decimal::RoundUp;
+      return;
+    case 'D':
+      modes.round = decimal::RoundDown;
+      return;
+    case 'C':
+      modes.round = decimal::RoundCompatible;
+      return;
     case 'P':
       modes.round = executionEnvironment.defaultOutputRoundingMode;
       return;
-    default: break;
+    default:
+      break;
     }
     break;
   case 'X':
@@ -178,16 +194,17 @@ static void HandleControl(CONTEXT &context, char ch, char next, int n) {
     }
     break;
   case 'T': {
-    if (!next) {  // Tn
-      context.HandleAbsolutePosition(n - 1);  // convert 1-based to 0-based
+    if (!next) { // Tn
+      context.HandleAbsolutePosition(n - 1); // convert 1-based to 0-based
       return;
     }
-    if (next == 'L' || next == 'R') {  // TLn & TRn
+    if (next == 'L' || next == 'R') { // TLn & TRn
       context.HandleRelativePosition(next == 'L' ? -n : n);
       return;
     }
   } break;
-  default: break;
+  default:
+    break;
   }
   if (next) {
     context.SignalError(IostatErrorInFormat,
@@ -202,7 +219,7 @@ static void HandleControl(CONTEXT &context, char ch, char next, int n) {
 // Handles all repetition counts and control edit descriptors.
 // Generally assumes that the format string has survived the common
 // format validator gauntlet.
-template<typename CONTEXT>
+template <typename CONTEXT>
 int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
   int unlimitedLoopCheck{-1};
   while (true) {
@@ -235,13 +252,13 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
             "FORMAT stack overflow: too many nested parentheses");
         return 0;
       }
-      stack_[height_].start = offset_ - 1;  // the '('
+      stack_[height_].start = offset_ - 1; // the '('
       if (unlimited || height_ == 0) {
         stack_[height_].remaining = Iteration::unlimited;
         unlimitedLoopCheck = offset_ - 1;
       } else if (repeat) {
         if (*repeat <= 0) {
-          *repeat = 1;  // error recovery
+          *repeat = 1; // error recovery
         }
         stack_[height_].remaining = *repeat - 1;
       } else {
@@ -254,9 +271,9 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
     } else if (ch == ')') {
       if (height_ == 1) {
         if (stop) {
-          return 0;  // end of FORMAT and no data items remain
+          return 0; // end of FORMAT and no data items remain
         }
-        context.AdvanceRecord();  // implied / before rightmost )
+        context.AdvanceRecord(); // implied / before rightmost )
       }
       if (stack_[height_ - 1].remaining == Iteration::unlimited) {
         offset_ = stack_[height_ - 1].start + 1;
@@ -318,7 +335,7 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
         return repeat && *repeat > 0 ? *repeat : 1;
       } else {
         // Control edit descriptor
-        if (ch == 'T') {  // Tn, TLn, TRn
+        if (ch == 'T') { // Tn, TLn, TRn
           repeat = GetIntField(context);
         }
         HandleControl(context, static_cast<char>(ch), static_cast<char>(next),
@@ -334,7 +351,7 @@ int FormatControl<CONTEXT>::CueUpNextDataEdit(Context &context, bool stop) {
   }
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
     Context &context, int maxRepeat) {
 
@@ -352,7 +369,7 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
     }
   }
 
-  if (edit.descriptor == 'A') {  // width is optional for A[w]
+  if (edit.descriptor == 'A') { // width is optional for A[w]
     auto ch{PeekNext()};
     if (ch >= '0' && ch <= '9') {
       edit.width = GetIntField(context);
@@ -373,8 +390,8 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
 
   // Handle repeated nonparenthesized edit descriptors
   if (repeat > 1) {
-    stack_[height_].start = start;  // after repeat count
-    stack_[height_].remaining = repeat;  // full count
+    stack_[height_].start = start; // after repeat count
+    stack_[height_].remaining = repeat; // full count
     ++height_;
   }
   edit.repeat = 1;
@@ -384,7 +401,7 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
       if (stack_[height_ - 1].remaining > maxRepeat) {
         edit.repeat = maxRepeat;
         stack_[height_ - 1].remaining -= maxRepeat;
-        offset_ = start;  // repeat same edit descriptor next time
+        offset_ = start; // repeat same edit descriptor next time
       } else {
         edit.repeat = stack_[height_ - 1].remaining;
         --height_;
@@ -394,9 +411,9 @@ DataEdit FormatControl<CONTEXT>::GetNextDataEdit(
   return edit;
 }
 
-template<typename CONTEXT>
+template <typename CONTEXT>
 void FormatControl<CONTEXT>::Finish(Context &context) {
   CueUpNextDataEdit(context, true /* stop at colon or end of FORMAT */);
 }
-}
-#endif  // FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_FORMAT_IMPLEMENTATION_H_
diff --git a/flang/runtime/format.cpp b/flang/runtime/format.cpp
index 6702ab97fe69..2c259b1f7b83 100644
--- a/flang/runtime/format.cpp
+++ b/flang/runtime/format.cpp
@@ -60,4 +60,4 @@ template class FormatControl<
     ExternalFormattedIoStatementState<Direction::Output>>;
 template class FormatControl<
     ExternalFormattedIoStatementState<Direction::Input>>;
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/format.h b/flang/runtime/format.h
index 4875b44f08bb..07eff97a7048 100644
--- a/flang/runtime/format.h
+++ b/flang/runtime/format.h
@@ -21,39 +21,39 @@
 namespace Fortran::runtime::io {
 
 enum EditingFlags {
-  blankZero = 1,  // BLANK=ZERO or BZ edit
-  decimalComma = 2,  // DECIMAL=COMMA or DC edit
-  signPlus = 4,  // SIGN=PLUS or SP edit
+  blankZero = 1, // BLANK=ZERO or BZ edit
+  decimalComma = 2, // DECIMAL=COMMA or DC edit
+  signPlus = 4, // SIGN=PLUS or SP edit
 };
 
 struct MutableModes {
-  std::uint8_t editingFlags{0};  // BN, DP, SS
+  std::uint8_t editingFlags{0}; // BN, DP, SS
   enum decimal::FortranRounding round{
       executionEnvironment
-          .defaultOutputRoundingMode};  // RP/ROUND='PROCESSOR_DEFAULT'
-  bool pad{false};  // PAD= mode on READ
-  char delim{'\0'};  // DELIM=
-  short scale{0};  // kP
+          .defaultOutputRoundingMode}; // RP/ROUND='PROCESSOR_DEFAULT'
+  bool pad{false}; // PAD= mode on READ
+  char delim{'\0'}; // DELIM=
+  short scale{0}; // kP
 };
 
 // A single edit descriptor extracted from a FORMAT
 struct DataEdit {
-  char descriptor;  // capitalized: one of A, I, B, O, Z, F, E(N/S/X), D, G
+  char descriptor; // capitalized: one of A, I, B, O, Z, F, E(N/S/X), D, G
 
   // Special internal data edit descriptors for list-directed I/O
-  static constexpr char ListDirected{'g'};  // non-COMPLEX list-directed
-  static constexpr char ListDirectedRealPart{'r'};  // emit "(r," or "(r;"
-  static constexpr char ListDirectedImaginaryPart{'z'};  // emit "z)"
-  static constexpr char ListDirectedNullValue{'n'};  // see 13.10.3.2
+  static constexpr char ListDirected{'g'}; // non-COMPLEX list-directed
+  static constexpr char ListDirectedRealPart{'r'}; // emit "(r," or "(r;"
+  static constexpr char ListDirectedImaginaryPart{'z'}; // emit "z)"
+  static constexpr char ListDirectedNullValue{'n'}; // see 13.10.3.2
   constexpr bool IsListDirected() const {
     return descriptor == ListDirected || descriptor == ListDirectedRealPart ||
         descriptor == ListDirectedImaginaryPart;
   }
 
-  char variation{'\0'};  // N, S, or X for EN, ES, EX
-  std::optional<int> width;  // the 'w' field; optional for A
-  std::optional<int> digits;  // the 'm' or 'd' field
-  std::optional<int> expoDigits;  // 'Ee' field
+  char variation{'\0'}; // N, S, or X for EN, ES, EX
+  std::optional<int> width; // the 'w' field; optional for A
+  std::optional<int> digits; // the 'm' or 'd' field
+  std::optional<int> expoDigits; // 'Ee' field
   MutableModes modes;
   int repeat{1};
 };
@@ -76,7 +76,7 @@ struct DefaultFormatControlCallbacks : public IoErrorHandler {
 // Generates a sequence of DataEdits from a FORMAT statement or
 // default-CHARACTER string.  Driven by I/O item list processing.
 // Errors are fatal.  See clause 13.4 in Fortran 2018 for background.
-template<typename CONTEXT> class FormatControl {
+template <typename CONTEXT> class FormatControl {
 public:
   using Context = CONTEXT;
   using CharType = typename Context::CharType;
@@ -109,8 +109,8 @@ private:
 
   struct Iteration {
     static constexpr int unlimited{-1};
-    int start{0};  // offset in format_ of '(' or a repeated edit descriptor
-    int remaining{0};  // while >0, decrement and iterate
+    int start{0}; // offset in format_ of '(' or a repeated edit descriptor
+    int remaining{0}; // while >0, decrement and iterate
   };
 
   void SkipBlanks() {
@@ -151,10 +151,10 @@ private:
   std::uint8_t height_{0};
   const CharType *format_{nullptr};
   int formatLength_{0};
-  int offset_{0};  // next item is at format_[offset_]
+  int offset_{0}; // next item is at format_[offset_]
 
   // must be last, may be incomplete
   Iteration stack_[maxMaxHeight];
 };
-}
-#endif  // FORTRAN_RUNTIME_FORMAT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_FORMAT_H_
diff --git a/flang/runtime/internal-unit.cpp b/flang/runtime/internal-unit.cpp
index e5a71f735a12..c051100b9a18 100644
--- a/flang/runtime/internal-unit.cpp
+++ b/flang/runtime/internal-unit.cpp
@@ -14,7 +14,7 @@
 
 namespace Fortran::runtime::io {
 
-template<Direction DIR>
+template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     Scalar scalar, std::size_t length) {
   recordLength = length;
@@ -24,7 +24,7 @@ InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
       CFI_attribute_pointer);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
     const Descriptor &that, const Terminator &terminator) {
   RUNTIME_CHECK(terminator, that.type().IsCharacter());
@@ -37,8 +37,8 @@ InternalDescriptorUnit<DIR>::InternalDescriptorUnit(
   endfileRecordNumber = d.Elements() + 1;
 }
 
-template<Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
-  if constexpr (DIR == Direction::Output) {  // blank fill
+template <Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
+  if constexpr (DIR == Direction::Output) { // blank fill
     while (char *record{CurrentRecord()}) {
       if (furthestPositionInRecord <
           recordLength.value_or(furthestPositionInRecord)) {
@@ -51,12 +51,12 @@ template<Direction DIR> void InternalDescriptorUnit<DIR>::EndIoStatement() {
   }
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool InternalDescriptorUnit<DIR>::Emit(
     const char *data, std::size_t bytes, IoErrorHandler &handler) {
   if constexpr (DIR == Direction::Input) {
     handler.Crash("InternalDescriptorUnit<Direction::Input>::Emit() called");
-    return false && data[bytes] != 0;  // bogus compare silences GCC warning
+    return false && data[bytes] != 0; // bogus compare silences GCC warning
   } else {
     if (bytes <= 0) {
       return true;
@@ -85,7 +85,7 @@ bool InternalDescriptorUnit<DIR>::Emit(
   }
 }
 
-template<Direction DIR>
+template <Direction DIR>
 std::optional<char32_t> InternalDescriptorUnit<DIR>::GetCurrentChar(
     IoErrorHandler &handler) {
   if constexpr (DIR == Direction::Output) {
@@ -107,13 +107,13 @@ std::optional<char32_t> InternalDescriptorUnit<DIR>::GetCurrentChar(
   return record[positionInRecord];
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool InternalDescriptorUnit<DIR>::AdvanceRecord(IoErrorHandler &handler) {
   if (currentRecordNumber >= endfileRecordNumber.value_or(0)) {
     handler.SignalEnd();
     return false;
   }
-  if constexpr (DIR == Direction::Output) {  // blank fill
+  if constexpr (DIR == Direction::Output) { // blank fill
     if (furthestPositionInRecord <
         recordLength.value_or(furthestPositionInRecord)) {
       char *record{CurrentRecord()};
@@ -128,7 +128,7 @@ bool InternalDescriptorUnit<DIR>::AdvanceRecord(IoErrorHandler &handler) {
   return true;
 }
 
-template<Direction DIR>
+template <Direction DIR>
 void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
   RUNTIME_CHECK(handler, currentRecordNumber > 1);
   --currentRecordNumber;
@@ -138,4 +138,4 @@ void InternalDescriptorUnit<DIR>::BackspaceRecord(IoErrorHandler &handler) {
 
 template class InternalDescriptorUnit<Direction::Output>;
 template class InternalDescriptorUnit<Direction::Input>;
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/internal-unit.h b/flang/runtime/internal-unit.h
index 7f4f11e976f6..e5137ebfe1ad 100644
--- a/flang/runtime/internal-unit.h
+++ b/flang/runtime/internal-unit.h
@@ -22,7 +22,7 @@ class IoErrorHandler;
 
 // Points to (but does not own) a CHARACTER scalar or array for internal I/O.
 // Does not buffer.
-template<Direction DIR> class InternalDescriptorUnit : public ConnectionState {
+template <Direction DIR> class InternalDescriptorUnit : public ConnectionState {
 public:
   using Scalar =
       std::conditional_t<DIR == Direction::Input, const char *, char *>;
@@ -49,5 +49,5 @@ private:
 
 extern template class InternalDescriptorUnit<Direction::Output>;
 extern template class InternalDescriptorUnit<Direction::Input>;
-}
-#endif  // FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_INTERNAL_UNIT_H_
diff --git a/flang/runtime/io-api.cpp b/flang/runtime/io-api.cpp
index cf18b8f0519b..db228e5bbf21 100644
--- a/flang/runtime/io-api.cpp
+++ b/flang/runtime/io-api.cpp
@@ -23,7 +23,7 @@
 
 namespace Fortran::runtime::io {
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginInternalArrayListIO(const Descriptor &descriptor,
     void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
     const char *sourceFile, int sourceLine) {
@@ -47,7 +47,7 @@ Cookie IONAME(BeginInternalArrayListInput)(const Descriptor &descriptor,
       descriptor, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginInternalArrayFormattedIO(const Descriptor &descriptor,
     const char *format, std::size_t formatLength, void ** /*scratchArea*/,
     std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
@@ -71,7 +71,7 @@ Cookie IONAME(BeginInternalArrayFormattedInput)(const Descriptor &descriptor,
       formatLength, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginInternalFormattedIO(
     std::conditional_t<DIR == Direction::Input, const char, char> *internal,
     std::size_t internalLength, const char *format, std::size_t formatLength,
@@ -101,7 +101,7 @@ Cookie IONAME(BeginInternalFormattedInput)(const char *internal,
       format, formatLength, scratchArea, scratchBytes, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginExternalListIO(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
@@ -138,7 +138,7 @@ Cookie IONAME(BeginExternalListInput)(
       unitNumber, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginExternalFormattedIO(const char *format, std::size_t formatLength,
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
@@ -174,7 +174,7 @@ Cookie IONAME(BeginExternalFormattedInput)(const char *format,
       format, formatLength, unitNumber, sourceFile, sourceLine);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 Cookie BeginUnformattedIO(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
@@ -191,7 +191,7 @@ Cookie BeginUnformattedIO(
     if (file.access == Access::Sequential && !file.recordLength.has_value()) {
       // Create space for (sub)record header to be completed by
       // UnformattedIoStatementState<Direction::Output>::EndIoStatement()
-      io.Emit("\0\0\0\0", 4);  // placeholder for record length header
+      io.Emit("\0\0\0\0", 4); // placeholder for record length header
     }
   }
   return &io;
@@ -209,7 +209,7 @@ Cookie IONAME(BeginUnformattedInput)(
       unitNumber, sourceFile, sourceLine);
 }
 
-Cookie IONAME(BeginOpenUnit)(  // OPEN(without NEWUNIT=)
+Cookie IONAME(BeginOpenUnit)( // OPEN(without NEWUNIT=)
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   bool wasExtant{false};
   Terminator terminator{sourceFile, sourceLine};
@@ -219,7 +219,7 @@ Cookie IONAME(BeginOpenUnit)(  // OPEN(without NEWUNIT=)
       unit, wasExtant, sourceFile, sourceLine);
 }
 
-Cookie IONAME(BeginOpenNewUnit)(  // OPEN(NEWUNIT=j)
+Cookie IONAME(BeginOpenNewUnit)( // OPEN(NEWUNIT=j)
     const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   return IONAME(BeginOpenUnit)(
@@ -265,8 +265,10 @@ static bool YesOrNo(const char *keyword, std::size_t length, const char *what,
     IoErrorHandler &handler) {
   static const char *keywords[]{"YES", "NO", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: return true;
-  case 1: return false;
+  case 0:
+    return true;
+  case 1:
+    return false;
   default:
     handler.SignalError(IostatErrorInKeyword, "Invalid %s='%.*s'", what,
         static_cast<int>(length), keyword);
@@ -292,8 +294,12 @@ bool IONAME(SetBlank)(Cookie cookie, const char *keyword, std::size_t length) {
   ConnectionState &connection{io.GetConnectionState()};
   static const char *keywords[]{"NULL", "ZERO", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.editingFlags &= ~blankZero; return true;
-  case 1: connection.modes.editingFlags |= blankZero; return true;
+  case 0:
+    connection.modes.editingFlags &= ~blankZero;
+    return true;
+  case 1:
+    connection.modes.editingFlags |= blankZero;
+    return true;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid BLANK='%.*s'", static_cast<int>(length), keyword);
@@ -307,8 +313,12 @@ bool IONAME(SetDecimal)(
   ConnectionState &connection{io.GetConnectionState()};
   static const char *keywords[]{"COMMA", "POINT", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.editingFlags |= decimalComma; return true;
-  case 1: connection.modes.editingFlags &= ~decimalComma; return true;
+  case 0:
+    connection.modes.editingFlags |= decimalComma;
+    return true;
+  case 1:
+    connection.modes.editingFlags &= ~decimalComma;
+    return true;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid DECIMAL='%.*s'", static_cast<int>(length), keyword);
@@ -321,9 +331,15 @@ bool IONAME(SetDelim)(Cookie cookie, const char *keyword, std::size_t length) {
   ConnectionState &connection{io.GetConnectionState()};
   static const char *keywords[]{"APOSTROPHE", "QUOTE", "NONE", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.delim = '\''; return true;
-  case 1: connection.modes.delim = '"'; return true;
-  case 2: connection.modes.delim = '\0'; return true;
+  case 0:
+    connection.modes.delim = '\'';
+    return true;
+  case 1:
+    connection.modes.delim = '"';
+    return true;
+  case 2:
+    connection.modes.delim = '\0';
+    return true;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid DELIM='%.*s'", static_cast<int>(length), keyword);
@@ -390,11 +406,21 @@ bool IONAME(SetRound)(Cookie cookie, const char *keyword, std::size_t length) {
   static const char *keywords[]{"UP", "DOWN", "ZERO", "NEAREST", "COMPATIBLE",
       "PROCESSOR_DEFINED", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.round = decimal::RoundUp; return true;
-  case 1: connection.modes.round = decimal::RoundDown; return true;
-  case 2: connection.modes.round = decimal::RoundToZero; return true;
-  case 3: connection.modes.round = decimal::RoundNearest; return true;
-  case 4: connection.modes.round = decimal::RoundCompatible; return true;
+  case 0:
+    connection.modes.round = decimal::RoundUp;
+    return true;
+  case 1:
+    connection.modes.round = decimal::RoundDown;
+    return true;
+  case 2:
+    connection.modes.round = decimal::RoundToZero;
+    return true;
+  case 3:
+    connection.modes.round = decimal::RoundNearest;
+    return true;
+  case 4:
+    connection.modes.round = decimal::RoundCompatible;
+    return true;
   case 5:
     connection.modes.round = executionEnvironment.defaultOutputRoundingMode;
     return true;
@@ -410,9 +436,11 @@ bool IONAME(SetSign)(Cookie cookie, const char *keyword, std::size_t length) {
   ConnectionState &connection{io.GetConnectionState()};
   static const char *keywords[]{"PLUS", "YES", "PROCESSOR_DEFINED", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: connection.modes.editingFlags |= signPlus; return true;
+  case 0:
+    connection.modes.editingFlags |= signPlus;
+    return true;
   case 1:
-  case 2:  // processor default is SS
+  case 2: // processor default is SS
     connection.modes.editingFlags &= ~signPlus;
     return true;
   default:
@@ -433,9 +461,15 @@ bool IONAME(SetAccess)(Cookie cookie, const char *keyword, std::size_t length) {
   Access access{connection.access};
   static const char *keywords[]{"SEQUENTIAL", "DIRECT", "STREAM", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: access = Access::Sequential; break;
-  case 1: access = Access::Direct; break;
-  case 2: access = Access::Stream; break;
+  case 0:
+    access = Access::Sequential;
+    break;
+  case 1:
+    access = Access::Direct;
+    break;
+  case 2:
+    access = Access::Stream;
+    break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ACCESS='%.*s'",
         static_cast<int>(length), keyword);
@@ -460,9 +494,14 @@ bool IONAME(SetAction)(Cookie cookie, const char *keyword, std::size_t length) {
   bool mayWrite{true};
   static const char *keywords[]{"READ", "WRITE", "READWRITE", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: mayWrite = false; break;
-  case 1: mayRead = false; break;
-  case 2: break;
+  case 0:
+    mayWrite = false;
+    break;
+  case 1:
+    mayRead = false;
+    break;
+  case 2:
+    break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ACTION='%.*s'",
         static_cast<int>(length), keyword);
@@ -489,8 +528,12 @@ bool IONAME(SetAsynchronous)(
   }
   static const char *keywords[]{"YES", "NO", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: open->unit().set_mayAsynchronous(true); return true;
-  case 1: open->unit().set_mayAsynchronous(false); return true;
+  case 0:
+    open->unit().set_mayAsynchronous(true);
+    return true;
+  case 1:
+    open->unit().set_mayAsynchronous(false);
+    return true;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ASYNCHRONOUS='%.*s'",
         static_cast<int>(length), keyword);
@@ -509,8 +552,12 @@ bool IONAME(SetEncoding)(
   bool isUTF8{false};
   static const char *keywords[]{"UTF-8", "DEFAULT", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: isUTF8 = true; break;
-  case 1: isUTF8 = false; break;
+  case 0:
+    isUTF8 = true;
+    break;
+  case 1:
+    isUTF8 = false;
+    break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ENCODING='%.*s'",
         static_cast<int>(length), keyword);
@@ -534,8 +581,12 @@ bool IONAME(SetForm)(Cookie cookie, const char *keyword, std::size_t length) {
   bool isUnformatted{false};
   static const char *keywords[]{"FORMATTED", "UNFORMATTED", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
-  case 0: isUnformatted = false; break;
-  case 1: isUnformatted = true; break;
+  case 0:
+    isUnformatted = false;
+    break;
+  case 1:
+    isUnformatted = true;
+    break;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid FORM='%.*s'",
         static_cast<int>(length), keyword);
@@ -559,9 +610,15 @@ bool IONAME(SetPosition)(
   }
   static const char *positions[]{"ASIS", "REWIND", "APPEND", nullptr};
   switch (IdentifyValue(keyword, length, positions)) {
-  case 0: open->set_position(Position::AsIs); return true;
-  case 1: open->set_position(Position::Rewind); return true;
-  case 2: open->set_position(Position::Append); return true;
+  case 0:
+    open->set_position(Position::AsIs);
+    return true;
+  case 1:
+    open->set_position(Position::Rewind);
+    return true;
+  case 2:
+    open->set_position(Position::Append);
+    return true;
   default:
     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
         "Invalid POSITION='%.*s'", static_cast<int>(length), keyword);
@@ -593,11 +650,21 @@ bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
     static const char *statuses[]{
         "OLD", "NEW", "SCRATCH", "REPLACE", "UNKNOWN", nullptr};
     switch (IdentifyValue(keyword, length, statuses)) {
-    case 0: open->set_status(OpenStatus::Old); return true;
-    case 1: open->set_status(OpenStatus::New); return true;
-    case 2: open->set_status(OpenStatus::Scratch); return true;
-    case 3: open->set_status(OpenStatus::Replace); return true;
-    case 4: open->set_status(OpenStatus::Unknown); return true;
+    case 0:
+      open->set_status(OpenStatus::Old);
+      return true;
+    case 1:
+      open->set_status(OpenStatus::New);
+      return true;
+    case 2:
+      open->set_status(OpenStatus::Scratch);
+      return true;
+    case 3:
+      open->set_status(OpenStatus::Replace);
+      return true;
+    case 4:
+      open->set_status(OpenStatus::Unknown);
+      return true;
     default:
       io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
           "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
@@ -607,8 +674,12 @@ bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
   if (auto *close{io.get_if<CloseStatementState>()}) {
     static const char *statuses[]{"KEEP", "DELETE", nullptr};
     switch (IdentifyValue(keyword, length, statuses)) {
-    case 0: close->set_status(CloseStatus::Keep); return true;
-    case 1: close->set_status(CloseStatus::Delete); return true;
+    case 0:
+      close->set_status(CloseStatus::Keep);
+      return true;
+    case 1:
+      close->set_status(CloseStatus::Delete);
+      return true;
     default:
       io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
           "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
@@ -616,7 +687,7 @@ bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
     return false;
   }
   if (io.get_if<NoopCloseStatementState>()) {
-    return true;  // don't bother validating STATUS= in a no-op CLOSE
+    return true; // don't bother validating STATUS= in a no-op CLOSE
   }
   io.GetIoErrorHandler().Crash(
       "SetStatus() called when not in an OPEN or CLOSE statement");
@@ -636,11 +707,20 @@ bool IONAME(SetFile)(
 
 static bool SetInteger(int &x, int kind, int value) {
   switch (kind) {
-  case 1: reinterpret_cast<std::int8_t &>(x) = value; return true;
-  case 2: reinterpret_cast<std::int16_t &>(x) = value; return true;
-  case 4: x = value; return true;
-  case 8: reinterpret_cast<std::int64_t &>(x) = value; return true;
-  default: return false;
+  case 1:
+    reinterpret_cast<std::int8_t &>(x) = value;
+    return true;
+  case 2:
+    reinterpret_cast<std::int16_t &>(x) = value;
+    return true;
+  case 4:
+    x = value;
+    return true;
+  case 8:
+    reinterpret_cast<std::int64_t &>(x) = value;
+    return true;
+  default:
+    return false;
   }
 }
 
@@ -661,8 +741,7 @@ bool IONAME(GetNewUnit)(Cookie cookie, int &unit, int kind) {
 
 bool IONAME(OutputDescriptor)(Cookie cookie, const Descriptor &) {
   IoStatementState &io{*cookie};
-  io.GetIoErrorHandler().Crash(
-      "OutputDescriptor: not yet implemented");  // TODO
+  io.GetIoErrorHandler().Crash("OutputDescriptor: not yet implemented"); // TODO
 }
 
 bool IONAME(OutputUnformattedBlock)(
@@ -812,7 +891,7 @@ bool IONAME(InputLogical)(Cookie cookie, bool &truth) {
 
 void IONAME(GetIoMsg)(Cookie cookie, char *msg, std::size_t length) {
   IoErrorHandler &handler{cookie->GetIoErrorHandler()};
-  if (handler.GetIoStat()) {  // leave "msg" alone when no error
+  if (handler.GetIoStat()) { // leave "msg" alone when no error
     handler.GetIoMsg(msg, length);
   }
 }
@@ -821,4 +900,4 @@ enum Iostat IONAME(EndIoStatement)(Cookie cookie) {
   IoStatementState &io{*cookie};
   return static_cast<enum Iostat>(io.EndIoStatement());
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/io-api.h b/flang/runtime/io-api.h
index 0efbf6d1953f..6b394dbdec02 100644
--- a/flang/runtime/io-api.h
+++ b/flang/runtime/io-api.h
@@ -19,7 +19,7 @@
 namespace Fortran::runtime {
 class Descriptor;
 class NamelistGroup;
-}
+} // namespace Fortran::runtime
 
 namespace Fortran::runtime::io {
 
@@ -27,7 +27,7 @@ class IoStatementState;
 using Cookie = IoStatementState *;
 using ExternalUnit = int;
 using AsynchronousId = int;
-static constexpr ExternalUnit DefaultUnit{-1};  // READ(*), WRITE(*), PRINT
+static constexpr ExternalUnit DefaultUnit{-1}; // READ(*), WRITE(*), PRINT
 
 extern "C" {
 
@@ -242,7 +242,7 @@ bool IONAME(SetEncoding)(Cookie, const char *, std::size_t);
 bool IONAME(SetForm)(Cookie, const char *, std::size_t);
 // POSITION=ASIS, REWIND, APPEND
 bool IONAME(SetPosition)(Cookie, const char *, std::size_t);
-bool IONAME(SetRecl)(Cookie, std::size_t);  // RECL=
+bool IONAME(SetRecl)(Cookie, std::size_t); // RECL=
 
 // STATUS can be set during an OPEN or CLOSE statement.
 // For OPEN: STATUS=OLD, NEW, SCRATCH, REPLACE, UNKNOWN
@@ -265,7 +265,7 @@ bool IONAME(GetIoLength)(Cookie, std::int64_t, int kind = 8);
 
 // GetIoMsg() does not modify its argument unless an error or
 // end-of-record/file condition is present.
-void IONAME(GetIoMsg)(Cookie, char *, std::size_t);  // IOMSG=
+void IONAME(GetIoMsg)(Cookie, char *, std::size_t); // IOMSG=
 
 // INQUIRE() specifiers are mostly identified by their NUL-terminated
 // case-insensitive names.
@@ -293,6 +293,6 @@ bool IONAME(InquireInteger64)(
 // rather than by terminating the image.
 enum Iostat IONAME(EndIoStatement)(Cookie);
 
-}  // extern "C"
-}
+} // extern "C"
+} // namespace Fortran::runtime::io
 #endif
diff --git a/flang/runtime/io-error.cpp b/flang/runtime/io-error.cpp
index 721ecf31fecc..58696728c48a 100644
--- a/flang/runtime/io-error.cpp
+++ b/flang/runtime/io-error.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "config.h"
 #include "io-error.h"
+#include "config.h"
 #include "magic-numbers.h"
 #include "tools.h"
 #include <cerrno>
@@ -31,12 +31,12 @@ void IoErrorHandler::SignalError(int iostatOrErrno, const char *msg, ...) {
     }
   } else if (iostatOrErrno == IostatEor && (flags_ & hasEor)) {
     if (!ioStat_ || ioStat_ < IostatEor) {
-      ioStat_ = IostatEor;  // least priority
+      ioStat_ = IostatEor; // least priority
     }
   } else if (iostatOrErrno != IostatOk) {
     if (flags_ & (hasIoStat | hasErr)) {
       if (ioStat_ <= 0) {
-        ioStat_ = iostatOrErrno;  // priority over END=/EOR=
+        ioStat_ = iostatOrErrno; // priority over END=/EOR=
         if (msg && (flags_ & hasIoMsg)) {
           char buffer[256];
           va_list ap;
@@ -102,7 +102,7 @@ bool IoErrorHandler::GetIoMsg(char *buffer, std::size_t bufferLength) {
   return false;
 #endif
   ::strncpy(buffer, newBuf, bufferLength - 1);
-  buffer[bufferLength-1] = '\n';
+  buffer[bufferLength - 1] = '\n';
   return true;
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/io-error.h b/flang/runtime/io-error.h
index 246b12beaf3a..8d43c40ef103 100644
--- a/flang/runtime/io-error.h
+++ b/flang/runtime/io-error.h
@@ -38,29 +38,29 @@ public:
 
   void SignalError(int iostatOrErrno, const char *msg, ...);
   void SignalError(int iostatOrErrno);
-  template<typename... X> void SignalError(const char *msg, X &&... xs) {
+  template <typename... X> void SignalError(const char *msg, X &&... xs) {
     SignalError(IostatGenericError, msg, std::forward<X>(xs)...);
   }
 
-  void SignalErrno();  // SignalError(errno)
-  void SignalEnd();  // input only; EOF on internal write is an error
-  void SignalEor();  // non-advancing input only; EOR on write is an error
+  void SignalErrno(); // SignalError(errno)
+  void SignalEnd(); // input only; EOF on internal write is an error
+  void SignalEor(); // non-advancing input only; EOR on write is an error
 
   int GetIoStat() const { return ioStat_; }
   bool GetIoMsg(char *, std::size_t);
 
 private:
   enum Flag : std::uint8_t {
-    hasIoStat = 1,  // IOSTAT=
-    hasErr = 2,  // ERR=
-    hasEnd = 4,  // END=
-    hasEor = 8,  // EOR=
-    hasIoMsg = 16,  // IOMSG=
+    hasIoStat = 1, // IOSTAT=
+    hasErr = 2, // ERR=
+    hasEnd = 4, // END=
+    hasEor = 8, // EOR=
+    hasIoMsg = 16, // IOMSG=
   };
   std::uint8_t flags_{0};
   int ioStat_{0};
   OwningPtr<char> ioMsg_;
 };
 
-}
-#endif  // FORTRAN_RUNTIME_IO_ERROR_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_ERROR_H_
diff --git a/flang/runtime/io-stmt.cpp b/flang/runtime/io-stmt.cpp
index ea76226d7290..1e2e5f5ec5c8 100644
--- a/flang/runtime/io-stmt.cpp
+++ b/flang/runtime/io-stmt.cpp
@@ -25,17 +25,17 @@ std::optional<DataEdit> IoStatementBase::GetNextDataEdit(
   return std::nullopt;
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalIoStatementState<DIR, CHAR>::InternalIoStatementState(
     Buffer scalar, std::size_t length, const char *sourceFile, int sourceLine)
-  : IoStatementBase{sourceFile, sourceLine}, unit_{scalar, length} {}
+    : IoStatementBase{sourceFile, sourceLine}, unit_{scalar, length} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalIoStatementState<DIR, CHAR>::InternalIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
-  : IoStatementBase{sourceFile, sourceLine}, unit_{d, *this} {}
+    : IoStatementBase{sourceFile, sourceLine}, unit_{d, *this} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 bool InternalIoStatementState<DIR, CHAR>::Emit(
     const CharType *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
@@ -45,7 +45,7 @@ bool InternalIoStatementState<DIR, CHAR>::Emit(
   return unit_.Emit(data, chars, *this);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 std::optional<char32_t> InternalIoStatementState<DIR, CHAR>::GetCurrentChar() {
   if constexpr (DIR == Direction::Output) {
     Crash(
@@ -55,7 +55,7 @@ std::optional<char32_t> InternalIoStatementState<DIR, CHAR>::GetCurrentChar() {
   return unit_.GetCurrentChar(*this);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 bool InternalIoStatementState<DIR, CHAR>::AdvanceRecord(int n) {
   while (n-- > 0) {
     if (!unit_.AdvanceRecord(*this)) {
@@ -65,15 +65,15 @@ bool InternalIoStatementState<DIR, CHAR>::AdvanceRecord(int n) {
   return true;
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 void InternalIoStatementState<DIR, CHAR>::BackspaceRecord() {
   unit_.BackspaceRecord(*this);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 int InternalIoStatementState<DIR, CHAR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) {
-    unit_.EndIoStatement();  // fill
+    unit_.EndIoStatement(); // fill
   }
   auto result{IoStatementBase::EndIoStatement()};
   if (free_) {
@@ -82,56 +82,57 @@ int InternalIoStatementState<DIR, CHAR>::EndIoStatement() {
   return result;
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 void InternalIoStatementState<DIR, CHAR>::HandleAbsolutePosition(
     std::int64_t n) {
   return unit_.HandleAbsolutePosition(n);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 void InternalIoStatementState<DIR, CHAR>::HandleRelativePosition(
     std::int64_t n) {
   return unit_.HandleRelativePosition(n);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     Buffer buffer, std::size_t length, const CHAR *format,
     std::size_t formatLength, const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<DIR, CHAR>{buffer, length, sourceFile, sourceLine},
-    ioStatementState_{*this}, format_{*this, format, formatLength} {}
+    : InternalIoStatementState<DIR, CHAR>{buffer, length, sourceFile,
+          sourceLine},
+      ioStatementState_{*this}, format_{*this, format, formatLength} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     const Descriptor &d, const CHAR *format, std::size_t formatLength,
     const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<DIR, CHAR>{d, sourceFile, sourceLine},
-    ioStatementState_{*this}, format_{*this, format, formatLength} {}
+    : InternalIoStatementState<DIR, CHAR>{d, sourceFile, sourceLine},
+      ioStatementState_{*this}, format_{*this, format, formatLength} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 int InternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) {
-    format_.Finish(*this);  // ignore any remaining input positioning actions
+    format_.Finish(*this); // ignore any remaining input positioning actions
   }
   return InternalIoStatementState<DIR, CHAR>::EndIoStatement();
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
     Buffer buffer, std::size_t length, const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<DIR, CharType>{buffer, length, sourceFile,
-        sourceLine},
-    ioStatementState_{*this} {}
+    : InternalIoStatementState<DIR, CharType>{buffer, length, sourceFile,
+          sourceLine},
+      ioStatementState_{*this} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 InternalListIoStatementState<DIR, CHAR>::InternalListIoStatementState(
     const Descriptor &d, const char *sourceFile, int sourceLine)
-  : InternalIoStatementState<DIR, CharType>{d, sourceFile, sourceLine},
-    ioStatementState_{*this} {}
+    : InternalIoStatementState<DIR, CharType>{d, sourceFile, sourceLine},
+      ioStatementState_{*this} {}
 
 ExternalIoStatementBase::ExternalIoStatementBase(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
-  : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
+    : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
 
 MutableModes &ExternalIoStatementBase::mutableModes() { return unit_.modes; }
 
@@ -145,16 +146,16 @@ int ExternalIoStatementBase::EndIoStatement() {
     unit_.leftTabLimit.reset();
   }
   auto result{IoStatementBase::EndIoStatement()};
-  unit_.EndIoStatement();  // annihilates *this in unit_.u_
+  unit_.EndIoStatement(); // annihilates *this in unit_.u_
   return result;
 }
 
 void OpenStatementState::set_path(
     const char *path, std::size_t length, int kind) {
-  if (kind != 1) {  // TODO
+  if (kind != 1) { // TODO
     Crash("OPEN: FILE= with unimplemented: CHARACTER(KIND=%d)", kind);
   }
-  std::size_t bytes{length * kind};  // TODO: UTF-8 encoding of Unicode path
+  std::size_t bytes{length * kind}; // TODO: UTF-8 encoding of Unicode path
   path_ = SaveDefaultCharacter(path, bytes, *this);
   pathLength_ = length;
 }
@@ -180,7 +181,7 @@ int NoopCloseStatementState::EndIoStatement() {
   return result;
 }
 
-template<Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
+template <Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
   if constexpr (DIR == Direction::Output) {
     if (!unit().nonAdvancing) {
       unit().AdvanceRecord(*this);
@@ -190,7 +191,7 @@ template<Direction DIR> int ExternalIoStatementState<DIR>::EndIoStatement() {
   return ExternalIoStatementBase::EndIoStatement();
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool ExternalIoStatementState<DIR>::Emit(const char *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
     Crash("ExternalIoStatementState::Emit(char) called for input statement");
@@ -198,7 +199,7 @@ bool ExternalIoStatementState<DIR>::Emit(const char *data, std::size_t chars) {
   return unit().Emit(data, chars * sizeof(*data), *this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool ExternalIoStatementState<DIR>::Emit(
     const char16_t *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
@@ -210,7 +211,7 @@ bool ExternalIoStatementState<DIR>::Emit(
       reinterpret_cast<const char *>(data), chars * sizeof(*data), *this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool ExternalIoStatementState<DIR>::Emit(
     const char32_t *data, std::size_t chars) {
   if constexpr (DIR == Direction::Input) {
@@ -222,7 +223,7 @@ bool ExternalIoStatementState<DIR>::Emit(
       reinterpret_cast<const char *>(data), chars * sizeof(*data), *this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 std::optional<char32_t> ExternalIoStatementState<DIR>::GetCurrentChar() {
   if constexpr (DIR == Direction::Output) {
     Crash(
@@ -231,7 +232,7 @@ std::optional<char32_t> ExternalIoStatementState<DIR>::GetCurrentChar() {
   return unit().GetCurrentChar(*this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 bool ExternalIoStatementState<DIR>::AdvanceRecord(int n) {
   while (n-- > 0) {
     if (!unit().AdvanceRecord(*this)) {
@@ -241,28 +242,28 @@ bool ExternalIoStatementState<DIR>::AdvanceRecord(int n) {
   return true;
 }
 
-template<Direction DIR> void ExternalIoStatementState<DIR>::BackspaceRecord() {
+template <Direction DIR> void ExternalIoStatementState<DIR>::BackspaceRecord() {
   unit().BackspaceRecord(*this);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 void ExternalIoStatementState<DIR>::HandleAbsolutePosition(std::int64_t n) {
   return unit().HandleAbsolutePosition(n);
 }
 
-template<Direction DIR>
+template <Direction DIR>
 void ExternalIoStatementState<DIR>::HandleRelativePosition(std::int64_t n) {
   return unit().HandleRelativePosition(n);
 }
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 ExternalFormattedIoStatementState<DIR, CHAR>::ExternalFormattedIoStatementState(
     ExternalFileUnit &unit, const CHAR *format, std::size_t formatLength,
     const char *sourceFile, int sourceLine)
-  : ExternalIoStatementState<DIR>{unit, sourceFile, sourceLine},
-    mutableModes_{unit.modes}, format_{*this, format, formatLength} {}
+    : ExternalIoStatementState<DIR>{unit, sourceFile, sourceLine},
+      mutableModes_{unit.modes}, format_{*this, format, formatLength} {}
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 int ExternalFormattedIoStatementState<DIR, CHAR>::EndIoStatement() {
   format_.Finish(*this);
   return ExternalIoStatementState<DIR>::EndIoStatement();
@@ -359,7 +360,7 @@ void IoStatementState::SkipSpaces(std::optional<int> &remaining) {
 
 std::optional<char32_t> IoStatementState::NextInField(
     std::optional<int> &remaining) {
-  if (!remaining) {  // list-directed or namelist: check for separators
+  if (!remaining) { // list-directed or namelist: check for separators
     if (auto next{GetCurrentChar()}) {
       switch (*next) {
       case ' ':
@@ -370,8 +371,11 @@ std::optional<char32_t> IoStatementState::NextInField(
       case ')':
       case '\'':
       case '"':
-      case '*': break;
-      default: HandleRelativePosition(1); return next;
+      case '*':
+        break;
+      default:
+        HandleRelativePosition(1);
+        return next;
       }
     }
   } else if (*remaining > 0) {
@@ -383,7 +387,7 @@ std::optional<char32_t> IoStatementState::NextInField(
     const ConnectionState &connection{GetConnectionState()};
     if (!connection.IsAtEOF() && connection.recordLength &&
         connection.positionInRecord >= *connection.recordLength) {
-      if (connection.modes.pad) {  // PAD='YES'
+      if (connection.modes.pad) { // PAD='YES'
         --*remaining;
         return std::optional<char32_t>{' '};
       }
@@ -452,13 +456,13 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
   ConnectionState &connection{io.GetConnectionState()};
   DataEdit edit;
   edit.descriptor = DataEdit::ListDirected;
-  edit.repeat = 1;  // may be overridden below
+  edit.repeat = 1; // may be overridden below
   edit.modes = connection.modes;
-  if (hitSlash_) {  // everything after '/' is nullified
+  if (hitSlash_) { // everything after '/' is nullified
     edit.descriptor = DataEdit::ListDirectedNullValue;
     return edit;
   }
-  if (remaining_ > 0 && !realPart_) {  // "r*c" repetition in progress
+  if (remaining_ > 0 && !realPart_) { // "r*c" repetition in progress
     while (connection.currentRecordNumber > initialRecordNumber_) {
       io.BackspaceRecord();
     }
@@ -511,10 +515,10 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
       return edit;
     }
   }
-  if (imaginaryPart_) {  // can't repeat components
+  if (imaginaryPart_) { // can't repeat components
     return edit;
   }
-  if (*ch >= '0' && *ch <= '9') {  // look for "r*" repetition count
+  if (*ch >= '0' && *ch <= '9') { // look for "r*" repetition count
     auto start{connection.positionInRecord};
     int r{0};
     do {
@@ -527,10 +531,10 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
       io.HandleRelativePosition(1);
       ch = io.GetCurrentChar();
     } while (ch && *ch >= '0' && *ch <= '9');
-    if (r > 0 && ch && *ch == '*') {  // subtle: r must be nonzero
+    if (r > 0 && ch && *ch == '*') { // subtle: r must be nonzero
       io.HandleRelativePosition(1);
       ch = io.GetCurrentChar();
-      if (!ch || *ch == ' ' || *ch == comma || *ch == '/') {  // "r*" null
+      if (!ch || *ch == ' ' || *ch == comma || *ch == '/') { // "r*" null
         edit.descriptor = DataEdit::ListDirectedNullValue;
         return edit;
       }
@@ -538,7 +542,7 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
       remaining_ = r - edit.repeat;
       initialRecordNumber_ = connection.currentRecordNumber;
       initialPositionInRecord_ = connection.positionInRecord;
-    } else {  // not a repetition count, just an integer value; rewind
+    } else { // not a repetition count, just an integer value; rewind
       connection.positionInRecord = start;
     }
   }
@@ -549,7 +553,8 @@ ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
   return edit;
 }
 
-template<Direction DIR> int UnformattedIoStatementState<DIR>::EndIoStatement() {
+template <Direction DIR>
+int UnformattedIoStatementState<DIR>::EndIoStatement() {
   auto &ext{static_cast<ExternalIoStatementState<DIR> &>(*this)};
   ExternalFileUnit &unit{ext.unit()};
   if (unit.access == Access::Sequential && !unit.recordLength.has_value()) {
@@ -587,4 +592,4 @@ template class ExternalListIoStatementState<Direction::Output>;
 template class ExternalListIoStatementState<Direction::Input>;
 template class UnformattedIoStatementState<Direction::Output>;
 template class UnformattedIoStatementState<Direction::Input>;
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/io-stmt.h b/flang/runtime/io-stmt.h
index 73b93a1f7e4b..b8145d79a96a 100644
--- a/flang/runtime/io-stmt.h
+++ b/flang/runtime/io-stmt.h
@@ -29,18 +29,18 @@ class OpenStatementState;
 class CloseStatementState;
 class NoopCloseStatementState;
 
-template<Direction, typename CHAR = char>
+template <Direction, typename CHAR = char>
 class InternalFormattedIoStatementState;
-template<Direction, typename CHAR = char> class InternalListIoStatementState;
-template<Direction, typename CHAR = char>
+template <Direction, typename CHAR = char> class InternalListIoStatementState;
+template <Direction, typename CHAR = char>
 class ExternalFormattedIoStatementState;
-template<Direction> class ExternalListIoStatementState;
-template<Direction> class UnformattedIoStatementState;
+template <Direction> class ExternalListIoStatementState;
+template <Direction> class UnformattedIoStatementState;
 
 // The Cookie type in the I/O API is a pointer (for C) to this class.
 class IoStatementState {
 public:
-  template<typename A> explicit IoStatementState(A &x) : u_{x} {}
+  template <typename A> explicit IoStatementState(A &x) : u_{x} {}
 
   // These member functions each project themselves into the active alternative.
   // They're used by per-data-item routines in the I/O API (e.g., OutputReal64)
@@ -49,18 +49,18 @@ public:
   // which may not have good support in some runtime environments.
   std::optional<DataEdit> GetNextDataEdit(int = 1);
   bool Emit(const char *, std::size_t);
-  std::optional<char32_t> GetCurrentChar();  // vacant after end of record
+  std::optional<char32_t> GetCurrentChar(); // vacant after end of record
   bool AdvanceRecord(int = 1);
   void BackspaceRecord();
   void HandleRelativePosition(std::int64_t);
   int EndIoStatement();
   ConnectionState &GetConnectionState();
   IoErrorHandler &GetIoErrorHandler() const;
-  ExternalFileUnit *GetExternalFileUnit() const;  // null if internal unit
+  ExternalFileUnit *GetExternalFileUnit() const; // null if internal unit
   MutableModes &mutableModes();
 
   // N.B.: this also works with base classes
-  template<typename A> A *get_if() const {
+  template <typename A> A *get_if() const {
     return std::visit(
         [](auto &x) -> A * {
           if constexpr (std::is_convertible_v<decltype(x.get()), A &>) {
@@ -75,7 +75,7 @@ public:
   bool EmitField(const char *, std::size_t length, std::size_t width);
   void SkipSpaces(std::optional<int> &remaining);
   std::optional<char32_t> NextInField(std::optional<int> &remaining);
-  std::optional<char32_t> GetNextNonBlank();  // can advance record
+  std::optional<char32_t> GetNextNonBlank(); // can advance record
 
 private:
   std::variant<std::reference_wrapper<OpenStatementState>,
@@ -109,15 +109,15 @@ struct IoStatementBase : public DefaultFormatControlCallbacks {
 
 struct InputStatementState {};
 struct OutputStatementState {};
-template<Direction D>
+template <Direction D>
 using IoDirectionState = std::conditional_t<D == Direction::Input,
     InputStatementState, OutputStatementState>;
 
 struct FormattedStatementState {};
 
 // Common state for list-directed internal & external I/O
-template<Direction> struct ListDirectedStatementState {};
-template<> struct ListDirectedStatementState<Direction::Output> {
+template <Direction> struct ListDirectedStatementState {};
+template <> struct ListDirectedStatementState<Direction::Output> {
   static std::size_t RemainingSpaceInRecord(const ConnectionState &);
   bool NeedAdvance(const ConnectionState &, std::size_t) const;
   bool EmitLeadingSpaceOrAdvance(
@@ -126,7 +126,7 @@ template<> struct ListDirectedStatementState<Direction::Output> {
       IoStatementState &, int maxRepeat = 1);
   bool lastWasUndelimitedCharacter{false};
 };
-template<> class ListDirectedStatementState<Direction::Input> {
+template <> class ListDirectedStatementState<Direction::Input> {
 public:
   // Skips value separators, handles repetition and null values.
   // Vacant when '/' appears; present with descriptor == ListDirectedNullValue
@@ -135,16 +135,16 @@ public:
       IoStatementState &, int maxRepeat = 1);
 
 private:
-  int remaining_{0};  // for "r*" repetition
+  int remaining_{0}; // for "r*" repetition
   std::int64_t initialRecordNumber_;
   std::int64_t initialPositionInRecord_;
-  bool isFirstItem_{true};  // leading separator implies null first item
-  bool hitSlash_{false};  // once '/' is seen, nullify further items
+  bool isFirstItem_{true}; // leading separator implies null first item
+  bool hitSlash_{false}; // once '/' is seen, nullify further items
   bool realPart_{false};
   bool imaginaryPart_{false};
 };
 
-template<Direction DIR, typename CHAR = char>
+template <Direction DIR, typename CHAR = char>
 class InternalIoStatementState : public IoStatementBase,
                                  public IoDirectionState<DIR> {
 public:
@@ -170,10 +170,10 @@ protected:
   InternalDescriptorUnit<DIR> unit_;
 };
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 class InternalFormattedIoStatementState
-  : public InternalIoStatementState<DIR, CHAR>,
-    public FormattedStatementState {
+    : public InternalIoStatementState<DIR, CHAR>,
+      public FormattedStatementState {
 public:
   using CharType = CHAR;
   using typename InternalIoStatementState<DIR, CharType>::Buffer;
@@ -191,13 +191,13 @@ public:
   }
 
 private:
-  IoStatementState ioStatementState_;  // points to *this
+  IoStatementState ioStatementState_; // points to *this
   using InternalIoStatementState<DIR, CharType>::unit_;
   // format_ *must* be last; it may be partial someday
   FormatControl<InternalFormattedIoStatementState> format_;
 };
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 class InternalListIoStatementState : public InternalIoStatementState<DIR, CHAR>,
                                      public ListDirectedStatementState<DIR> {
 public:
@@ -211,7 +211,7 @@ public:
   using ListDirectedStatementState<DIR>::GetNextDataEdit;
 
 private:
-  IoStatementState ioStatementState_;  // points to *this
+  IoStatementState ioStatementState_; // points to *this
   using InternalIoStatementState<DIR, CharType>::unit_;
 };
 
@@ -229,7 +229,7 @@ private:
   ExternalFileUnit &unit_;
 };
 
-template<Direction DIR>
+template <Direction DIR>
 class ExternalIoStatementState : public ExternalIoStatementBase,
                                  public IoDirectionState<DIR> {
 public:
@@ -245,7 +245,7 @@ public:
   void HandleAbsolutePosition(std::int64_t);
 };
 
-template<Direction DIR, typename CHAR>
+template <Direction DIR, typename CHAR>
 class ExternalFormattedIoStatementState : public ExternalIoStatementState<DIR>,
                                           public FormattedStatementState {
 public:
@@ -268,7 +268,7 @@ private:
   FormatControl<ExternalFormattedIoStatementState> format_;
 };
 
-template<Direction DIR>
+template <Direction DIR>
 class ExternalListIoStatementState : public ExternalIoStatementState<DIR>,
                                      public ListDirectedStatementState<DIR> {
 public:
@@ -276,7 +276,7 @@ public:
   using ListDirectedStatementState<DIR>::GetNextDataEdit;
 };
 
-template<Direction DIR>
+template <Direction DIR>
 class UnformattedIoStatementState : public ExternalIoStatementState<DIR> {
 public:
   using ExternalIoStatementState<DIR>::ExternalIoStatementState;
@@ -287,12 +287,12 @@ class OpenStatementState : public ExternalIoStatementBase {
 public:
   OpenStatementState(ExternalFileUnit &unit, bool wasExtant,
       const char *sourceFile = nullptr, int sourceLine = 0)
-    : ExternalIoStatementBase{unit, sourceFile, sourceLine}, wasExtant_{
-                                                                 wasExtant} {}
+      : ExternalIoStatementBase{unit, sourceFile, sourceLine}, wasExtant_{
+                                                                   wasExtant} {}
   bool wasExtant() const { return wasExtant_; }
   void set_status(OpenStatus status) { status_ = status; }
-  void set_path(const char *, std::size_t, int kind);  // FILE=
-  void set_position(Position position) { position_ = position; }  // POSITION=
+  void set_path(const char *, std::size_t, int kind); // FILE=
+  void set_position(Position position) { position_ = position; } // POSITION=
   int EndIoStatement();
 
 private:
@@ -307,7 +307,7 @@ class CloseStatementState : public ExternalIoStatementBase {
 public:
   CloseStatementState(ExternalFileUnit &unit, const char *sourceFile = nullptr,
       int sourceLine = 0)
-    : ExternalIoStatementBase{unit, sourceFile, sourceLine} {}
+      : ExternalIoStatementBase{unit, sourceFile, sourceLine} {}
   void set_status(CloseStatus status) { status_ = status; }
   int EndIoStatement();
 
@@ -318,15 +318,15 @@ private:
 class NoopCloseStatementState : public IoStatementBase {
 public:
   NoopCloseStatementState(const char *sourceFile, int sourceLine)
-    : IoStatementBase{sourceFile, sourceLine}, ioStatementState_{*this} {}
+      : IoStatementBase{sourceFile, sourceLine}, ioStatementState_{*this} {}
   IoStatementState &ioStatementState() { return ioStatementState_; }
-  void set_status(CloseStatus) {}  // discards
+  void set_status(CloseStatus) {} // discards
   MutableModes &mutableModes() { return connection_.modes; }
   ConnectionState &GetConnectionState() { return connection_; }
   int EndIoStatement();
 
 private:
-  IoStatementState ioStatementState_;  // points to *this
+  IoStatementState ioStatementState_; // points to *this
   ConnectionState connection_;
 };
 
@@ -353,5 +353,5 @@ extern template class FormatControl<
 extern template class FormatControl<
     ExternalFormattedIoStatementState<Direction::Input>>;
 
-}
-#endif  // FORTRAN_RUNTIME_IO_STMT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_STMT_H_
diff --git a/flang/runtime/iostat.cpp b/flang/runtime/iostat.cpp
index 6e146faecdae..c86619d384f9 100644
--- a/flang/runtime/iostat.cpp
+++ b/flang/runtime/iostat.cpp
@@ -11,21 +11,31 @@
 namespace Fortran::runtime::io {
 const char *IostatErrorString(int iostat) {
   switch (iostat) {
-  case IostatOk: return "No error";
-  case IostatEnd: return "End of file during input";
-  case IostatEor: return "End of record during non-advancing input";
-  case IostatUnflushable: return "FLUSH not possible";
-  case IostatInquireInternalUnit: return "INQUIRE on internal unit";
+  case IostatOk:
+    return "No error";
+  case IostatEnd:
+    return "End of file during input";
+  case IostatEor:
+    return "End of record during non-advancing input";
+  case IostatUnflushable:
+    return "FLUSH not possible";
+  case IostatInquireInternalUnit:
+    return "INQUIRE on internal unit";
   case IostatGenericError:
-    return "I/O error";  // dummy value, there's always a message
-  case IostatRecordWriteOverrun: return "Excessive output to fixed-size record";
-  case IostatRecordReadOverrun: return "Excessive input from fixed-size record";
+    return "I/O error"; // dummy value, there's always a message
+  case IostatRecordWriteOverrun:
+    return "Excessive output to fixed-size record";
+  case IostatRecordReadOverrun:
+    return "Excessive input from fixed-size record";
   case IostatInternalWriteOverrun:
     return "Internal write overran available records";
-  case IostatErrorInFormat: return "Invalid FORMAT";
-  case IostatErrorInKeyword: return "Bad keyword argument value";
-  default: return nullptr;
+  case IostatErrorInFormat:
+    return "Invalid FORMAT";
+  case IostatErrorInKeyword:
+    return "Bad keyword argument value";
+  default:
+    return nullptr;
   }
 }
 
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/iostat.h b/flang/runtime/iostat.h
index b5b78360feb2..2ab5ac8232d2 100644
--- a/flang/runtime/iostat.h
+++ b/flang/runtime/iostat.h
@@ -22,11 +22,11 @@ namespace Fortran::runtime::io {
 // they're actually defined in another magic-numbers.h header file
 // so that they can be included both here and there.)
 enum Iostat {
-  IostatOk = 0,  // no error, EOF, or EOR condition
+  IostatOk = 0, // no error, EOF, or EOR condition
 
   // These error codes are required by Fortran (see 12.10.2.16-17) to be
   // negative integer values
-  IostatEnd = FORTRAN_RUNTIME_IOSTAT_END,  // end-of-file on input & no error
+  IostatEnd = FORTRAN_RUNTIME_IOSTAT_END, // end-of-file on input & no error
   // End-of-record on non-advancing input, no EOF or error
   IostatEor = FORTRAN_RUNTIME_IOSTAT_EOR,
 
@@ -39,7 +39,7 @@ enum Iostat {
   IostatInquireInternalUnit = FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT,
 
   // The remaining error codes are not exported.
-  IostatGenericError = 1001,  // see IOMSG= for details
+  IostatGenericError = 1001, // see IOMSG= for details
   IostatRecordWriteOverrun,
   IostatRecordReadOverrun,
   IostatInternalWriteOverrun,
@@ -49,5 +49,5 @@ enum Iostat {
 
 const char *IostatErrorString(int);
 
-}
-#endif  // FORTRAN_RUNTIME_IOSTAT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IOSTAT_H_
diff --git a/flang/runtime/lock.h b/flang/runtime/lock.h
index 5c614801f2ae..714b1d595b18 100644
--- a/flang/runtime/lock.h
+++ b/flang/runtime/lock.h
@@ -27,6 +27,7 @@ public:
       terminator.Crash("Lock::CheckLocked() failed");
     }
   }
+
 private:
   std::mutex mutex_;
 };
@@ -39,6 +40,6 @@ public:
 private:
   Lock &lock_;
 };
-}
+} // namespace Fortran::runtime
 
-#endif  // FORTRAN_RUNTIME_LOCK_H_
+#endif // FORTRAN_RUNTIME_LOCK_H_
diff --git a/flang/runtime/main.cpp b/flang/runtime/main.cpp
index 707e35cc99a0..5de2e6434abb 100644
--- a/flang/runtime/main.cpp
+++ b/flang/runtime/main.cpp
@@ -14,7 +14,7 @@
 #include <cstdlib>
 
 static void ConfigureFloatingPoint() {
-#ifdef feclearexcept  // a macro in some environments; omit std::
+#ifdef feclearexcept // a macro in some environments; omit std::
   feclearexcept(FE_ALL_EXCEPT);
 #else
   std::feclearexcept(FE_ALL_EXCEPT);
diff --git a/flang/runtime/main.h b/flang/runtime/main.h
index 94ce3a93b70b..31ef8f8f4446 100644
--- a/flang/runtime/main.h
+++ b/flang/runtime/main.h
@@ -16,4 +16,4 @@ FORTRAN_EXTERN_C_BEGIN
 void RTNAME(ProgramStart)(int, const char *[], const char *[]);
 FORTRAN_EXTERN_C_END
 
-#endif  // FORTRAN_RUNTIME_MAIN_H_
+#endif // FORTRAN_RUNTIME_MAIN_H_
diff --git a/flang/runtime/memory.cpp b/flang/runtime/memory.cpp
index 84fd35da48ef..21cd210308a2 100644
--- a/flang/runtime/memory.cpp
+++ b/flang/runtime/memory.cpp
@@ -25,4 +25,4 @@ void *AllocateMemoryOrCrash(const Terminator &terminator, std::size_t bytes) {
 }
 
 void FreeMemory(void *p) { std::free(p); }
-}
+} // namespace Fortran::runtime
diff --git a/flang/runtime/memory.h b/flang/runtime/memory.h
index 1bd5bca1b78a..f26213f954a4 100644
--- a/flang/runtime/memory.h
+++ b/flang/runtime/memory.h
@@ -20,38 +20,38 @@ class Terminator;
 
 [[nodiscard]] void *AllocateMemoryOrCrash(
     const Terminator &, std::size_t bytes);
-template<typename A>[[nodiscard]] A &AllocateOrCrash(const Terminator &t) {
+template <typename A>[[nodiscard]] A &AllocateOrCrash(const Terminator &t) {
   return *reinterpret_cast<A *>(AllocateMemoryOrCrash(t, sizeof(A)));
 }
 void FreeMemory(void *);
-template<typename A> void FreeMemory(A *p) {
+template <typename A> void FreeMemory(A *p) {
   FreeMemory(reinterpret_cast<void *>(p));
 }
-template<typename A> void FreeMemoryAndNullify(A *&p) {
+template <typename A> void FreeMemoryAndNullify(A *&p) {
   FreeMemory(p);
   p = nullptr;
 }
 
-template<typename A> struct New {
-  template<typename... X>
+template <typename A> struct New {
+  template <typename... X>
   [[nodiscard]] A &operator()(const Terminator &terminator, X &&... x) {
     return *new (AllocateMemoryOrCrash(terminator, sizeof(A)))
         A{std::forward<X>(x)...};
   }
 };
 
-template<typename A> struct OwningPtrDeleter {
+template <typename A> struct OwningPtrDeleter {
   void operator()(A *p) { FreeMemory(p); }
 };
 
-template<typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
+template <typename A> using OwningPtr = std::unique_ptr<A, OwningPtrDeleter<A>>;
 
-template<typename A> struct Allocator {
+template <typename A> struct Allocator {
   using value_type = A;
   explicit Allocator(const Terminator &t) : terminator{t} {}
-  template<typename B>
+  template <typename B>
   explicit constexpr Allocator(const Allocator<B> &that) noexcept
-    : terminator{that.terminator} {}
+      : terminator{that.terminator} {}
   Allocator(const Allocator &) = default;
   Allocator(Allocator &&) = default;
   [[nodiscard]] constexpr A *allocate(std::size_t n) {
@@ -61,6 +61,6 @@ template<typename A> struct Allocator {
   constexpr void deallocate(A *p, std::size_t) { FreeMemory(p); }
   const Terminator &terminator;
 };
-}
+} // namespace Fortran::runtime
 
-#endif  // FORTRAN_RUNTIME_MEMORY_H_
+#endif // FORTRAN_RUNTIME_MEMORY_H_
diff --git a/flang/runtime/stop.cpp b/flang/runtime/stop.cpp
index 46ad558dfe4c..321b060d8b91 100644
--- a/flang/runtime/stop.cpp
+++ b/flang/runtime/stop.cpp
@@ -17,7 +17,7 @@
 extern "C" {
 
 static void DescribeIEEESignaledExceptions() {
-#ifdef fetestexcept  // a macro in some environments; omit std::
+#ifdef fetestexcept // a macro in some environments; omit std::
   auto excepts{fetestexcept(FE_ALL_EXCEPT)};
 #else
   auto excepts{std::fetestexcept(FE_ALL_EXCEPT)};
diff --git a/flang/runtime/stop.h b/flang/runtime/stop.h
index 24fea0b4f7db..249e71e0b1f0 100644
--- a/flang/runtime/stop.h
+++ b/flang/runtime/stop.h
@@ -25,4 +25,4 @@ NORETURN void RTNAME(ProgramEndStatement)(NO_ARGUMENTS);
 
 FORTRAN_EXTERN_C_END
 
-#endif  // FORTRAN_RUNTIME_STOP_H_
+#endif // FORTRAN_RUNTIME_STOP_H_
diff --git a/flang/runtime/terminator.cpp b/flang/runtime/terminator.cpp
index cc0f4d23a439..cea1a8673eeb 100644
--- a/flang/runtime/terminator.cpp
+++ b/flang/runtime/terminator.cpp
@@ -57,4 +57,4 @@ void Terminator::RegisterCrashHandler(
 void NotifyOtherImagesOfNormalEnd() {}
 void NotifyOtherImagesOfFailImageStatement() {}
 void NotifyOtherImagesOfErrorTermination() {}
-}
+} // namespace Fortran::runtime
diff --git a/flang/runtime/terminator.h b/flang/runtime/terminator.h
index 20f5abd435c0..66bc92ae4e25 100644
--- a/flang/runtime/terminator.h
+++ b/flang/runtime/terminator.h
@@ -23,7 +23,7 @@ public:
   Terminator() {}
   Terminator(const Terminator &) = default;
   explicit Terminator(const char *sourceFileName, int sourceLine = 0)
-    : sourceFileName_{sourceFileName}, sourceLine_{sourceLine} {}
+      : sourceFileName_{sourceFileName}, sourceLine_{sourceLine} {}
   void SetLocation(const char *sourceFileName = nullptr, int sourceLine = 0) {
     sourceFileName_ = sourceFileName;
     sourceLine_ = sourceLine;
@@ -51,10 +51,10 @@ private:
 void NotifyOtherImagesOfNormalEnd();
 void NotifyOtherImagesOfFailImageStatement();
 void NotifyOtherImagesOfErrorTermination();
-}
+} // namespace Fortran::runtime
 
 namespace Fortran::runtime::io {
 void FlushOutputOnCrash(const Terminator &);
 }
 
-#endif  // FORTRAN_RUNTIME_TERMINATOR_H_
+#endif // FORTRAN_RUNTIME_TERMINATOR_H_
diff --git a/flang/runtime/tools.cpp b/flang/runtime/tools.cpp
index 12c792ca29cc..ea9ad9063344 100644
--- a/flang/runtime/tools.cpp
+++ b/flang/runtime/tools.cpp
@@ -68,4 +68,4 @@ void ToFortranDefaultCharacter(
   }
 }
 
-}
+} // namespace Fortran::runtime
diff --git a/flang/runtime/tools.h b/flang/runtime/tools.h
index ec7982c2082f..fad19f607c68 100644
--- a/flang/runtime/tools.h
+++ b/flang/runtime/tools.h
@@ -31,5 +31,5 @@ int IdentifyValue(
 // Truncates or pads as necessary
 void ToFortranDefaultCharacter(
     char *to, std::size_t toLength, const char *from);
-}
-#endif  // FORTRAN_RUNTIME_TOOLS_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_TOOLS_H_
diff --git a/flang/runtime/transformational.cpp b/flang/runtime/transformational.cpp
index f0577c6e7dd3..1964a536f7df 100644
--- a/flang/runtime/transformational.cpp
+++ b/flang/runtime/transformational.cpp
@@ -17,10 +17,14 @@ namespace Fortran::runtime {
 
 static inline std::int64_t GetInt64(const char *p, std::size_t bytes) {
   switch (bytes) {
-  case 1: return *reinterpret_cast<const std::int8_t *>(p);
-  case 2: return *reinterpret_cast<const std::int16_t *>(p);
-  case 4: return *reinterpret_cast<const std::int32_t *>(p);
-  case 8: return *reinterpret_cast<const std::int64_t *>(p);
+  case 1:
+    return *reinterpret_cast<const std::int8_t *>(p);
+  case 2:
+    return *reinterpret_cast<const std::int16_t *>(p);
+  case 4:
+    return *reinterpret_cast<const std::int32_t *>(p);
+  case 8:
+    return *reinterpret_cast<const std::int64_t *>(p);
   default:
     Terminator terminator{__FILE__, __LINE__};
     terminator.Crash("no case for %dz bytes", bytes);
@@ -39,7 +43,7 @@ OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
       resultRank >= 0 && resultRank <= static_cast<SubscriptValue>(maxRank));
 
   // Extract and check the shape of the result; compute its element count.
-  SubscriptValue lowerBound[maxRank];  // all 1's
+  SubscriptValue lowerBound[maxRank]; // all 1's
   SubscriptValue resultExtent[maxRank];
   std::size_t shapeElementBytes{shape.ElementBytes()};
   std::size_t resultElements{1};
@@ -96,7 +100,7 @@ OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
   } else {
     result = Descriptor::Create(source.type(), elementBytes, nullptr,
         resultRank, resultExtent,
-        CFI_attribute_allocatable);  // TODO rearrange these arguments
+        CFI_attribute_allocatable); // TODO rearrange these arguments
   }
   DescriptorAddendum *resultAddendum{result->Addendum()};
   RUNTIME_CHECK(terminator, resultAddendum);
@@ -141,4 +145,4 @@ OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
 
   return result;
 }
-}
+} // namespace Fortran::runtime
diff --git a/flang/runtime/transformational.h b/flang/runtime/transformational.h
index 2785614b6937..bf271fa23291 100644
--- a/flang/runtime/transformational.h
+++ b/flang/runtime/transformational.h
@@ -17,4 +17,4 @@ namespace Fortran::runtime {
 OwningPtr<Descriptor> RESHAPE(const Descriptor &source, const Descriptor &shape,
     const Descriptor *pad = nullptr, const Descriptor *order = nullptr);
 }
-#endif  // FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
+#endif // FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
diff --git a/flang/runtime/type-code.cpp b/flang/runtime/type-code.cpp
index 8b57cdb4e5a7..54b2b23089f7 100644
--- a/flang/runtime/type-code.cpp
+++ b/flang/runtime/type-code.cpp
@@ -14,27 +14,49 @@ TypeCode::TypeCode(TypeCategory f, int kind) {
   switch (f) {
   case TypeCategory::Integer:
     switch (kind) {
-    case 1: raw_ = CFI_type_int8_t; break;
-    case 2: raw_ = CFI_type_int16_t; break;
-    case 4: raw_ = CFI_type_int32_t; break;
-    case 8: raw_ = CFI_type_int64_t; break;
-    case 16: raw_ = CFI_type_int128_t; break;
+    case 1:
+      raw_ = CFI_type_int8_t;
+      break;
+    case 2:
+      raw_ = CFI_type_int16_t;
+      break;
+    case 4:
+      raw_ = CFI_type_int32_t;
+      break;
+    case 8:
+      raw_ = CFI_type_int64_t;
+      break;
+    case 16:
+      raw_ = CFI_type_int128_t;
+      break;
     }
     break;
   case TypeCategory::Real:
     switch (kind) {
-    case 4: raw_ = CFI_type_float; break;
-    case 8: raw_ = CFI_type_double; break;
+    case 4:
+      raw_ = CFI_type_float;
+      break;
+    case 8:
+      raw_ = CFI_type_double;
+      break;
     case 10:
-    case 16: raw_ = CFI_type_long_double; break;
+    case 16:
+      raw_ = CFI_type_long_double;
+      break;
     }
     break;
   case TypeCategory::Complex:
     switch (kind) {
-    case 4: raw_ = CFI_type_float_Complex; break;
-    case 8: raw_ = CFI_type_double_Complex; break;
+    case 4:
+      raw_ = CFI_type_float_Complex;
+      break;
+    case 8:
+      raw_ = CFI_type_double_Complex;
+      break;
     case 10:
-    case 16: raw_ = CFI_type_long_double_Complex; break;
+    case 16:
+      raw_ = CFI_type_long_double_Complex;
+      break;
     }
     break;
   case TypeCategory::Character:
@@ -44,13 +66,23 @@ TypeCode::TypeCode(TypeCategory f, int kind) {
     break;
   case TypeCategory::Logical:
     switch (kind) {
-    case 1: raw_ = CFI_type_Bool; break;
-    case 2: raw_ = CFI_type_int16_t; break;
-    case 4: raw_ = CFI_type_int32_t; break;
-    case 8: raw_ = CFI_type_int64_t; break;
+    case 1:
+      raw_ = CFI_type_Bool;
+      break;
+    case 2:
+      raw_ = CFI_type_int16_t;
+      break;
+    case 4:
+      raw_ = CFI_type_int32_t;
+      break;
+    case 8:
+      raw_ = CFI_type_int64_t;
+      break;
     }
     break;
-  case TypeCategory::Derived: raw_ = CFI_type_struct; break;
+  case TypeCategory::Derived:
+    raw_ = CFI_type_struct;
+    break;
   }
 }
-}
+} // namespace Fortran::runtime
diff --git a/flang/runtime/type-code.h b/flang/runtime/type-code.h
index af09be560651..104944b1a7ed 100644
--- a/flang/runtime/type-code.h
+++ b/flang/runtime/type-code.h
@@ -65,5 +65,5 @@ public:
 private:
   ISO::CFI_type_t raw_{CFI_type_other};
 };
-}
-#endif  // FORTRAN_RUNTIME_TYPE_CODE_H_
+} // namespace Fortran::runtime
+#endif // FORTRAN_RUNTIME_TYPE_CODE_H_
diff --git a/flang/runtime/unit-map.cpp b/flang/runtime/unit-map.cpp
index c505f0b0814a..4e58cf590c2a 100644
--- a/flang/runtime/unit-map.cpp
+++ b/flang/runtime/unit-map.cpp
@@ -55,7 +55,7 @@ void UnitMap::CloseAll(IoErrorHandler &handler) {
   CriticalSection critical{lock_};
   for (int j{0}; j < buckets_; ++j) {
     while (Chain * p{bucket_[j].get()}) {
-      bucket_[j].swap(p->next);  // pops p from head of list
+      bucket_[j].swap(p->next); // pops p from head of list
       p->unit.CloseUnit(CloseStatus::Keep, handler);
       p->unit.~ExternalFileUnit();
       FreeMemory(p);
@@ -66,7 +66,7 @@ void UnitMap::CloseAll(IoErrorHandler &handler) {
 ExternalFileUnit &UnitMap::Create(int n, const Terminator &terminator) {
   Chain &chain{New<Chain>{}(terminator, n)};
   chain.next.reset(&chain);
-  bucket_[Hash(n)].swap(chain.next);  // pushes new node as list head
+  bucket_[Hash(n)].swap(chain.next); // pushes new node as list head
   return chain.unit;
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/unit-map.h b/flang/runtime/unit-map.h
index 550716fc25e8..8b8afb3b4638 100644
--- a/flang/runtime/unit-map.h
+++ b/flang/runtime/unit-map.h
@@ -57,7 +57,7 @@ private:
     OwningPtr<Chain> next{nullptr};
   };
 
-  static constexpr int buckets_{1031};  // must be prime
+  static constexpr int buckets_{1031}; // must be prime
   int Hash(int n) { return n % buckets_; }
 
   ExternalFileUnit *Find(int n) {
@@ -67,8 +67,8 @@ private:
       if (p->unit.unitNumber() == n) {
         if (previous) {
           // Move found unit to front of chain for quicker lookup next time
-          previous->next.swap(p->next);  // now p->next.get() == p
-          bucket_[hash].swap(p->next);  // now bucket_[hash].get() == p
+          previous->next.swap(p->next); // now p->next.get() == p
+          bucket_[hash].swap(p->next); // now bucket_[hash].get() == p
         }
         return &p->unit;
       }
@@ -79,9 +79,9 @@ private:
   ExternalFileUnit &Create(int, const Terminator &);
 
   Lock lock_;
-  OwningPtr<Chain> bucket_[buckets_]{};  // all owned by *this
-  int nextNewUnit_{-1000};  // see 12.5.6.12 in Fortran 2018
-  OwningPtr<Chain> closing_{nullptr};  // units during CLOSE statement
+  OwningPtr<Chain> bucket_[buckets_]{}; // all owned by *this
+  int nextNewUnit_{-1000}; // see 12.5.6.12 in Fortran 2018
+  OwningPtr<Chain> closing_{nullptr}; // units during CLOSE statement
 };
-}
-#endif  // FORTRAN_RUNTIME_UNIT_MAP_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_UNIT_MAP_H_
diff --git a/flang/runtime/unit.cpp b/flang/runtime/unit.cpp
index 7c9801f23411..0661d55134f4 100644
--- a/flang/runtime/unit.cpp
+++ b/flang/runtime/unit.cpp
@@ -26,7 +26,7 @@ void FlushOutputOnCrash(const Terminator &terminator) {
   CriticalSection critical{unitMapLock};
   if (defaultOutput) {
     IoErrorHandler handler{terminator};
-    handler.HasIoStat();  // prevent nested crash if flush has error
+    handler.HasIoStat(); // prevent nested crash if flush has error
     defaultOutput->Flush(handler);
   }
 }
@@ -83,7 +83,7 @@ void ExternalFileUnit::CloseUnit(CloseStatus status, IoErrorHandler &handler) {
 }
 
 void ExternalFileUnit::DestroyClosed() {
-  GetUnitMap().DestroyClosed(*this);  // destroys *this
+  GetUnitMap().DestroyClosed(*this); // destroys *this
 }
 
 UnitMap &ExternalFileUnit::GetUnitMap() {
@@ -137,12 +137,12 @@ bool ExternalFileUnit::Emit(
 
 std::optional<char32_t> ExternalFileUnit::GetCurrentChar(
     IoErrorHandler &handler) {
-  isReading_ = true;  // TODO: manage read/write transitions
+  isReading_ = true; // TODO: manage read/write transitions
   if (isUnformatted) {
     handler.Crash("GetCurrentChar() called for unformatted input");
     return std::nullopt;
   }
-  std::size_t chunk{256};  // for stream input
+  std::size_t chunk{256}; // for stream input
   if (recordLength.has_value()) {
     if (positionInRecord >= *recordLength) {
       return std::nullopt;
@@ -190,7 +190,7 @@ bool ExternalFileUnit::AdvanceRecord(IoErrorHandler &handler) {
       }
     } else {
       positionInRecord = furthestPositionInRecord + 1;
-      ok &= Emit("\n", 1, handler);  // TODO: Windows CR+LF
+      ok &= Emit("\n", 1, handler); // TODO: Windows CR+LF
       frameOffsetInFile_ += recordOffsetInFrame_ + furthestPositionInRecord;
       recordOffsetInFrame_ = 0;
     }
@@ -240,7 +240,7 @@ void ExternalFileUnit::NextSequentialUnformattedInputRecord(
   std::int32_t header{0}, footer{0};
   // Retain previous footer (if any) in frame for more efficient BACKSPACE
   std::size_t retain{sizeof header};
-  if (recordLength) {  // not first record - advance to next
+  if (recordLength) { // not first record - advance to next
     ++currentRecordNumber;
     if (endfileRecordNumber && currentRecordNumber >= *endfileRecordNumber) {
       handler.SignalEnd();
@@ -379,7 +379,7 @@ void ExternalFileUnit::BackspaceSequentialFormattedRecord(
     ReadFrame(0, *recordLength + 1, handler);
   } else {
     RUNTIME_CHECK(handler, start > 1);
-    std::int64_t at{start - 2};  // byte before previous record's newline
+    std::int64_t at{start - 2}; // byte before previous record's newline
     while (true) {
       if (const char *p{
               FindLastNewline(Frame(), at - frameOffsetInFile_ + 1)}) {
@@ -410,4 +410,4 @@ void ExternalFileUnit::BackspaceSequentialFormattedRecord(
     --*recordLength;
   }
 }
-}
+} // namespace Fortran::runtime::io
diff --git a/flang/runtime/unit.h b/flang/runtime/unit.h
index b32c2cde74db..cb40ddebacc5 100644
--- a/flang/runtime/unit.h
+++ b/flang/runtime/unit.h
@@ -49,10 +49,10 @@ public:
   void CloseUnit(CloseStatus, IoErrorHandler &);
   void DestroyClosed();
 
-  template<typename A, typename... X>
+  template <typename A, typename... X>
   IoStatementState &BeginIoStatement(X &&... xs) {
     // TODO: Child data transfer statements vs. locking
-    lock_.Take();  // dropped in EndIoStatement()
+    lock_.Take(); // dropped in EndIoStatement()
     A &state{u_.emplace<A>(std::forward<X>(xs)...)};
     if constexpr (!std::is_same_v<A, OpenStatementState>) {
       state.mutableModes() = ConnectionState::modes;
@@ -102,8 +102,8 @@ private:
   // during a single list-directed READ due to the possibility of a
   // multi-record CHARACTER value with a "r*" repeat count.
   std::int64_t frameOffsetInFile_{0};
-  std::int64_t recordOffsetInFrame_{0};  // of currentRecordNumber
+  std::int64_t recordOffsetInFrame_{0}; // of currentRecordNumber
 };
 
-}
-#endif  // FORTRAN_RUNTIME_IO_UNIT_H_
+} // namespace Fortran::runtime::io
+#endif // FORTRAN_RUNTIME_IO_UNIT_H_
diff --git a/flang/tools/f18-parse-demo/f18-parse-demo.cpp b/flang/tools/f18-parse-demo/f18-parse-demo.cpp
index ebb35615263d..fd577e2fd350 100644
--- a/flang/tools/f18-parse-demo/f18-parse-demo.cpp
+++ b/flang/tools/f18-parse-demo/f18-parse-demo.cpp
@@ -80,13 +80,13 @@ double CPUseconds() { return 0; }
 
 struct DriverOptions {
   DriverOptions() {}
-  bool verbose{false};  // -v
-  bool compileOnly{false};  // -c
-  std::string outputPath;  // -o path
-  std::vector<std::string> searchDirectories{"."s};  // -I dir
-  bool forcedForm{false};  // -Mfixed or -Mfree appeared
-  bool warnOnNonstandardUsage{false};  // -Mstandard
-  bool warningsAreErrors{false};  // -Werror
+  bool verbose{false}; // -v
+  bool compileOnly{false}; // -c
+  std::string outputPath; // -o path
+  std::vector<std::string> searchDirectories{"."s}; // -I dir
+  bool forcedForm{false}; // -Mfixed or -Mfree appeared
+  bool warnOnNonstandardUsage{false}; // -Mstandard
+  bool warningsAreErrors{false}; // -Werror
   Fortran::parser::Encoding encoding{Fortran::parser::Encoding::LATIN_1};
   bool parseOnly{false};
   bool dumpProvenance{false};
@@ -100,7 +100,7 @@ struct DriverOptions {
 
 bool ParentProcess() {
   if (fork() == 0) {
-    return false;  // in child process
+    return false; // in child process
   }
   int childStat{0};
   wait(&childStat);
@@ -451,7 +451,7 @@ int main(int argc, char *const argv[]) {
   }
   if (!options.features.IsEnabled(
           Fortran::common::LanguageFeature::BackslashEscapes)) {
-    driver.fcArgs.push_back("-fno-backslash");  // PGI "-Mbackslash"
+    driver.fcArgs.push_back("-fno-backslash"); // PGI "-Mbackslash"
   }
 
   if (!anyFiles) {
diff --git a/flang/tools/f18-parse-demo/stub-evaluate.cpp b/flang/tools/f18-parse-demo/stub-evaluate.cpp
index dbaa13a338d9..d673eca5fa50 100644
--- a/flang/tools/f18-parse-demo/stub-evaluate.cpp
+++ b/flang/tools/f18-parse-demo/stub-evaluate.cpp
@@ -26,7 +26,7 @@ struct ProcedureRef {
   ~ProcedureRef();
 };
 ProcedureRef::~ProcedureRef() {}
-}
+} // namespace Fortran::evaluate
 
 DEFINE_DELETER(Fortran::evaluate::GenericExprWrapper)
 DEFINE_DELETER(Fortran::evaluate::GenericAssignmentWrapper)
diff --git a/flang/tools/f18/dump.cpp b/flang/tools/f18/dump.cpp
index d04b8e094a23..f11b5aedf4c6 100644
--- a/flang/tools/f18/dump.cpp
+++ b/flang/tools/f18/dump.cpp
@@ -37,6 +37,6 @@ DEFINE_DUMP(semantics, Scope)
 DEFINE_DUMP(semantics, IntrinsicTypeSpec)
 DEFINE_DUMP(semantics, DerivedTypeSpec)
 DEFINE_DUMP(semantics, DeclTypeSpec)
-}
+} // namespace Fortran
 
 #endif
diff --git a/flang/tools/f18/f18.cpp b/flang/tools/f18/f18.cpp
index 51d3aec3d118..5538c9fc3e9a 100644
--- a/flang/tools/f18/f18.cpp
+++ b/flang/tools/f18/f18.cpp
@@ -47,8 +47,8 @@ static std::list<std::string> argList(int argc, char *const argv[]) {
 }
 
 struct MeasurementVisitor {
-  template<typename A> bool Pre(const A &) { return true; }
-  template<typename A> void Post(const A &) {
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {
     ++objects;
     bytes += sizeof(A);
   }
@@ -79,15 +79,15 @@ struct GetDefinitionArgs {
 
 struct DriverOptions {
   DriverOptions() {}
-  bool verbose{false};  // -v
-  bool compileOnly{false};  // -c
-  std::string outputPath;  // -o path
-  std::vector<std::string> searchDirectories{"."s};  // -I dir
-  std::string moduleDirectory{"."s};  // -module dir
-  std::string moduleFileSuffix{".mod"};  // -moduleSuffix suff
-  bool forcedForm{false};  // -Mfixed or -Mfree appeared
-  bool warnOnNonstandardUsage{false};  // -Mstandard
-  bool warningsAreErrors{false};  // -Werror
+  bool verbose{false}; // -v
+  bool compileOnly{false}; // -c
+  std::string outputPath; // -o path
+  std::vector<std::string> searchDirectories{"."s}; // -I dir
+  std::string moduleDirectory{"."s}; // -module dir
+  std::string moduleFileSuffix{".mod"}; // -moduleSuffix suff
+  bool forcedForm{false}; // -Mfixed or -Mfree appeared
+  bool warnOnNonstandardUsage{false}; // -Mstandard
+  bool warningsAreErrors{false}; // -Werror
   Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
   bool parseOnly{false};
   bool dumpProvenance{false};
@@ -111,7 +111,7 @@ struct DriverOptions {
 
 bool ParentProcess() {
   if (fork() == 0) {
-    return false;  // in child process
+    return false; // in child process
   }
   int childStat{0};
   wait(&childStat);
@@ -640,7 +640,7 @@ int main(int argc, char *const argv[]) {
     if (!options.features.IsEnabled(
             Fortran::common::LanguageFeature::BackslashEscapes)) {
       driver.pgf90Args.push_back(
-          "-Mbackslash");  // yes, this *disables* them in pgf90
+          "-Mbackslash"); // yes, this *disables* them in pgf90
     }
     Fortran::parser::useHexadecimalEscapeSequences = false;
   } else {
diff --git a/flang/unittests/Decimal/thorough-test.cpp b/flang/unittests/Decimal/thorough-test.cpp
index e7aeed01ec8e..f8416bffa719 100644
--- a/flang/unittests/Decimal/thorough-test.cpp
+++ b/flang/unittests/Decimal/thorough-test.cpp
@@ -4,7 +4,7 @@
 #include <cstdio>
 #include <cstring>
 
-static constexpr int incr{1};  // steps through all values
+static constexpr int incr{1}; // steps through all values
 static constexpr bool doNegative{true};
 static constexpr bool doMinimize{true};
 
diff --git a/flang/unittests/Evaluate/ISO-Fortran-binding.cpp b/flang/unittests/Evaluate/ISO-Fortran-binding.cpp
index 1fff9d4d1998..da9ea3521388 100644
--- a/flang/unittests/Evaluate/ISO-Fortran-binding.cpp
+++ b/flang/unittests/Evaluate/ISO-Fortran-binding.cpp
@@ -8,7 +8,7 @@ using namespace Fortran::runtime;
 using namespace Fortran::ISO;
 
 // CFI_CDESC_T test helpers
-template<int rank> class Test_CFI_CDESC_T {
+template <int rank> class Test_CFI_CDESC_T {
 public:
   Test_CFI_CDESC_T() {}
   ~Test_CFI_CDESC_T() {}
@@ -22,7 +22,7 @@ public:
     // suitable in size
     if (rank > 0) {
       MATCH(sizeof(dvStorage_), Descriptor::SizeInBytes(rank_, false));
-    } else {  // C++ implementation over-allocates for rank=0 by 24bytes.
+    } else { // C++ implementation over-allocates for rank=0 by 24bytes.
       MATCH(true, sizeof(dvStorage_) >= Descriptor::SizeInBytes(rank_, false));
     }
     // suitable in alignment
@@ -36,14 +36,14 @@ private:
   CFI_CDESC_T(rank) dvStorage_;
 };
 
-template<int rank> static void TestCdescMacroForAllRanksSmallerThan() {
+template <int rank> static void TestCdescMacroForAllRanksSmallerThan() {
   static_assert(rank > 0, "rank<0!");
   Test_CFI_CDESC_T<rank> obj;
   obj.Check();
   TestCdescMacroForAllRanksSmallerThan<rank - 1>();
 }
 
-template<> void TestCdescMacroForAllRanksSmallerThan<0>() {
+template <> void TestCdescMacroForAllRanksSmallerThan<0>() {
   Test_CFI_CDESC_T<0> obj;
   obj.Check();
 }
@@ -191,11 +191,11 @@ static void run_CFI_establish_tests() {
   const int rank3d{3};
   CFI_CDESC_T(rank3d) dv3darrayStorage;
   CFI_cdesc_t *dv_3darray{&dv3darrayStorage};
-  AddNoiseToCdesc(dv_3darray, rank3d);  // => dv_3darray->dim[2].extent = -42
+  AddNoiseToCdesc(dv_3darray, rank3d); // => dv_3darray->dim[2].extent = -42
   check_CFI_establish(dv_3darray, nullptr, CFI_attribute_other, CFI_type_int, 4,
       rank3d, extents);
   MATCH(false,
-      dv_3darray->dim[2].extent == 2 + 66);  // extents was read
+      dv_3darray->dim[2].extent == 2 + 66); // extents was read
 }
 
 static void check_CFI_address(
@@ -412,13 +412,13 @@ static void run_CFI_section_tests() {
   bool testPreConditions{true};
   constexpr CFI_index_t m{5}, n{6}, o{7};
   constexpr CFI_rank_t rank{3};
-  long long array[o][n][m];  // Fortran A(m,n,o)
+  long long array[o][n][m]; // Fortran A(m,n,o)
   long long counter{1};
 
   for (CFI_index_t k{0}; k < o; ++k) {
     for (CFI_index_t j{0}; j < n; ++j) {
       for (CFI_index_t i{0}; i < m; ++i) {
-        array[k][j][i] = counter++;  // Fortran A(i,j,k)
+        array[k][j][i] = counter++; // Fortran A(i,j,k)
       }
     }
   }
@@ -446,7 +446,7 @@ static void run_CFI_section_tests() {
   }
 
   retCode = CFI_section(
-      result, source, lb, ub, strides);  // Fortran B = A(2:4:2, 5:5:0, 4:6:2)
+      result, source, lb, ub, strides); // Fortran B = A(2:4:2, 5:5:0, 4:6:2)
   MATCH(true, retCode == CFI_SUCCESS);
 
   const CFI_index_t lbs0{source->dim[0].lower_bound};
@@ -477,7 +477,7 @@ static void run_CFI_section_tests() {
   lb[0] = 4;
   ub[0] = 2;
   retCode = CFI_section(
-      result, source, lb, ub, strides);  // Fortran B = A(4:2:-1, 5:5:0, 4:6:2)
+      result, source, lb, ub, strides); // Fortran B = A(4:2:-1, 5:5:0, 4:6:2)
   MATCH(true, retCode == CFI_SUCCESS);
 
   resJ = result->dim[1].lower_bound;
@@ -540,7 +540,7 @@ static void run_CFI_select_part_tests() {
   }
 
   std::size_t displacement{offsetof(Galaxy, stars)};
-  std::size_t elem_len{0};  // ignored
+  std::size_t elem_len{0}; // ignored
   retCode = CFI_select_part(result, source, displacement, elem_len);
   MATCH(CFI_SUCCESS, retCode);
 
@@ -572,7 +572,7 @@ static void run_CFI_select_part_tests() {
   }
 
   displacement = offsetof(Galaxy, name) + 2;
-  elem_len = 2;  // not ignored this time
+  elem_len = 2; // not ignored this time
   retCode = CFI_select_part(result, source, displacement, elem_len);
   MATCH(CFI_SUCCESS, retCode);
 
diff --git a/flang/unittests/Evaluate/folding.cpp b/flang/unittests/Evaluate/folding.cpp
index 450f87ac2622..ec98c9846786 100644
--- a/flang/unittests/Evaluate/folding.cpp
+++ b/flang/unittests/Evaluate/folding.cpp
@@ -11,15 +11,15 @@
 using namespace Fortran::evaluate;
 
 // helper to call functions on all types from tuple
-template<typename... T> struct RunOnTypes {};
-template<typename Test, typename... T>
+template <typename... T> struct RunOnTypes {};
+template <typename Test, typename... T>
 struct RunOnTypes<Test, std::tuple<T...>> {
   static void Run() { (..., Test::template Run<T>()); }
 };
 
 // test for fold.h GetScalarConstantValue function
 struct TestGetScalarConstantValue {
-  template<typename T> static void Run() {
+  template <typename T> static void Run() {
     Expr<T> exprFullyTyped{Constant<T>{Scalar<T>{}}};
     Expr<SomeKind<T::category>> exprSomeKind{exprFullyTyped};
     Expr<SomeType> exprSomeType{exprSomeKind};
@@ -29,7 +29,7 @@ struct TestGetScalarConstantValue {
   }
 };
 
-template<typename T>
+template <typename T>
 static FunctionRef<T> CreateIntrinsicElementalCall(
     const std::string &name, const Expr<T> &arg) {
   Fortran::semantics::Attrs attrs;
@@ -45,12 +45,12 @@ static FunctionRef<T> CreateIntrinsicElementalCall(
 // HostFloatingPointEnvironment::SetUpHostFloatingPointEnvironment
 
 // Dummy host runtime functions where subnormal flushing matters
-float SubnormalFlusher1(float f) {  // given f is subnormal
-  return 2.3 * f;  // returns 0 if subnormal arguments are flushed to zero
+float SubnormalFlusher1(float f) { // given f is subnormal
+  return 2.3 * f; // returns 0 if subnormal arguments are flushed to zero
 }
 
-float SubnormalFlusher2(float f) {  // given f/2 is subnormal
-  return f / 2.3;  // returns 0 if subnormal
+float SubnormalFlusher2(float f) { // given f/2 is subnormal
+  return f / 2.3; // returns 0 if subnormal
 }
 
 void TestHostRuntimeSubnormalFlushing() {
@@ -98,7 +98,7 @@ void TestHostRuntimeSubnormalFlushing() {
       TEST(false);
     }
   } else {
-    TEST(false);  // Cannot run this test on the host
+    TEST(false); // Cannot run this test on the host
   }
 }
 
diff --git a/flang/unittests/Evaluate/fp-testing.cpp b/flang/unittests/Evaluate/fp-testing.cpp
index fe235eca7924..66ab7b274a82 100644
--- a/flang/unittests/Evaluate/fp-testing.cpp
+++ b/flang/unittests/Evaluate/fp-testing.cpp
@@ -83,10 +83,18 @@ RealFlags ScopedHostFloatingPointEnvironment::CurrentFlags() {
 
 void ScopedHostFloatingPointEnvironment::SetRounding(Rounding rounding) {
   switch (rounding.mode) {
-  case RoundingMode::TiesToEven: fesetround(FE_TONEAREST); break;
-  case RoundingMode::ToZero: fesetround(FE_TOWARDZERO); break;
-  case RoundingMode::Up: fesetround(FE_UPWARD); break;
-  case RoundingMode::Down: fesetround(FE_DOWNWARD); break;
+  case RoundingMode::TiesToEven:
+    fesetround(FE_TONEAREST);
+    break;
+  case RoundingMode::ToZero:
+    fesetround(FE_TOWARDZERO);
+    break;
+  case RoundingMode::Up:
+    fesetround(FE_UPWARD);
+    break;
+  case RoundingMode::Down:
+    fesetround(FE_DOWNWARD);
+    break;
   case RoundingMode::TiesAwayFromZero:
     std::fprintf(stderr, "SetRounding: TiesAwayFromZero not available");
     std::abort();
diff --git a/flang/unittests/Evaluate/fp-testing.h b/flang/unittests/Evaluate/fp-testing.h
index 9e10561fd9e4..760e976c4c96 100644
--- a/flang/unittests/Evaluate/fp-testing.h
+++ b/flang/unittests/Evaluate/fp-testing.h
@@ -22,4 +22,4 @@ private:
   fenv_t currentFenv_;
 };
 
-#endif  // FORTRAN_TEST_EVALUATE_FP_TESTING_H_
+#endif // FORTRAN_TEST_EVALUATE_FP_TESTING_H_
diff --git a/flang/unittests/Evaluate/integer.cpp b/flang/unittests/Evaluate/integer.cpp
index a6111848ab9b..3eabb2434cce 100644
--- a/flang/unittests/Evaluate/integer.cpp
+++ b/flang/unittests/Evaluate/integer.cpp
@@ -6,7 +6,7 @@
 using Fortran::evaluate::Ordering;
 using Fortran::evaluate::value::Integer;
 
-template<int BITS, typename INT = Integer<BITS>> void exhaustiveTesting() {
+template <int BITS, typename INT = Integer<BITS>> void exhaustiveTesting() {
   std::uint64_t maxUnsignedValue{(std::uint64_t{1} << BITS) - 1};
   std::int64_t maxPositiveSignedValue{(std::int64_t{1} << (BITS - 1)) - 1};
   std::int64_t mostNegativeSignedValue{-(std::int64_t{1} << (BITS - 1))};
diff --git a/flang/unittests/Evaluate/intrinsics.cpp b/flang/unittests/Evaluate/intrinsics.cpp
index e2bf1cf18cb0..7123ef63b63d 100644
--- a/flang/unittests/Evaluate/intrinsics.cpp
+++ b/flang/unittests/Evaluate/intrinsics.cpp
@@ -41,35 +41,35 @@ private:
   std::map<std::string, std::size_t> offsets_;
 };
 
-template<typename A> auto Const(A &&x) -> Constant<TypeOf<A>> {
+template <typename A> auto Const(A &&x) -> Constant<TypeOf<A>> {
   return Constant<TypeOf<A>>{std::move(x)};
 }
 
-template<typename A> struct NamedArg {
+template <typename A> struct NamedArg {
   std::string keyword;
   A value;
 };
 
-template<typename A> static NamedArg<A> Named(std::string kw, A &&x) {
+template <typename A> static NamedArg<A> Named(std::string kw, A &&x) {
   return {kw, std::move(x)};
 }
 
 struct TestCall {
   TestCall(const common::IntrinsicTypeDefaultKinds &d,
       const IntrinsicProcTable &t, std::string n)
-    : defaults{d}, table{t}, name{n} {}
-  template<typename A> TestCall &Push(A &&x) {
+      : defaults{d}, table{t}, name{n} {}
+  template <typename A> TestCall &Push(A &&x) {
     args.emplace_back(AsGenericExpr(std::move(x)));
     keywords.push_back("");
     return *this;
   }
-  template<typename A> TestCall &Push(NamedArg<A> &&x) {
+  template <typename A> TestCall &Push(NamedArg<A> &&x) {
     args.emplace_back(AsGenericExpr(std::move(x.value)));
     keywords.push_back(x.keyword);
     strings.Save(x.keyword);
     return *this;
   }
-  template<typename A, typename... As> TestCall &Push(A &&x, As &&... xs) {
+  template <typename A, typename... As> TestCall &Push(A &&x, As &&... xs) {
     Push(std::move(x));
     return Push(std::move(xs)...);
   }
@@ -158,7 +158,7 @@ void TestIntrinsics() {
 
   TestCall{defaults, table, "bad"}
       .Push(Const(Scalar<Int4>{}))
-      .DoCall();  // bad intrinsic name
+      .DoCall(); // bad intrinsic name
   TestCall{defaults, table, "abs"}
       .Push(Named("a", Const(Scalar<Int4>{})))
       .DoCall(Int4::GetType());
@@ -167,12 +167,12 @@ void TestIntrinsics() {
       .DoCall(Int4::GetType());
   TestCall{defaults, table, "abs"}
       .Push(Named("bad", Const(Scalar<Int4>{})))
-      .DoCall();  // bad keyword
-  TestCall{defaults, table, "abs"}.DoCall();  // insufficient args
+      .DoCall(); // bad keyword
+  TestCall{defaults, table, "abs"}.DoCall(); // insufficient args
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int4>{}))
       .Push(Const(Scalar<Int4>{}))
-      .DoCall();  // too many args
+      .DoCall(); // too many args
   TestCall{defaults, table, "abs"}
       .Push(Const(Scalar<Int4>{}))
       .Push(Named("a", Const(Scalar<Int4>{})))
@@ -259,7 +259,7 @@ void TestIntrinsics() {
       .DoCall(Int4::GetType());
   // TODO: test other intrinsics
 }
-}
+} // namespace Fortran::evaluate
 
 int main() {
   Fortran::evaluate::TestIntrinsics();
diff --git a/flang/unittests/Evaluate/logical.cpp b/flang/unittests/Evaluate/logical.cpp
index f2d171718093..d79aff844871 100644
--- a/flang/unittests/Evaluate/logical.cpp
+++ b/flang/unittests/Evaluate/logical.cpp
@@ -2,7 +2,7 @@
 #include "flang/Evaluate/type.h"
 #include <cstdio>
 
-template<int KIND> void testKind() {
+template <int KIND> void testKind() {
   using Type =
       Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, KIND>;
   TEST(Fortran::evaluate::IsSpecificIntrinsicType<Type>);
diff --git a/flang/unittests/Evaluate/real.cpp b/flang/unittests/Evaluate/real.cpp
index 90f9dcf408c2..d4c7ce5fb1aa 100644
--- a/flang/unittests/Evaluate/real.cpp
+++ b/flang/unittests/Evaluate/real.cpp
@@ -45,7 +45,7 @@ void dumpTest() {
   }
 }
 
-template<typename R> void basicTests(int rm, Rounding rounding) {
+template <typename R> void basicTests(int rm, Rounding rounding) {
   static constexpr int kind{R::bits / 8};
   char desc[64];
   using Word = typename R::Word;
@@ -148,7 +148,7 @@ template<typename R> void basicTests(int rm, Rounding rounding) {
       TEST(!vr.value.IsInfinite())(ldesc);
       TEST(ivf.flags.empty())(ldesc);
       MATCH(x, ivf.value.ToUInt64())(ldesc);
-      if (rounding.mode == RoundingMode::TiesToEven) {  // to match stold()
+      if (rounding.mode == RoundingMode::TiesToEven) { // to match stold()
         std::string buf;
         llvm::raw_string_ostream ss{buf};
         vr.value.AsFortran(ss, kind, false /*exact*/);
@@ -284,9 +284,9 @@ inline std::uint32_t FlagsToBits(const RealFlags &flags) {
   }
   return bits;
 }
-#endif  // __clang__
+#endif // __clang__
 
-template<typename UINT = std::uint32_t, typename FLT = float, typename REAL>
+template <typename UINT = std::uint32_t, typename FLT = float, typename REAL>
 void inttest(std::int64_t x, int pass, Rounding rounding) {
   union {
     UINT ui;
@@ -296,10 +296,10 @@ void inttest(std::int64_t x, int pass, Rounding rounding) {
   Integer8 ix{x};
   ValueWithRealFlags<REAL> real;
   real = real.value.FromInteger(ix, rounding);
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
   fpenv.ClearFlags();
 #endif
-  FLT fcheck = x;  // TODO unsigned too
+  FLT fcheck = x; // TODO unsigned too
   auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
   u.f = fcheck;
   UINT rcheck{NormalizeNaN(u.ui)};
@@ -308,7 +308,7 @@ void inttest(std::int64_t x, int pass, Rounding rounding) {
   MATCH(actualFlags, FlagsToBits(real.flags))("%d 0x%llx", pass, x);
 }
 
-template<typename FLT = float> FLT ToIntPower(FLT x, int power) {
+template <typename FLT = float> FLT ToIntPower(FLT x, int power) {
   if (power == 0) {
     return x / x;
   }
@@ -330,7 +330,7 @@ template<typename FLT = float> FLT ToIntPower(FLT x, int power) {
   return result;
 }
 
-template<typename FLT, int decimalDigits>
+template <typename FLT, int decimalDigits>
 FLT TimesIntPowerOfTen(FLT x, int power) {
   if (power > decimalDigits || power < -decimalDigits) {
     auto maxExactPowerOfTen{
@@ -343,7 +343,7 @@ FLT TimesIntPowerOfTen(FLT x, int power) {
   return x * ToIntPower<FLT>(10.0, power);
 }
 
-template<typename UINT = std::uint32_t, typename FLT = float,
+template <typename UINT = std::uint32_t, typename FLT = float,
     typename REAL = Real4>
 void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
   for (int j{0}; j < 63; ++j) {
@@ -372,16 +372,16 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
     // unary operations
     {
       ValueWithRealFlags<REAL> aint{x.ToWholeNumber()};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
       fpenv.ClearFlags();
 #endif
       FLT fcheck{std::trunc(fj)};
       auto actualFlags{FlagsToBits(fpenv.CurrentFlags())};
-      actualFlags &= ~Inexact;  // x86 std::trunc can set Inexact; AINT ain't
+      actualFlags &= ~Inexact; // x86 std::trunc can set Inexact; AINT ain't
       u.f = fcheck;
 #ifndef __clang__
       if (IsNaN(u.ui)) {
-        actualFlags |= InvalidArgument;  // x86 std::trunc(NaN) workaround
+        actualFlags |= InvalidArgument; // x86 std::trunc(NaN) workaround
       }
 #endif
       UINT rcheck{NormalizeNaN(u.ui)};
@@ -440,7 +440,7 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       REAL y{typename REAL::Word{std::uint64_t{rk}}};
       {
         ValueWithRealFlags<REAL> sum{x.Add(y, rounding)};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
         fpenv.ClearFlags();
 #endif
         FLT fcheck{fj + fk};
@@ -457,7 +457,7 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       }
       {
         ValueWithRealFlags<REAL> diff{x.Subtract(y, rounding)};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
         fpenv.ClearFlags();
 #endif
         FLT fcheck{fj - fk};
@@ -474,7 +474,7 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       }
       {
         ValueWithRealFlags<REAL> prod{x.Multiply(y, rounding)};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
         fpenv.ClearFlags();
 #endif
         FLT fcheck{fj * fk};
@@ -491,7 +491,7 @@ void subsetTests(int pass, Rounding rounding, std::uint32_t opds) {
       }
       {
         ValueWithRealFlags<REAL> quot{x.Divide(y, rounding)};
-#ifndef __clang__  // broken and also slow
+#ifndef __clang__ // broken and also slow
         fpenv.ClearFlags();
 #endif
         FLT fcheck{fj / fk};
@@ -524,7 +524,7 @@ void roundTest(int rm, Rounding rounding, std::uint32_t opds) {
 
 int main() {
   dumpTest();
-  std::uint32_t opds{512};  // for quick testing by default
+  std::uint32_t opds{512}; // for quick testing by default
   if (const char *p{std::getenv("REAL_TEST_OPERANDS")}) {
     // Use 8192 or 16384 for more exhaustive testing.
     opds = std::atol(p);
diff --git a/flang/unittests/Evaluate/testing.cpp b/flang/unittests/Evaluate/testing.cpp
index 9be31540ec7b..b2f73bf1b265 100644
--- a/flang/unittests/Evaluate/testing.cpp
+++ b/flang/unittests/Evaluate/testing.cpp
@@ -9,7 +9,7 @@ namespace testing {
 namespace {
 int passes{0};
 int failures{0};
-}
+} // namespace
 
 static void BitBucket(const char *, ...) {}
 
@@ -124,4 +124,4 @@ int Complete() {
     return EXIT_FAILURE;
   }
 }
-}
+} // namespace testing
diff --git a/flang/unittests/Evaluate/testing.h b/flang/unittests/Evaluate/testing.h
index 639a698d72d5..422e2853c05b 100644
--- a/flang/unittests/Evaluate/testing.h
+++ b/flang/unittests/Evaluate/testing.h
@@ -32,5 +32,5 @@ FailureDetailPrinter Match(const char *file, int line, const std::string &want,
     const char *gots, const std::string &got);
 FailureDetailPrinter Compare(const char *file, int line, const char *xs,
     const char *rel, const char *ys, std::uint64_t x, std::uint64_t y);
-}
-#endif  // FORTRAN_EVALUATE_TESTING_H_
+} // namespace testing
+#endif // FORTRAN_EVALUATE_TESTING_H_
diff --git a/flang/unittests/Evaluate/uint128.cpp b/flang/unittests/Evaluate/uint128.cpp
index f2ddcbf557eb..f05c1c96a7e8 100644
--- a/flang/unittests/Evaluate/uint128.cpp
+++ b/flang/unittests/Evaluate/uint128.cpp
@@ -106,7 +106,7 @@ static void TestVsNative() {
       TestVsNative(m ^ ~n, m ^ n);
       TestVsNative(m ^ n, ~m ^ n);
       TestVsNative(m ^ ~n, ~m ^ n);
-      Test(m, 10000000000000000);  // important case for decimal conversion
+      Test(m, 10000000000000000); // important case for decimal conversion
       Test(~m, 10000000000000000);
     }
   }
diff --git a/flang/unittests/Runtime/hello.cpp b/flang/unittests/Runtime/hello.cpp
index cc2d1205a751..64ed2cbaba72 100644
--- a/flang/unittests/Runtime/hello.cpp
+++ b/flang/unittests/Runtime/hello.cpp
@@ -175,13 +175,13 @@ int main() {
     double d;
     std::uint64_t n;
   } u;
-  u.n = 0x8000000000000000;  // -0
+  u.n = 0x8000000000000000; // -0
   realTest("(E9.1,';')", u.d, " -0.0E+00;");
   realTest("(F4.0,';')", u.d, " -0.;");
   realTest("(G8.0,';')", u.d, "-0.0E+00;");
   realTest("(G8.1,';')", u.d, " -0.    ;");
   realTest("(G0,';')", u.d, "-0.;");
-  u.n = 0x7ff0000000000000;  // +Inf
+  u.n = 0x7ff0000000000000; // +Inf
   realTest("(E9.1,';')", u.d, "      Inf;");
   realTest("(F9.1,';')", u.d, "      Inf;");
   realTest("(G9.1,';')", u.d, "      Inf;");
@@ -189,17 +189,17 @@ int main() {
   realTest("(SP,F9.1,';')", u.d, "     +Inf;");
   realTest("(SP,G9.1,';')", u.d, "     +Inf;");
   realTest("(G0,';')", u.d, "Inf;");
-  u.n = 0xfff0000000000000;  // -Inf
+  u.n = 0xfff0000000000000; // -Inf
   realTest("(E9.1,';')", u.d, "     -Inf;");
   realTest("(F9.1,';')", u.d, "     -Inf;");
   realTest("(G9.1,';')", u.d, "     -Inf;");
   realTest("(G0,';')", u.d, "-Inf;");
-  u.n = 0x7ff0000000000001;  // NaN
+  u.n = 0x7ff0000000000001; // NaN
   realTest("(E9.1,';')", u.d, "      NaN;");
   realTest("(F9.1,';')", u.d, "      NaN;");
   realTest("(G9.1,';')", u.d, "      NaN;");
   realTest("(G0,';')", u.d, "NaN;");
-  u.n = 0xfff0000000000001;  // NaN (sign irrelevant)
+  u.n = 0xfff0000000000001; // NaN (sign irrelevant)
   realTest("(E9.1,';')", u.d, "      NaN;");
   realTest("(F9.1,';')", u.d, "      NaN;");
   realTest("(G9.1,';')", u.d, "      NaN;");
@@ -208,7 +208,7 @@ int main() {
   realTest("(SP,G9.1,';')", u.d, "      NaN;");
   realTest("(G0,';')", u.d, "NaN;");
 
-  u.n = 0x3fb999999999999a;  // 0.1 rounded
+  u.n = 0x3fb999999999999a; // 0.1 rounded
   realTest("(E62.55,';')", u.d,
       " 0.1000000000000000055511151231257827021181583404541015625E+00;");
   realTest("(E0.0,';')", u.d, "0.E+00;");
@@ -228,7 +228,7 @@ int main() {
       ".1000000000000000055511151231257827021181583404541015625;");
   realTest("(G0,';')", u.d, ".1;");
 
-  u.n = 0x3ff8000000000000;  // 1.5
+  u.n = 0x3ff8000000000000; // 1.5
   realTest("(E9.2,';')", u.d, " 0.15E+01;");
   realTest("(F4.1,';')", u.d, " 1.5;");
   realTest("(G7.1,';')", u.d, " 2.    ;");
@@ -254,7 +254,7 @@ int main() {
 
   // TODO continue F and G editing tests on these data
 
-  u.n = 0xbff8000000000000;  // -1.5
+  u.n = 0xbff8000000000000; // -1.5
   realTest("(E9.2,';')", u.d, "-0.15E+01;");
   realTest("(RN,E8.1,';')", u.d, "-0.2E+01;");
   realTest("(RD,E8.1,';')", u.d, "-0.2E+01;");
@@ -262,7 +262,7 @@ int main() {
   realTest("(RZ,E8.1,';')", u.d, "-0.1E+01;");
   realTest("(RC,E8.1,';')", u.d, "-0.2E+01;");
 
-  u.n = 0x4004000000000000;  // 2.5
+  u.n = 0x4004000000000000; // 2.5
   realTest("(E9.2,';')", u.d, " 0.25E+01;");
   realTest("(RN,E8.1,';')", u.d, " 0.2E+01;");
   realTest("(RD,E8.1,';')", u.d, " 0.2E+01;");
@@ -270,7 +270,7 @@ int main() {
   realTest("(RZ,E8.1,';')", u.d, " 0.2E+01;");
   realTest("(RC,E8.1,';')", u.d, " 0.3E+01;");
 
-  u.n = 0xc004000000000000;  // -2.5
+  u.n = 0xc004000000000000; // -2.5
   realTest("(E9.2,';')", u.d, "-0.25E+01;");
   realTest("(RN,E8.1,';')", u.d, "-0.2E+01;");
   realTest("(RD,E8.1,';')", u.d, "-0.3E+01;");
@@ -278,7 +278,7 @@ int main() {
   realTest("(RZ,E8.1,';')", u.d, "-0.2E+01;");
   realTest("(RC,E8.1,';')", u.d, "-0.3E+01;");
 
-  u.n = 1;  // least positive nonzero subnormal
+  u.n = 1; // least positive nonzero subnormal
   realTest("(E32.17,';')", u.d, "         0.49406564584124654-323;");
   realTest("(ES32.17,';')", u.d, "         4.94065645841246544-324;");
   realTest("(EN32.17,';')", u.d, "         4.94065645841246544-324;");
@@ -362,7 +362,7 @@ int main() {
       "273816725095583738973359899366480994116420570263709027924276754456522908"
       "753868250641971826553344726563-323;");
 
-  u.n = 0x10000000000000;  // least positive nonzero normal
+  u.n = 0x10000000000000; // least positive nonzero normal
   realTest("(E723.716,';')", u.d,
       " 0."
       "222507385850720138309023271733240406421921598046233183055332741688720443"
@@ -378,7 +378,7 @@ int main() {
       "307;");
   realTest("(G0,';')", u.d, ".22250738585072014-307;");
 
-  u.n = 0x7fefffffffffffffuLL;  // greatest finite
+  u.n = 0x7fefffffffffffffuLL; // greatest finite
   realTest("(E32.17,';')", u.d, "         0.17976931348623157+309;");
   realTest("(E317.310,';')", u.d,
       " 0."
@@ -415,9 +415,9 @@ int main() {
   realInTest("(F18.1)", "               125", 0x4029000000000000);
   realInTest("(F18.2)", "               125", 0x3ff4000000000000);
   realInTest("(F18.3)", "               125", 0x3fc0000000000000);
-  realInTest("(-1P,F18.0)", "               125", 0x4093880000000000);  // 1250
-  realInTest("(1P,F18.0)", "               125", 0x4029000000000000);  // 12.5
-  realInTest("(BZ,F18.0)", "              125 ", 0x4093880000000000);  // 1250
+  realInTest("(-1P,F18.0)", "               125", 0x4093880000000000); // 1250
+  realInTest("(1P,F18.0)", "               125", 0x4029000000000000); // 12.5
+  realInTest("(BZ,F18.0)", "              125 ", 0x4093880000000000); // 1250
   realInTest("(DC,F18.0)", "              12,5", 0x4029000000000000);
 
   return EndTests();
diff --git a/flang/unittests/Runtime/testing.h b/flang/unittests/Runtime/testing.h
index 4bc2b9148a0a..943b6fd8d915 100644
--- a/flang/unittests/Runtime/testing.h
+++ b/flang/unittests/Runtime/testing.h
@@ -5,7 +5,7 @@
 #include <iosfwd>
 
 namespace llvm {
- class raw_ostream;
+class raw_ostream;
 }
 
 void StartTests();
@@ -14,4 +14,4 @@ int EndTests();
 
 void SetCharacter(char *, std::size_t, const char *);
 
-#endif  // FORTRAN_TEST_RUNTIME_TESTING_H_
+#endif // FORTRAN_TEST_RUNTIME_TESTING_H_