[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

public:
 
   A &value() { return *p_; }
   const A &value() const { return *p_; }
 
   bool operator==(const A &that) const { return *p_ == that; }
   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)...)};
   }
 
 private:
   A *p_{nullptr};
 };
 
 // Variant with copy construction and assignment
public:
 
   A &value() { return *p_; }
   const A &value() const { return *p_; }
 
   bool operator==(const A &that) const { return *p_ == that; }
   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)...)};
   }
 
 private:
   A *p_{nullptr};
 };
 
 template <typename A> using CopyableIndirection = Indirection<A, true>;

flang/include/flang/Common/template.h

 }
 
 // CombineTuples takes a list of std::tuple<> template instantiation types
 // and constructs a new std::tuple type that concatenates all of their member
 // types.  E.g.,
 //   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)...));
 };
 template <typename... TUPLES>
 using CombineTuples = typename CombineTuplesHelper<TUPLES...>::type;
 
 // CombineVariants takes a list of std::variant<> instantiations and constructs
std::optional<std::vector<A>> AllElementsPresent(
   }
   return result;
 }
 
 // (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>
-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)...));
 }
 
 // (f(A...) -> R) -> std::optional<A>... -> std::optional<R>
 // Apply a function to optional arguments if all are present.
 // 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>
 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)...);
 }
 
 // Given a VISITOR class of the general form
 //   struct VISITOR {
 //     using Result = ...;
 //     using Types = std::tuple<...>;
 //     template<typename T> Result Test() { ... }

flang/include/flang/Evaluate/expression.h

public:
   // Binary operations wrap a tuple of CopyableIndirections to Exprs.
 private:
   using Container = std::conditional_t<operands == 1,
       common::CopyableIndirection<Expr<Operand<0>>>,
       std::tuple<common::CopyableIndirection<Expr<OPERANDS>>...>>;
 
 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); }
 
   // References to operand expressions from member functions of derived
   // classes for specific operators can be made by index, e.g. operand<0>(),
   // which must be spelled like "this->template operand<0>()" when
   // inherited in a derived class template.  There are convenience aliases

flang/include/flang/Evaluate/tools.h

 
 // Utilities for attaching the location of the declaration of a symbol
 // of interest to a message, if both pointers are non-null.  Handles
 // the case of USE association gracefully.
 parser::Message *AttachDeclaration(parser::Message &, const Symbol &);
 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);
 }
 
 // Check for references to impure procedures; returns the name
 // of one to complain about, if any exist.
 std::optional<std::string> FindImpureCall(
     const IntrinsicProcTable &, const Expr<SomeType> &);
 std::optional<std::string> FindImpureCall(

flang/include/flang/Evaluate/traverse.h

template <typename ITER> Result CombineRange(ITER iter, ITER end) const {
     }
   }
 
   template <typename A> Result CombineContents(const A &x) const {
     return CombineRange(x.begin(), x.end());
   }
 
   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 {
       return visitor_.Combine(visitor_(x), Combine(ys...));
     }
   }
 
   Visitor &visitor_;

flang/include/flang/Parser/message.h

 // The construction of a MessageFormattedText uses a MessageFixedText
 // as a vsnprintf() formatting string that is applied to the
 // following arguments.  CharBlock and std::string argument
 // values are also supported; they are automatically converted into
 // char pointers that are suitable for '%s' formatting.
 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))...);
   }
   MessageFormattedText(const MessageFormattedText &) = default;
   MessageFormattedText(MessageFormattedText &&) = default;
   MessageFormattedText &operator=(const MessageFormattedText &) = default;
   MessageFormattedText &operator=(MessageFormattedText &&) = default;
   const std::string &string() const { return string_; }
public:
   Message(CharBlock csr, const MessageFormattedText &s)
       : location_{csr}, text_{s} {}
   Message(CharBlock csr, MessageFormattedText &&s)
       : location_{csr}, text_{std::move(s)} {}
   Message(CharBlock csr, const MessageExpectedText &t)
       : 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)...}} {}
 
   bool attachmentIsContext() const { return attachmentIsContext_; }
   Reference attachment() const { return attachment_; }
 
   void SetContext(Message *c) {
     attachment_ = c;
     attachmentIsContext_ = true;
   }
   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 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 &,
Messages &operator=(Messages &&that) {
     }
     return *this;
   }
 
   std::forward_list<Message> &messages() { return messages_; }
   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_;
   }
 
   void Annex(Messages &&that) {
     if (!that.messages_.empty()) {
       messages_.splice_after(last_, that.messages_);
       last_ = that.last_;
public:
   common::Restorer<Messages *> SetMessages(Messages &buffer) {
     return common::ScopedSet(messages_, &buffer);
   }
   // Discard messages; destination restored when the returned value is deleted.
   common::Restorer<Messages *> DiscardMessages() {
     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 {
       return nullptr;
     }
   }
 
-  template <typename... A> Message *Say(A &&... args) {
+  template <typename... A> Message *Say(A &&...args) {
     return Say(at_, std::forward<A>(args)...);
   }
 
 private:
   CharBlock at_;
   Messages *messages_{nullptr};
 };
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_MESSAGE_H_

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

void PushContext(MessageFixedText text) {
     context_ = Message::Reference{m};
   }
 
   void PopContext() {
     CHECK(context_);
     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)...);
   }
 
   void Nonstandard(LanguageFeature lf, const MessageFixedText &msg) {
     Nonstandard(p_, lf, msg);
   }
   void Nonstandard(
       CharBlock range, LanguageFeature lf, const MessageFixedText &msg) {

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

#define UNION_CLASS_BOILERPLATE(classname) \
   classname(A &&x) : u(std::move(x)) {} \
   using UnionTrait = std::true_type; \
   BOILERPLATE(classname)
 
 // 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...>> \
-  classname(Ts &&... args) : t(std::move(args)...) {} \
+  classname(Ts &&...args) : t(std::move(args)...) {} \
   using TupleTrait = std::true_type; \
   BOILERPLATE(classname)
 
 // Many other classes below simply wrap a single data member, which is
 // conventionally named "v".
 #define WRAPPER_CLASS_BOILERPLATE(classname, type) \
   BOILERPLATE(classname); \
   classname(type &&x) : v(std::move(x)) {} \

flang/include/flang/Semantics/expression.h

public:
   semantics::SemanticsContext &context() const { return context_; }
 
   FoldingContext &GetFoldingContext() const { return foldingContext_; }
 
   parser::ContextualMessages &GetContextualMessages() {
     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)...);
   }
 
   int GetDefaultKind(common::TypeCategory);
   DynamicType GetDefaultKindOfType(common::TypeCategory);
 
   // Return false and emit error if these checks fail:
   bool CheckIntrinsicKind(TypeCategory, std::int64_t kind);

flang/include/flang/Semantics/semantics.h

public:
   bool AnyFatalError() const;
 
   // Test or set the Error flag on a Symbol
   bool HasError(const Symbol &);
   bool HasError(const Symbol *);
   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) {
     return messages_.Say(std::move(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);
   }
 
   const Scope &FindScope(parser::CharBlock) const;
   Scope &FindScope(parser::CharBlock);
 
   const ConstructStack &constructStack() const { return constructStack_; }

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

static constexpr inline Scalar<T> FlushSubnormals(const Scalar<T> &x) {
     return x.FlushSubnormalToZero();
   }
 };
 
 // Callable factory
 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);
       host::HostType<TR> hostResult{};
       Scalar<TR> result{};
       if (context.flushSubnormalsToZero() &&
           !hostFPE.hasSubnormalFlushingHardwareControl()) {
         hostResult = func(host::CastFortranToHost<typename ArgInfo::Type>(
for (auto iter{rteProcRange.first}; iter != rteProcRange.second; ++iter) {
           if (type != iter->second.argumentsType[pos++]) {
             match = false;
             break;
           }
         }
         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)};
                 return callable(context, iter->second.handle, args...);
               }}};
         }
       }
     }
   }
   return std::nullopt;
 }
 
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_INTRINSICS_LIBRARY_TEMPLATES_H_

flang/lib/Parser/basic-parsers.h

 
 private:
   const funcType function_;
   const std::tuple<PARSER...> parsers_;
 };
 
 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...};
 }
 
 // Member function application
 template <typename OBJPARSER, typename... PARSER> class AMFPHelper {
   using resultType = typename OBJPARSER::resultType;
 

flang/lib/Parser/prescan.h

public:
   void NextLine();
 
   // Callbacks for use by Preprocessor.
   bool IsAtEnd() const { return nextLine_ >= limit_; }
   bool IsNextLinePreprocessorDirective() const;
   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));
     return m;
   }
 
 private:
   struct LineClassification {

flang/lib/Semantics/assignment.cpp

public:
   void Analyze(const parser::PointerAssignmentStmt &);
   void Analyze(const parser::ConcurrentControl &);
 
 private:
   bool CheckForPureContext(const SomeExpr &lhs, const SomeExpr &rhs,
       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() {
     return context_.foldingContext();
   }
 
   SemanticsContext &context_;
   int whereDepth_{0}; // number of WHEREs currently nested in

flang/lib/Semantics/check-declarations.cpp

private:
   bool CheckConflicting(const Symbol &, Attr, Attr);
   bool InPure() const {
     return innermostSymbol_ && IsPureProcedure(*innermostSymbol_);
   }
   bool InFunction() const {
     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);
       }
     }
   }
   bool IsResultOkToDiffer(const FunctionResult &);
 
Say(symbol1, symbol2,
         " of the corresponding argument in the interface body"_err_en_US);
     return false;
   }
 }
 
 // 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);
 }
 
 template <typename ATTRS>
 bool SubprogramMatchHelper::CheckSameAttrs(
     const Symbol &symbol1, const Symbol &symbol2, ATTRS attrs1, ATTRS attrs2) {

flang/lib/Semantics/pointer-assignment.cpp

bool PointerAssignmentChecker::LhsOkForUnlimitedPoly() const {
   } else if (type.IsUnlimitedPolymorphic()) {
     return true;
   } else {
     return !IsExtensibleType(&type.GetDerivedTypeSpec());
   }
 }
 
 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_);
   } else if (!source_.empty()) {
     msg->Attach(source_, "Declaration of %s"_en_US, description_);
   }
   return msg;
 }

flang/lib/Semantics/resolve-names.cpp

public:
 
   // Emit a message associated with the current statement source.
   Message &Say(MessageFixedText &&);
   Message &Say(MessageFormattedText &&);
   // Emit a message about a SourceName
   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)...);
   }
 
 private:
   SemanticsContext *context_;
 };
 
 // Inheritance graph for the parse tree visitation classes that follow:
MaybeSubscriptIntExpr EvaluateSubscriptIntExpr(const T &expr) {
     if (MaybeIntExpr maybeIntExpr{EvaluateIntExpr(expr)}) {
       return FoldExpr(evaluate::ConvertToType<evaluate::SubscriptInteger>(
           std::move(*maybeIntExpr)));
     } else {
       return std::nullopt;
     }
   }
 
-  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...);
   }
 
 protected:
   ImplicitRulesMap *implicitRulesMap_{nullptr};
 
 private:
   ResolveNamesVisitor *this_;

flang/unittests/Evaluate/intrinsics.cpp

template <typename A> TestCall &Push(A &&x) {
     return *this;
   }
   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)...);
   }
   void Marshal() {
     strings.Save(name);
     strings.Marshal();
     std::size_t j{0};
     for (auto &kw : keywords) {

flang/unittests/Runtime/external-io.cpp

 }
 
 void TestSequentialFixedUnformatted() {
   llvm::errs() << "begin TestSequentialFixedUnformatted()\n";
   // OPEN(NEWUNIT=unit,ACCESS='SEQUENTIAL',ACTION='READWRITE',&
   //   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)
   (io, "UNFORMATTED", 11) || (Fail() << "SetForm(UNFORMATTED)", 0);
   std::int64_t buffer;
   static constexpr std::size_t recl{sizeof buffer};
   IONAME(SetRecl)(io, recl) || (Fail() << "SetRecl()", 0);
   IONAME(SetStatus)(io, "SCRATCH", 7) || (Fail() << "SetStatus(SCRATCH)", 0);