[flang][NFC] Reformat files with current clang-format

[DavidTruby]

LGTM!

Out of interest what led to these changes? Were these files not clang formatted correctly before or has clang-format changed?

[klausler]

In D85489#2201563, @DavidTruby wrote:

LGTM!

Out of interest what led to these changes? Were these files not clang formatted correctly before or has clang-format changed?

The latter, we believe. We've been good about running git-clang-format, and these discrepancies are on lines that haven't changed in a while.

[DavidTruby]

Interesting, thanks for the info!
The changes look sensible to me so maybe it's a new pass clang-tidy has added.

flang/include/flang/Common/indirection.h

   bool operator==(const Indirection &that) const { return *p_ == *that.p_; }
 
   template <typename... ARGS>
-  static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&... args) {
+  static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&...args) {
     return {new A(std::move(args)...)};
   }
 

   bool operator==(const Indirection &that) const { return *p_ == *that.p_; }
 
   template <typename... ARGS>
-  static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&... args) {
+  static common::IfNoLvalue<Indirection, ARGS...> Make(ARGS &&...args) {
     return {new A(std::move(args)...)};
   }
 

flang/include/flang/Common/template.h

 //   CombineTuples<std::tuple<char, int>, std::tuple<float, double>>
 // is std::tuple<char, int, float, double>.
 template <typename... TUPLES> struct CombineTuplesHelper {
-  static decltype(auto) f(TUPLES *... a) {
+  static decltype(auto) f(TUPLES *...a) {
     return std::tuple_cat(std::move(*a)...);
   }
   using type = decltype(f(static_cast<TUPLES *>(nullptr)...));

 // 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>
-std::optional<std::tuple<A...>> AllPresent(std::optional<A> &&... x) {
+std::optional<std::tuple<A...>> AllPresent(std::optional<A> &&...x) {
   return AllElementsPresent(std::make_tuple(std::move(x)...));
 }
 

 // run it through JoinOptional to "squash" it.
 template <typename R, typename... A>
 std::optional<R> MapOptional(
-    std::function<R(A &&...)> &&f, std::optional<A> &&... x) {
+    std::function<R(A &&...)> &&f, std::optional<A> &&...x) {
   if (auto args{AllPresent(std::move(x)...)}) {
     return std::make_optional(std::apply(std::move(f), std::move(*args)));
   }
   return std::nullopt;
 }
 template <typename R, typename... A>
-std::optional<R> MapOptional(R (*f)(A &&...), std::optional<A> &&... x) {
+std::optional<R> MapOptional(R (*f)(A &&...), std::optional<A> &&...x) {
   return MapOptional(std::function<R(A && ...)>{f}, std::move(x)...);
 }
 

flang/include/flang/Evaluate/expression.h

 
 public:
   CLASS_BOILERPLATE(Operation)
-  explicit Operation(const Expr<OPERANDS> &... x) : operand_{x...} {}
-  explicit Operation(Expr<OPERANDS> &&... x) : operand_{std::move(x)...} {}
+  explicit Operation(const Expr<OPERANDS> &...x) : operand_{x...} {}
+  explicit Operation(Expr<OPERANDS> &&...x) : operand_{std::move(x)...} {}
 
   Derived &derived() { return *static_cast<Derived *>(this); }
   const Derived &derived() const { return *static_cast<const Derived *>(this); }

flang/include/flang/Evaluate/tools.h

 parser::Message *AttachDeclaration(parser::Message *, const Symbol &);
 template <typename MESSAGES, typename... A>
 parser::Message *SayWithDeclaration(
-    MESSAGES &messages, const Symbol &symbol, A &&... x) {
+    MESSAGES &messages, const Symbol &symbol, A &&...x) {
   return AttachDeclaration(messages.Say(std::forward<A>(x)...), symbol);
 }
 

flang/include/flang/Evaluate/traverse.h

   }
 
   template <typename A, typename... Bs>
-  Result Combine(const A &x, const Bs &... ys) const {
+  Result Combine(const A &x, const Bs &...ys) const {
     if constexpr (sizeof...(Bs) == 0) {
       return visitor_(x);
     } else {

flang/include/flang/Parser/message.h

 class MessageFormattedText {
 public:
   template <typename... A>
-  MessageFormattedText(const MessageFixedText &text, A &&... x)
+  MessageFormattedText(const MessageFixedText &text, A &&...x)
       : isFatal_{text.isFatal()} {
     Format(&text, Convert(std::forward<A>(x))...);
   }

       : location_{csr}, text_{t} {}
 
   template <typename RANGE, typename A, typename... As>
-  Message(RANGE r, const MessageFixedText &t, A &&x, As &&... xs)
+  Message(RANGE r, const MessageFixedText &t, A &&x, As &&...xs)
       : location_{r}, text_{MessageFormattedText{
                           t, std::forward<A>(x), std::forward<As>(xs)...}} {}
 

   }
   Message &Attach(Message *);
   Message &Attach(std::unique_ptr<Message> &&);
-  template <typename... A> Message &Attach(A &&... args) {
+  template <typename... A> Message &Attach(A &&...args) {
     return Attach(new Message{std::forward<A>(args)...}); // reference-counted
   }
 

   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_;
   }

     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 {

     }
   }
 
-  template <typename... A> Message *Say(A &&... args) {
+  template <typename... A> Message *Say(A &&...args) {
     return Say(at_, std::forward<A>(args)...);
   }
 

flang/include/flang/Parser/parse-state.h

     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>
-  void Say(const MessageExpectedText &text, A &&... args) {
+  void Say(const MessageExpectedText &text, A &&...args) {
     Say(p_, text, std::forward<A>(args)...);
   }
 

flang/include/flang/Parser/parse-tree.h

 // is conventionally named "t".
 #define TUPLE_CLASS_BOILERPLATE(classname) \
   template <typename... Ts, typename = common::NoLvalue<Ts...>> \
-  classname(Ts &&... args) : t(std::move(args)...) {} \
+  classname(Ts &&...args) : t(std::move(args)...) {} \
   using TupleTrait = std::true_type; \
   BOILERPLATE(classname)
 

flang/include/flang/Semantics/expression.h

     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>
-  parser::Message *SayAt(const T &parsed, A &&... args) {
+  parser::Message *SayAt(const T &parsed, A &&...args) {
     return Say(parser::FindSourceLocation(parsed), std::forward<A>(args)...);
   }
 

flang/include/flang/Semantics/semantics.h

   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>
-  parser::Message &Say(parser::CharBlock at, A &&... args) {
+  parser::Message &Say(parser::CharBlock at, A &&...args) {
     return messages_.Say(at, std::forward<A>(args)...);
   }
   parser::Message &Say(parser::Message &&msg) {

   }
   template <typename... A>
   void SayWithDecl(const Symbol &symbol, const parser::CharBlock &at,
-      parser::MessageFixedText &&msg, A &&... args) {
+      parser::MessageFixedText &&msg, A &&...args) {
     auto &message{Say(at, std::move(msg), args...)};
     evaluate::AttachDeclaration(&message, symbol);
   }

flang/lib/Evaluate/intrinsics-library-templates.h

 template <typename TR, typename... ArgInfo> struct CallableHostWrapper {
   static Scalar<TR> scalarCallable(FoldingContext &context,
       HostFuncPointer<TR, ArgInfo...> func,
-      const Scalar<typename ArgInfo::Type> &... x) {
+      const Scalar<typename ArgInfo::Type> &...x) {
     if constexpr (host::HostTypeExists<TR, typename ArgInfo::Type...>()) {
       host::HostFloatingPointEnvironment hostFPE;
       hostFPE.SetUpHostFloatingPointEnvironment(context);

         if (match) {
           return {HostProcedureWrapper<ConstantContainer, TR, TA...>{
               [=](FoldingContext &context,
-                  const ConstantContainer<TA> &... args) {
+                  const ConstantContainer<TA> &...args) {
                 auto callable{FromGenericFunctionPointer<ConstantContainer<TR>,
                     FoldingContext &, GenericFunctionPointer,
                     const ConstantContainer<TA> &...>(iter->second.callable)};

flang/lib/Parser/basic-parsers.h

 
 template <typename RESULT, typename... PARSER>
 inline constexpr auto applyFunction(
-    ApplicableFunctionPointer<RESULT, PARSER...> f, const PARSER &... parser) {
+    ApplicableFunctionPointer<RESULT, PARSER...> f, const PARSER &...parser) {
   return ApplyFunction<ApplicableFunctionPointer, RESULT, PARSER...>{
       f, parser...};
 }
 
 template <typename RESULT, typename... PARSER>
 inline /* not constexpr */ auto applyLambda(
-    ApplicableFunctionObject<RESULT, PARSER...> f, const PARSER &... parser) {
+    ApplicableFunctionObject<RESULT, PARSER...> f, const PARSER &...parser) {
   return ApplyFunction<ApplicableFunctionObject, RESULT, PARSER...>{
       f, parser...};
 }

flang/lib/Parser/prescan.h

   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));

flang/lib/Semantics/assignment.cpp

       parser::CharBlock rhsSource, bool isPointerAssignment);
   void CheckShape(parser::CharBlock, const SomeExpr *);
   template <typename... A>
-  parser::Message *Say(parser::CharBlock at, A &&... args) {
+  parser::Message *Say(parser::CharBlock at, A &&...args) {
     return &context_.Say(at, std::forward<A>(args)...);
   }
   evaluate::FoldingContext &foldingContext() {

flang/lib/Semantics/check-declarations.cpp

     return innermostSymbol_ && IsFunction(*innermostSymbol_);
   }
   template <typename... A>
-  void SayWithDeclaration(const Symbol &symbol, A &&... x) {
+  void SayWithDeclaration(const Symbol &symbol, A &&...x) {
     if (parser::Message * msg{messages_.Say(std::forward<A>(x)...)}) {
       if (messages_.at().begin() != symbol.name().begin()) {
         evaluate::AttachDeclaration(*msg, symbol);

 // Report an error referring to first symbol with declaration of second symbol
 template <typename... A>
 void SubprogramMatchHelper::Say(const Symbol &symbol1, const Symbol &symbol2,
-    parser::MessageFixedText &&text, A &&... args) {
+    parser::MessageFixedText &&text, A &&...args) {
   auto &message{context.Say(symbol1.name(), std::move(text), symbol1.name(),
       std::forward<A>(args)...)};
   evaluate::AttachDeclaration(message, symbol2);

flang/lib/Semantics/pointer-assignment.cpp

 }
 
 template <typename... A>
-parser::Message *PointerAssignmentChecker::Say(A &&... x) {
+parser::Message *PointerAssignmentChecker::Say(A &&...x) {
   auto *msg{context_.messages().Say(std::forward<A>(x)...)};
   if (lhs_) {
     return evaluate::AttachDeclaration(msg, *lhs_);

flang/lib/Semantics/resolve-names.cpp

   Message &Say(const SourceName &, MessageFixedText &&);
   // Emit a formatted message associated with a source location.
   template <typename... A>
-  Message &Say(const SourceName &source, MessageFixedText &&msg, A &&... args) {
+  Message &Say(const SourceName &source, MessageFixedText &&msg, A &&...args) {
     return context_->Say(source, std::move(msg), std::forward<A>(args)...);
   }
 

     }
   }
 
-  template <typename... A> Message &Say(A &&... args) {
+  template <typename... A> Message &Say(A &&...args) {
     return messageHandler_.Say(std::forward<A>(args)...);
   }
   template <typename... A>
   Message &Say(
-      const parser::Name &name, MessageFixedText &&text, const A &... args) {
+      const parser::Name &name, MessageFixedText &&text, const A &...args) {
     return messageHandler_.Say(name.source, std::move(text), args...);
   }
 

flang/unittests/Evaluate/intrinsics.cpp

     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)...);
   }

flang/unittests/Runtime/external-io.cpp

   //   FORM='UNFORMATTED',RECL=8,STATUS='SCRATCH')
   auto io{IONAME(BeginOpenNewUnit)(__FILE__, __LINE__)};
   IONAME(SetAccess)
-      (io, "SEQUENTIAL", 10) || (Fail() << "SetAccess(SEQUENTIAL)", 0);
   IONAME(SetAction)
   (io, "READWRITE", 9) || (Fail() << "SetAction(READWRITE)", 0);
   IONAME(SetForm)