[flang][NFC] Get formatting in sync with latest clang-format

[tskeith]

Summary

flang/module only contains Fortran files and one is a .h so disable
formatting on that directory.

[MyDeveloperDay]

I'd be interested to know if you felt any of those changes were an unwanted surprise

[PeteSteinfeld]

All builds, tests, and looks good.

Thanks for doing this!

[tskeith]

In D82989#2126276, @MyDeveloperDay wrote:

I'd be interested to know if you felt any of those changes were an unwanted surprise

Most of the differences were in formatting conditional expressions and I thought they were improvements.

My preference would be to have an option not to align things in those expressions. (You'll notice we have turned off all of the alignment options in .clang-format.) For example:

return IsUpperCaseLetter(ch) ? ch - 'A' + 10
    : IsLowerCaseLetter(ch) ? ch - 'a' + 10
    : DecimalDigitValue(ch);

flang/include/flang/Lower/AbstractConverter.h

 //===----------------------------------------------------------------------===//
 
 /// The abstract interface for converter implementations to lower Fortran
 /// front-end fragments such as expressions, types, etc. to the FIR dialect of
 /// MLIR.
 class AbstractConverter {
 public:
   //===--------------------------------------------------------------------===//
-  // Symbols     
+  // Symbols
   //===--------------------------------------------------------------------===//
 
   /// Get the mlir instance of a symbol.
   virtual mlir::Value getSymbolAddress(SymbolRef sym) = 0;
 
   //===--------------------------------------------------------------------===//
   // Expressions
   //===--------------------------------------------------------------------===//

flang/include/flang/Parser/characters.h

 
 inline constexpr bool IsSameApartFromCase(char x, char y) {
   return ToLowerCaseLetter(x) == ToLowerCaseLetter(y);
 }
 
 inline constexpr char DecimalDigitValue(char ch) { return ch - '0'; }
 
 inline constexpr char HexadecimalDigitValue(char ch) {
-  return IsUpperCaseLetter(ch)
-      ? ch - 'A' + 10
-      : IsLowerCaseLetter(ch) ? ch - 'a' + 10 : DecimalDigitValue(ch);
+  return IsUpperCaseLetter(ch) ? ch - 'A' + 10
+      : IsLowerCaseLetter(ch)  ? ch - 'a' + 10
+                               : DecimalDigitValue(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';

flang/include/flang/Semantics/scope.h

private:
   const DeclTypeSpec &MakeLengthlessType(DeclTypeSpec &&);
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Scope &);
 };
 
 // Inline so that it can be called from Evaluate without a link-time dependency.
 
 inline const Symbol *Scope::GetSymbol() const {
-  return symbol_ ? symbol_
-                 : derivedTypeSpec_ ? &derivedTypeSpec_->typeSymbol() : nullptr;
+  return symbol_         ? symbol_
+      : derivedTypeSpec_ ? &derivedTypeSpec_->typeSymbol()
+                         : nullptr;
 }
 
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_SCOPE_H_

flang/lib/Evaluate/fold-integer.cpp

return FoldElementalIntrinsic<T, T>(context, std::move(funcRef),
           }
           return j.value;
         }));
   } else if (name == "bit_size") {
     return Expr<T>{Scalar<T>::bits};
   } else if (name == "ceiling" || name == "floor" || name == "nint") {
     if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
       // NINT rounds ties away from zero, not to even
-      common::RoundingMode mode{name == "ceiling"
-              ? common::RoundingMode::Up
-              : name == "floor" ? common::RoundingMode::Down
+      common::RoundingMode mode{name == "ceiling" ? common::RoundingMode::Up
+              : name == "floor"                   ? common::RoundingMode::Down
                                 : common::RoundingMode::TiesAwayFromZero};
       return std::visit(
           [&](const auto &kx) {
             using TR = ResultType<decltype(kx)>;
             return FoldElementalIntrinsic<T, TR>(context, std::move(funcRef),
                 ScalarFunc<T, TR>([&](const Scalar<TR> &x) {
                   auto y{x.template ToInteger<Scalar<T>>(mode)};
                   if (y.flags.test(RealFlag::Overflow)) {
if (auto *charExpr{UnwrapExpr<Expr<SomeCharacter>>(args[0])}) {
               return FoldElementalIntrinsic<T, TC, TC>(context,
                   std::move(funcRef),
                   ScalarFunc<T, TC, TC>{
                       [&name](const Scalar<TC> &str,
                           const Scalar<TC> &other) -> Scalar<T> {
                         return name == "index"
                             ? CharacterUtils<TC::kind>::INDEX(str, other)
                             : name == "scan"
-                                ? CharacterUtils<TC::kind>::SCAN(str, other)
-                                : CharacterUtils<TC::kind>::VERIFY(str, other);
                       }});
             }
           },
           charExpr->u);
     } else {
       DIE("first argument must be CHARACTER");
     }
   } else if (name == "int") {

flang/lib/Lower/ConvertType.cpp

 }
 
 namespace {
 
 /// Discover the type of an Fortran::evaluate::Expr<T> and convert it to an
 /// mlir::Type. The type returned may be an MLIR standard or FIR type.
 class TypeBuilder {
 public:
-  
   /// Constructor.
   explicit TypeBuilder(
       mlir::MLIRContext *context,
       const Fortran::common::IntrinsicTypeDefaultKinds &defaults)
       : context{context}, defaults{defaults} {}
 
-  
   //===--------------------------------------------------------------------===//
   // Generate type entry points
   //===--------------------------------------------------------------------===//
-  
   template <template <typename> typename A, Fortran::common::TypeCategory TC>
   mlir::Type gen(const A<Fortran::evaluate::SomeKind<TC>> &) {
     return genFIRType<TC>(context, defaultKind<TC>());
   }
 
   template <template <typename> typename A, Fortran::common::TypeCategory TC,
             int KIND>
   mlir::Type gen(const A<Fortran::evaluate::Type<TC, KIND>> &) {
mlir::Type genFIRTy(Fortran::common::TypeCategory tc, int kind) {
     }
     llvm_unreachable("unhandled type category");
   }
 
 private:
   //===--------------------------------------------------------------------===//
   // Generate type helpers
   //===--------------------------------------------------------------------===//
-  
   mlir::Type gen(const Fortran::evaluate::ImpliedDoIndex &) {
     return genFIRType<Fortran::common::TypeCategory::Integer>(
         context, defaultKind<Fortran::common::TypeCategory::Integer>());
   }
 
   template <int KIND>
   mlir::Type gen(const Fortran::evaluate::TypeParamInquiry<KIND> &) {
     return genFIRType<Fortran::common::TypeCategory::Integer, KIND>(context);

flang/lib/Semantics/canonicalize-do.cpp

void Post(Block &block) {
     for (auto i{block.begin()}, end{block.end()}; i != end; ++i) {
       if (auto *executableConstruct{std::get_if<ExecutableConstruct>(&i->u)}) {
         std::visit(
             common::visitors{
                 [](auto &) {},
                 // 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));
+                      std::get<Statement<EndAssociateStmt>>(
+                          associate.value().t));
                 },
                 [&](common::Indirection<BlockConstruct> &blockConstruct) {
                   CanonicalizeIfMatch(block, stack, i,
-              std::get<Statement<EndBlockStmt>>(blockConstruct.value().t));
+                      std::get<Statement<EndBlockStmt>>(
+                          blockConstruct.value().t));
                 },
                 [&](common::Indirection<ChangeTeamConstruct> &changeTeam) {
                   CanonicalizeIfMatch(block, stack, i,
-              std::get<Statement<EndChangeTeamStmt>>(changeTeam.value().t));
+                      std::get<Statement<EndChangeTeamStmt>>(
+                          changeTeam.value().t));
                 },
                 [&](common::Indirection<CriticalConstruct> &critical) {
                   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));
                 },
                 [&](common::Indirection<IfConstruct> &ifConstruct) {
                   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));
+                      std::get<Statement<EndSelectStmt>>(
+                          caseConstruct.value().t));
                 },
                 [&](common::Indirection<SelectRankConstruct> &selectRank) {
                   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));
                 },
                 [&](common::Indirection<ForallConstruct> &forall) {
                   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});
                 },
                 [&](Statement<common::Indirection<EndDoStmt>> &endDoStmt) {
                   CanonicalizeIfMatch(block, stack, i, endDoStmt);
                 },
                 [&](Statement<ActionStmt> &actionStmt) {
                   CanonicalizeIfMatch(block, stack, i, actionStmt);
                 },
             },
             executableConstruct->u);
       }
     }
   }
 
 private:

flang/lib/Semantics/check-data.cpp

bool HasComponentWithoutSubscripts() const {
     return hasComponent_ && !hasSubscript_;
   }
   bool operator()(const Symbol &symbol) { // C876
     // 8.6.7p(2) - precludes non-pointers of derived types with
     // default component values
     const Scope &scope{context_.FindScope(source_)};
     bool isFirstSymbol{isFirstSymbol_};
     isFirstSymbol_ = false;
-    if (const char *whyNot{IsAutomatic(symbol)          ? "Automatic variable"
-            : IsDummy(symbol)                           ? "Dummy argument"
-            : IsFunctionResult(symbol)                  ? "Function result"
-            : IsAllocatable(symbol)                     ? "Allocatable"
-            : IsInitialized(symbol, true)               ? "Default-initialized"
-            : IsInBlankCommon(symbol)                   ? "Blank COMMON object"
+    if (const char *whyNot{IsAutomatic(symbol) ? "Automatic variable"
+                : IsDummy(symbol)              ? "Dummy argument"
+                : IsFunctionResult(symbol)     ? "Function result"
+                : IsAllocatable(symbol)        ? "Allocatable"
+                : IsInitialized(symbol, true)  ? "Default-initialized"
+                : IsInBlankCommon(symbol)      ? "Blank COMMON object"
                 : IsProcedure(symbol) && !IsPointer(symbol) ? "Procedure"
                 // remaining checks don't apply to components
                 : !isFirstSymbol                  ? nullptr
                 : IsHostAssociated(symbol, scope) ? "Host-associated object"
                 : IsUseAssociated(symbol, scope)  ? "USE-associated object"
                                                   : nullptr}) {
       context_.Say(source_,
           "%s '%s' must not be initialized in a DATA statement"_err_en_US,
           whyNot, symbol.name());
       return false;
     } else if (IsProcedurePointer(symbol)) {
       context_.Say(source_,
           "Procedure pointer '%s' in a DATA statement is not standard"_en_US,
           symbol.name());

flang/lib/Semantics/expression.cpp

if (actuals_.size() == 1) {
     }
   }
 }
 
 std::string ArgumentAnalyzer::TypeAsFortran(std::size_t i) {
   if (std::optional<DynamicType> type{GetType(i)}) {
     return type->category() == TypeCategory::Derived
         ? "TYPE("s + type->AsFortran() + ')'
         : type->category() == TypeCategory::Character
         ? "CHARACTER(KIND="s + std::to_string(type->kind()) + ')'
         : ToUpperCase(type->AsFortran());
   } else {
     return "untyped";
   }
 }
 
 bool ArgumentAnalyzer::AnyUntypedOperand() {

flang/module/.clang-format

+DisableFormat: true

flang/runtime/edit-output.cpp

const char *RealOutputEditingBase::FormatExponent(
   }
   length = eEnd - exponent;
   return exponent;
 }
 
 bool RealOutputEditingBase::EmitPrefix(
     const DataEdit &edit, std::size_t length, std::size_t width) {
   if (edit.IsListDirected()) {
-    int prefixLength{edit.descriptor == DataEdit::ListDirectedRealPart
-            ? 2
-            : edit.descriptor == DataEdit::ListDirectedImaginaryPart ? 0 : 1};
+    int prefixLength{edit.descriptor == DataEdit::ListDirectedRealPart ? 2
+            : edit.descriptor == DataEdit::ListDirectedImaginaryPart   ? 0
+                                                                       : 1};
     int suffixLength{edit.descriptor == DataEdit::ListDirectedRealPart ||
                 edit.descriptor == DataEdit::ListDirectedImaginaryPart
             ? 1
             : 0};
     length += prefixLength + suffixLength;
     ConnectionState &connection{io_.GetConnectionState()};
     return (connection.positionInRecord == 0 ||
                length <= connection.RemainingSpaceInRecord() ||

flang/runtime/memory.h

 #include <memory>
 
 namespace Fortran::runtime {
 
 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) {
   FreeMemory(reinterpret_cast<void *>(p));
 }
 template <typename A> void FreeMemoryAndNullify(A *&p) {
   FreeMemory(p);