[Flang] Run clang-format on all flang files

[PeteSteinfeld]

Summary

This will make it easier for me to do reviews.

[klausler]

flang/include/flang/Runtime/magic-numbers.h

1

This change is not an improvement.

flang/lib/Semantics/type.cpp

466

This one seems inconsistent with all other braced initializations.

flang/runtime/derived.cpp

168

Comment makes more sense when it's on the same line as its referent.

[awarzynski]

Thanks a ton Pete, nice clean-up!

Changes in the driver area LGTM. Listing them here for reference

• "flang/tools/flang-driver/*,
• "flang/include/flang/Frontend/*",
• "flang/lib/Frontend/*".

Approving this as is, but please address Peter's comments before merging (and any other comments that folks might leave in the meantime).

[jeanPerier]

I am ok with the changes in Optimizer/Evaluate

[PeteSteinfeld]

Responding to Peter's comments.

[PeteSteinfeld]

Thanks, Peter, Jean, and Andrej. I'll fix things up.

flang/include/flang/Runtime/magic-numbers.h

1

Thanks. I'll revert it.

flang/lib/Semantics/type.cpp

466

Yes. This is weird. It's probably a bug in clang-format. I'll revert it.

flang/runtime/derived.cpp

168

Agreed. I'll revert it.

flang/include/flang/Frontend/CompilerInvocation.h

class CompilerInvocation : public CompilerInvocationBase {
   std::string moduleDir = ".";
 
   std::string moduleFileSuffix = ".mod";
 
   bool debugModuleDir = false;
 
   bool warnAsErr = false;
 
-  /// This flag controls the unparsing and is used to decide whether to print out
-  /// the semantically analyzed version of an object or expression or the plain
-  /// version that does not include any information from semantic analysis.
+  /// This flag controls the unparsing and is used to decide whether to print
+  /// out the semantically analyzed version of an object or expression or the
+  /// plain version that does not include any information from semantic
+  /// analysis.
   bool useAnalyzedObjectsForUnparse = true;
 
   // Fortran Dialect options
   Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
 
   bool enableConformanceChecks = false;
 
   /// Used in e.g. unparsing to dump the analyzed rather than the original

flang/include/flang/Frontend/FrontendAction.h

protected:
   }
 
   // Report fatal parsing errors. Return True if present, false otherwise
   inline bool reportFatalParsingErrors() {
     return reportFatalErrors("Could not parse %0");
   }
 
 private:
-  template <unsigned N> bool reportFatalErrors(const char (&message)[N]);
+  template <unsigned N>
+  bool reportFatalErrors(const char (&message)[N]);
 };
 
 } // namespace Fortran::frontend
 
 #endif // FORTRAN_FRONTEND_FRONTENDACTION_H

flang/include/flang/Frontend/FrontendActions.h

 #include "llvm/Target/TargetMachine.h"
 #include <memory>
 
 namespace Fortran::frontend {
 
 // TODO: This is a copy from f18.cpp. It doesn't really belong here and should
 // be moved to a more suitable place in future.
 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);
   }
   size_t objects{0}, bytes{0};
 };
 
 //===----------------------------------------------------------------------===//
 // Custom Consumer Actions

 public:
   Fortran::parser::Parsing &getParsing();
   /// Creates an output file. This is just a wrapper for calling
   /// CreateDefaultOutputFile from CompilerInstance. Use it to make sure that
   /// your plugin respects driver's `-o` flag.
   /// \param extension  The extension to use for the output file (ignored when
   ///                   the user decides to print to stdout via `-o -`)
   /// \return           Null on error, ostream for the output file otherwise
-  std::unique_ptr<llvm::raw_pwrite_stream> createOutputFile(
-      llvm::StringRef extension);
+  std::unique_ptr<llvm::raw_pwrite_stream>
+  createOutputFile(llvm::StringRef extension);
 };
 
 //===----------------------------------------------------------------------===//
 // PrescanAndSemaDebug Actions
 //
 // These actions will parse the input, run the semantic checks and execute
 // their actions _regardless of_ whether any semantic errors have been found.
 // This can be useful when adding new languge feature and when you wish to

 /// Represents the type of "backend" action to perform by the corresponding
 /// CodeGenAction. Note that from Flang's perspective, both LLVM and MLIR are
 /// "backends" that are used for generating LLVM IR/BC, assembly files or
 /// machine code. This enum captures "what" exactly one of these backends is to
 /// do. The names are similar to what is used in Clang - this allows us to
 /// maintain some level of consistency/similarity between the drivers.
 enum class BackendActionTy {
   Backend_EmitAssembly, ///< Emit native assembly files
-  Backend_EmitObj, ///< Emit native object files
-  Backend_EmitBC, ///< Emit LLVM bitcode files
-  Backend_EmitLL, ///< Emit human-readable LLVM assembly
-  Backend_EmitMLIR ///< Emit MLIR files
+  Backend_EmitObj,      ///< Emit native object files
+  Backend_EmitBC,       ///< Emit LLVM bitcode files
+  Backend_EmitLL,       ///< Emit human-readable LLVM assembly
+  Backend_EmitMLIR      ///< Emit MLIR files
 };
 
 /// Abstract base class for actions that generate code (MLIR, LLVM IR, assembly
 /// and machine code). Every action that inherits from this class will at
 /// least run the prescanning, parsing, semantic checks and lower the parse
 /// tree to an MLIR module.
 class CodeGenAction : public FrontendAction {
 

flang/include/flang/Frontend/TextDiagnosticBuffer.h

private:
   /// All diagnostics in the order in which they were generated. That order
   /// likely doesn't correspond to user input order, but at least it keeps
   /// notes in the right places. Each pair is a diagnostic level and an index
   /// into the corresponding DiagList above.
   DiagnosticsLevelAndIndexPairs all;
 
 public:
   void HandleDiagnostic(clang::DiagnosticsEngine::Level diagLevel,
                         const clang::Diagnostic &info) override;
 
   /// Flush the buffered diagnostics to a given diagnostic engine.
   void flushDiagnostics(clang::DiagnosticsEngine &diags) const;
 };
 
 } // namespace Fortran::frontend
 
 #endif // FORTRAN_FRONTEND_TEXTDIAGNOSTICBUFFER_H

flang/include/flang/Frontend/TextDiagnosticPrinter.h

public:
   TextDiagnosticPrinter(raw_ostream &os, clang::DiagnosticOptions *diags);
   ~TextDiagnosticPrinter() override;
 
   /// Set the diagnostic printer prefix string, which will be printed at the
   /// start of any diagnostics. If empty, no prefix string is used.
   void setPrefix(std::string value) { prefix = std::move(value); }
 
   void HandleDiagnostic(clang::DiagnosticsEngine::Level level,
                         const clang::Diagnostic &info) override;
 };
 
 } // namespace Fortran::frontend
 
 #endif

flang/include/flang/Optimizer/Builder/Runtime/Derived.h

 namespace mlir {
 class Value;
 class Location;
 } // namespace mlir
 
 namespace fir {
 class FirOpBuilder;
 class RecordType;
-}
+} // namespace fir
 
 namespace fir::runtime {
 
 /// Generate call to derived type initialization runtime routine to
 /// default initialize \p box.
 void genDerivedTypeInitialize(fir::FirOpBuilder &builder, mlir::Location loc,
                               mlir::Value box);
 

flang/include/flang/Runtime/magic-numbers.h

-#if 0 /*===-- include/flang/Runtime/magic-numbers.h -----------------------===*/
+#if 0 /*===-- include/flang/Runtime/magic-numbers.h \
+         -----------------------===*/
 /*
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===----------------------------------------------------------------------===*/
 #endif
 #if 0

flang/include/flang/Semantics/symbol.h

public:
 
   const std::string *GetBindName() const;
   void SetBindName(std::string &&);
   bool IsFuncResult() const;
   bool IsObjectArray() const;
   bool IsSubprogram() const;
   bool IsFromModFile() const;
   bool HasExplicitInterface() const {
-    return common::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 GenericDetails &x) {
-                               return x.specific() &&
-                                   x.specific()->HasExplicitInterface();
-                             },
-                             [](const auto &) { return false; },
-                         },
+    return common::visit(
+        common::visitors{
+              return attrs_.test(Attr::INTRINSIC) || x.HasExplicitInterface();
+              return x.specific() && x.specific()->HasExplicitInterface();
         details_);
   }
 
   bool operator==(const Symbol &that) const { return this == &that; }
   bool operator!=(const Symbol &that) const { return !(*this == that); }
 
   int Rank() const { return RankImpl(); }
 

flang/lib/Evaluate/characteristics.cpp

return common::visit(
               // declaration checking in Semantics.
               auto intrinsic{context.intrinsics().IsSpecificIntrinsicFunction(
                   symbol.name().ToString())};
               if (intrinsic && intrinsic->isRestrictedSpecific) {
                 intrinsic.reset(); // Exclude intrinsics from table 16.3.
               }
               return intrinsic;
             }
-            const semantics::ProcInterface &interface {
-              proc.interface()
-            };
+            const semantics::ProcInterface &interface { proc.interface() };
             if (const semantics::Symbol * interfaceSymbol{interface.symbol()}) {
               auto interface {
                 CharacterizeProcedure(*interfaceSymbol, context, seenProcs)
               };
               if (interface && IsPointer(symbol)) {
                 interface->attrs.reset(Procedure::Attr::Elemental);
               }
               return interface;

flang/lib/Evaluate/fold-integer.cpp

#endif // _MSC_VER
     } else {
       DIE("kind() result not integral");
     }
   } else if (name == "iparity") {
     return FoldBitReduction(
         context, std::move(funcRef), &Scalar<T>::IEOR, Scalar<T>{});
   } else if (name == "ishft") {
     return FoldElementalIntrinsic<T, T, Int4>(context, std::move(funcRef),
-        ScalarFunc<T, T, Int4>([&](const Scalar<T> &i,
-                                   const Scalar<Int4> &pos) -> Scalar<T> {
+        ScalarFunc<T, T, Int4>(
+            [&](const Scalar<T> &i, const Scalar<Int4> &pos) -> Scalar<T> {
               auto posVal{static_cast<int>(pos.ToInt64())};
               if (posVal < -i.bits) {
                 context.messages().Say(
-                "SHIFT=%d count for ishft is less than %d"_err_en_US, posVal,
-                -i.bits);
+                    "SHIFT=%d count for ishft is less than %d"_err_en_US,
+                    posVal, -i.bits);
               } else if (posVal > i.bits) {
                 context.messages().Say(
-                "SHIFT=%d count for ishft is greater than %d"_err_en_US, posVal,
-                i.bits);
+                    "SHIFT=%d count for ishft is greater than %d"_err_en_US,
+                    posVal, i.bits);
               }
               return i.ISHFT(posVal);
             }));
   } else if (name == "ishftc") {
     if (args.at(2)) { // SIZE= is present
       return FoldElementalIntrinsic<T, T, Int4, Int4>(context,
           std::move(funcRef),
           ScalarFunc<T, T, Int4, Int4>(
               [&](const Scalar<T> &i, const Scalar<Int4> &shift,
                   const Scalar<Int4> &size) -> Scalar<T> {
                 // Errors are caught in intrinsics.cpp
return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
                 context.messages().Say("mod() by zero"_warn_en_US);
               } else if (quotRem.overflow) {
                 context.messages().Say("mod() folding overflowed"_warn_en_US);
               }
               return quotRem.remainder;
             }));
   } else if (name == "modulo") {
     return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
-        ScalarFuncWithContext<T, T, T>(
-            [](FoldingContext &context, const Scalar<T> &x,
+        ScalarFuncWithContext<T, T, T>([](FoldingContext &context,
+                                           const Scalar<T> &x,
                                            const Scalar<T> &y) -> Scalar<T> {
-              auto result{x.MODULO(y)};
-              if (result.overflow) {
-                context.messages().Say(
-                    "modulo() folding overflowed"_warn_en_US);
-              }
-              return result.value;
-            }));
+            context.messages().Say("modulo() folding overflowed"_warn_en_US);
   } else if (name == "not") {
     return FoldElementalIntrinsic<T, T>(
         context, std::move(funcRef), &Scalar<T>::NOT);
   } else if (name == "precision") {
     if (const auto *cx{UnwrapExpr<Expr<SomeReal>>(args[0])}) {
       return Expr<T>{common::visit(
           [](const auto &kx) {
             return Scalar<ResultType<decltype(kx)>>::PRECISION;
return FoldElementalIntrinsic<T, T, Int4>(context, std::move(funcRef),
             context.messages().Say(
                 "SHIFT=%d count for %s is greater than %d"_err_en_US, posVal,
                 name, i.bits);
           }
           return std::invoke(fptr, i, posVal);
         }));
   } else if (name == "sign") {
     return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
-        ScalarFunc<T, T, T>(
-            [&context](const Scalar<T> &j, const Scalar<T> &k) -> Scalar<T> {
-              typename Scalar<T>::ValueWithOverflow result{j.SIGN(k)};
-              if (result.overflow) {
-                context.messages().Say(
-                    "sign(integer(kind=%d)) folding overflowed"_warn_en_US,
-                    KIND);
-              }
-              return result.value;
-            }));
+        ScalarFunc<T, T, T>([&context](const Scalar<T> &j,
+                                const Scalar<T> &k) -> Scalar<T> {
+                "sign(integer(kind=%d)) folding overflowed"_warn_en_US, KIND);
   } else if (name == "size") {
     if (auto shape{GetContextFreeShape(context, args[0])}) {
       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) {
             const Symbol *symbol{UnwrapWholeSymbolDataRef(args[0])};
             if (symbol && IsAssumedSizeArray(*symbol) && *dim == rank) {

flang/lib/Evaluate/fold-real.cpp

if (auto *zExpr{UnwrapExpr<Expr<ComplexT>>(args[0])}) {
       return Fold(context, Expr<T>{ComplexComponent{true, std::move(*zExpr)}});
     }
   } else if (name == "aint" || name == "anint") {
     // ANINT rounds ties away from zero, not to even
     common::RoundingMode mode{name == "aint"
             ? common::RoundingMode::ToZero
             : common::RoundingMode::TiesAwayFromZero};
     return FoldElementalIntrinsic<T, T>(context, std::move(funcRef),
-        ScalarFunc<T, T>([&name, &context, mode](
-                             const Scalar<T> &x) -> Scalar<T> {
+        ScalarFunc<T, T>(
+            [&name, &context, mode](const Scalar<T> &x) -> Scalar<T> {
               ValueWithRealFlags<Scalar<T>> y{x.ToWholeNumber(mode)};
               if (y.flags.test(RealFlag::Overflow)) {
                 context.messages().Say(
                     "%s intrinsic folding overflow"_warn_en_US, name);
               }
               return y.value;
             }));
   } else if (name == "dim") {
     return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
         ScalarFunc<T, T, T>(
             [](const Scalar<T> &x, const Scalar<T> &y) -> Scalar<T> {
               return x.DIM(y).value;
             }));
   } else if (name == "dot_product") {
     return FoldDotProduct<T>(context, std::move(funcRef));

flang/lib/Frontend/CompilerInstance.cpp

 llvm::Expected<std::unique_ptr<llvm::raw_pwrite_stream>>
 CompilerInstance::createOutputFileImpl(llvm::StringRef outputFilePath,
                                        bool binary) {
 
   // Creates the file descriptor for the output file
   std::unique_ptr<llvm::raw_fd_ostream> os;
 
   std::error_code error;
-  os.reset(new llvm::raw_fd_ostream(outputFilePath, error,
+  os.reset(new llvm::raw_fd_ostream(
+      outputFilePath, error,
       (binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_TextWithCRLF)));
   if (error) {
     return llvm::errorCodeToError(error);
   }
 
   // For seekable streams, just return the stream corresponding to the output
   // file.
   if (!binary || os->supportsSeeking())

flang/lib/Frontend/CompilerInvocation.cpp

if (ik.isUnknown()) {
       if (i == 0)
         dashX = ik;
     }
 
     opts.inputs.emplace_back(std::move(inputs[i]), ik);
   }
 
   // Set fortranForm based on options -ffree-form and -ffixed-form.
-  if (const auto *arg = args.getLastArg(clang::driver::options::OPT_ffixed_form,
+  if (const auto *arg =
+          args.getLastArg(clang::driver::options::OPT_ffixed_form,
                           clang::driver::options::OPT_ffree_form)) {
     opts.fortranForm =
         arg->getOption().matches(clang::driver::options::OPT_ffixed_form)
             ? FortranForm::FixedForm
             : FortranForm::FreeForm;
   }
 
   // Set fixedFormColumns based on -ffixed-line-length=<value>
   if (const auto *arg =
           args.getLastArg(clang::driver::options::OPT_ffixed_line_length_EQ)) {
     llvm::StringRef argValue = llvm::StringRef(arg->getValue());
     std::int64_t columns = -1;
     if (argValue == "none") {
else
       diags.Report(clang::diag::err_drv_invalid_value)
           << arg->getAsString(args) << argValue;
   }
 
   // -f{no-}implicit-none
   opts.features.Enable(
       Fortran::common::LanguageFeature::ImplicitNoneTypeAlways,
       args.hasFlag(clang::driver::options::OPT_fimplicit_none,
                    clang::driver::options::OPT_fno_implicit_none, false));
 
   // -f{no-}backslash
   opts.features.Enable(Fortran::common::LanguageFeature::BackslashEscapes,
                        args.hasFlag(clang::driver::options::OPT_fbackslash,
-          clang::driver::options::OPT_fno_backslash, false));
+                                    clang::driver::options::OPT_fno_backslash,
+                                    false));
 
   // -f{no-}logical-abbreviations
-  opts.features.Enable(Fortran::common::LanguageFeature::LogicalAbbreviations,
+  opts.features.Enable(
+      Fortran::common::LanguageFeature::LogicalAbbreviations,
       args.hasFlag(clang::driver::options::OPT_flogical_abbreviations,
-          clang::driver::options::OPT_fno_logical_abbreviations, false));
+                   clang::driver::options::OPT_fno_logical_abbreviations,
+                   false));
 
   // -f{no-}xor-operator
-  opts.features.Enable(Fortran::common::LanguageFeature::XOROperator,
+  opts.features.Enable(
+      Fortran::common::LanguageFeature::XOROperator,
       args.hasFlag(clang::driver::options::OPT_fxor_operator,
                    clang::driver::options::OPT_fno_xor_operator, false));
 
   // -fno-automatic
   if (args.hasArg(clang::driver::options::OPT_fno_automatic)) {
     opts.features.Enable(Fortran::common::LanguageFeature::DefaultSave);
   }
 
   if (args.hasArg(
           clang::driver::options::OPT_falternative_parameter_statement)) {
static std::string getOpenMPHeadersDir() {
   return std::string(includePath);
 }
 
 /// Parses all preprocessor input arguments and populates the preprocessor
 /// options accordingly.
 ///
 /// \param [in] opts The preprocessor options instance
 /// \param [out] args The list of input arguments
-static void parsePreprocessorArgs(
-    Fortran::frontend::PreprocessorOptions &opts, llvm::opt::ArgList &args) {
+static void parsePreprocessorArgs(Fortran::frontend::PreprocessorOptions &opts,
+                                  llvm::opt::ArgList &args) {
   // Add macros from the command line.
-  for (const auto *currentArg : args.filtered(
-           clang::driver::options::OPT_D, clang::driver::options::OPT_U)) {
+  for (const auto *currentArg : args.filtered(clang::driver::options::OPT_D,
+                                              clang::driver::options::OPT_U)) {
     if (currentArg->getOption().matches(clang::driver::options::OPT_D)) {
       opts.addMacroDef(currentArg->getValue());
     } else {
       opts.addMacroUndef(currentArg->getValue());
     }
   }
 
   // Add the ordered list of -I's.
   for (const auto *currentArg : args.filtered(clang::driver::options::OPT_I))
     opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue());
 
   // Prepend the ordered list of -intrinsic-modules-path
   // to the default location to search.
   for (const auto *currentArg :
        args.filtered(clang::driver::options::OPT_fintrinsic_modules_path))
     opts.searchDirectoriesFromIntrModPath.emplace_back(currentArg->getValue());
 
   // -cpp/-nocpp
   if (const auto *currentArg = args.getLastArg(
           clang::driver::options::OPT_cpp, clang::driver::options::OPT_nocpp))
     opts.macrosFlag =
         (currentArg->getOption().matches(clang::driver::options::OPT_cpp))
             ? PPMacrosFlag::Include
             : PPMacrosFlag::Exclude;
 
   opts.noReformat = args.hasArg(clang::driver::options::OPT_fno_reformat);
   opts.noLineDirectives = args.hasArg(clang::driver::options::OPT_P);
 }
 
 /// Parses all semantic related arguments and populates the variables
 /// options accordingly. Returns false if new errors are generated.
 static bool parseSemaArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
                           clang::DiagnosticsEngine &diags) {
   unsigned numErrorsBefore = diags.getNumErrors();
 
   // -J/module-dir option
   auto moduleDirList =
       args.getAllArgValues(clang::driver::options::OPT_module_dir);
   // User can only specify -J/-module-dir once
   // https://gcc.gnu.org/onlinedocs/gfortran/Directory-Options.html
   if (moduleDirList.size() > 1) {
     const unsigned diagID =
         diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
                               "Only one '-module-dir/-J' option allowed");
     diags.Report(diagID);
   }
   if (moduleDirList.size() == 1)
     res.setModuleDir(moduleDirList[0]);
 
   // -fdebug-module-writer option
   if (args.hasArg(clang::driver::options::OPT_fdebug_module_writer)) {
     res.setDebugModuleDir(true);
res.setUseAnalyzedObjectsForUnparse(args.hasFlag(
       clang::driver::options::OPT_fno_analyzed_objects_for_unparse, true));
 
   return diags.getNumErrors() == numErrorsBefore;
 }
 
 /// Parses all diagnostics related arguments and populates the variables
 /// options accordingly. Returns false if new errors are generated.
 static bool parseDiagArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
                           clang::DiagnosticsEngine &diags) {
   unsigned numErrorsBefore = diags.getNumErrors();
 
   // -Werror option
   // TODO: Currently throws a Diagnostic for anything other than -W<error>,
   // this has to change when other -W<opt>'s are supported.
   if (args.hasArg(clang::driver::options::OPT_W_Joined)) {
     if (args.getLastArgValue(clang::driver::options::OPT_W_Joined)
             .equals("error")) {
       res.setWarnAsErr(true);
     } else {
       const unsigned diagID =
           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
                                 "Only `-Werror` is supported currently.");
       diags.Report(diagID);
     }
   }
 
   // Default to off for `flang-new -fc1`.
   res.getFrontendOpts().showColors =
       parseShowColorsArgs(args, /*defaultDiagColor=*/false);
 
   return diags.getNumErrors() == numErrorsBefore;
 }
 
 /// Parses all Dialect related arguments and populates the variables
 /// options accordingly. Returns false if new errors are generated.
 static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
                              clang::DiagnosticsEngine &diags) {
   unsigned numErrorsBefore = diags.getNumErrors();
 
   // -fdefault* family
   if (args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
     res.getDefaultKinds().set_defaultRealKind(8);
     res.getDefaultKinds().set_doublePrecisionKind(16);
   }
   if (args.hasArg(clang::driver::options::OPT_fdefault_integer_8)) {
     res.getDefaultKinds().set_defaultIntegerKind(8);
     res.getDefaultKinds().set_subscriptIntegerKind(8);
     res.getDefaultKinds().set_sizeIntegerKind(8);
   }
   if (args.hasArg(clang::driver::options::OPT_fdefault_double_8)) {
     if (!args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
       // -fdefault-double-8 has to be used with -fdefault-real-8
       // to be compatible with gfortran
-      const unsigned diagID =
-          diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
-              "Use of `-fdefault-double-8` requires `-fdefault-real-8`");
+      const unsigned diagID = diags.getCustomDiagID(
+          clang::DiagnosticsEngine::Error,
       diags.Report(diagID);
     }
     // https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html
     res.getDefaultKinds().set_doublePrecisionKind(8);
   }
   if (args.hasArg(clang::driver::options::OPT_flarge_sizes))
     res.getDefaultKinds().set_sizeIntegerKind(8);
 
static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
   if (args.hasArg(clang::driver::options::OPT_std_EQ)) {
     auto standard = args.getLastArgValue(clang::driver::options::OPT_std_EQ);
     // We only allow f2018 as the given standard
     if (standard.equals("f2018")) {
       res.setEnableConformanceChecks();
     } else {
       const unsigned diagID =
           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
                                 "Only -std=f2018 is allowed currently.");
       diags.Report(diagID);
     }
   }
   return diags.getNumErrors() == numErrorsBefore;
 }
 
 /// Parses all floating point related arguments and populates the
 /// CompilerInvocation accordingly.

 // this. Also at some point we will need to differentiate between different
 // targets and add dedicated predefines for each.
 void CompilerInvocation::setDefaultPredefinitions() {
   auto &fortranOptions = getFortranOpts();
   const auto &frontendOptions = getFrontendOpts();
 
   // Populate the macro list with version numbers and other predefinitions.
   fortranOptions.predefinitions.emplace_back("__flang__", "1");
-  fortranOptions.predefinitions.emplace_back(
-      "__flang_major__", FLANG_VERSION_MAJOR_STRING);
-  fortranOptions.predefinitions.emplace_back(
-      "__flang_minor__", FLANG_VERSION_MINOR_STRING);
-  fortranOptions.predefinitions.emplace_back(
-      "__flang_patchlevel__", FLANG_VERSION_PATCHLEVEL_STRING);
+  fortranOptions.predefinitions.emplace_back("__flang_major__",
+                                             FLANG_VERSION_MAJOR_STRING);
+  fortranOptions.predefinitions.emplace_back("__flang_minor__",
+                                             FLANG_VERSION_MINOR_STRING);
+  fortranOptions.predefinitions.emplace_back("__flang_patchlevel__",
+                                             FLANG_VERSION_PATCHLEVEL_STRING);
 
   // Add predefinitions based on extensions enabled
   if (frontendOptions.features.IsEnabled(
           Fortran::common::LanguageFeature::OpenACC)) {
     fortranOptions.predefinitions.emplace_back("_OPENACC", "202011");
   }
   if (frontendOptions.features.IsEnabled(
           Fortran::common::LanguageFeature::OpenMP)) {

flang/lib/Frontend/FrontendOptions.cpp

 
 #include "flang/Frontend/FrontendOptions.h"
 
 using namespace Fortran::frontend;
 
 bool Fortran::frontend::isFixedFormSuffix(llvm::StringRef suffix) {
   // Note: Keep this list in-sync with flang/test/lit.cfg.py
   return suffix == "f77" || suffix == "f" || suffix == "F" || suffix == "ff" ||
-      suffix == "for" || suffix == "FOR" || suffix == "fpp" || suffix == "FPP";
+         suffix == "for" || suffix == "FOR" || suffix == "fpp" ||
+         suffix == "FPP";
 }
 
 bool Fortran::frontend::isFreeFormSuffix(llvm::StringRef suffix) {
   // Note: Keep this list in-sync with flang/test/lit.cfg.py
   // TODO: Add Cuda Fortan files (i.e. `*.cuf` and `*.CUF`).
   return suffix == "f90" || suffix == "F90" || suffix == "ff90" ||
          suffix == "f95" || suffix == "F95" || suffix == "ff95" ||
          suffix == "f03" || suffix == "F03" || suffix == "f08" ||
          suffix == "F08" || suffix == "f18" || suffix == "F18";
 }
 
 bool Fortran::frontend::isToBePreprocessed(llvm::StringRef suffix) {
   return suffix == "F" || suffix == "FOR" || suffix == "fpp" ||
          suffix == "FPP" || suffix == "F90" || suffix == "F95" ||
          suffix == "F03" || suffix == "F08" || suffix == "F18";
 }
 
 InputKind FrontendOptions::getInputKindForExtension(llvm::StringRef extension) {
   if (isFixedFormSuffix(extension) || isFreeFormSuffix(extension)) {
     return Language::Fortran;
   }
 
   if (extension == "bc" || extension == "ll")
     return Language::LLVM_IR;
   if (extension == "fir" || extension == "mlir")
     return Language::MLIR;
 
   return Language::Unknown;
 }

flang/lib/Frontend/TextDiagnosticPrinter.cpp

void TextDiagnosticPrinter::HandleDiagnostic(
 
   llvm::raw_svector_ostream diagMessageStream(outStr);
 
   if (!prefix.empty())
     os << prefix << ": ";
 
   // We only emit diagnostics in contexts that lack valid source locations.
   assert(!info.getLocation().isValid() &&
          "Diagnostics with valid source location are not supported");
 
   Fortran::frontend::TextDiagnostic::printDiagnosticLevel(os, level,
                                                           diagOpts->ShowColors);
   Fortran::frontend::TextDiagnostic::printDiagnosticMessage(
       os,
       /*IsSupplemental=*/level == clang::DiagnosticsEngine::Note,
       diagMessageStream.str(), diagOpts->ShowColors);
 
   os.flush();
 }

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

createFrontendAction(CompilerInstance &ci) {
   case GetDefinition:
     return std::make_unique<GetDefinitionAction>();
   case GetSymbolsSources:
     return std::make_unique<GetSymbolsSourcesAction>();
   case InitOnly:
     return std::make_unique<InitOnlyAction>();
   case PluginAction: {
     for (const FrontendPluginRegistry::entry &plugin :
          FrontendPluginRegistry::entries()) {
       if (plugin.getName() == ci.getFrontendOpts().actionName) {
         std::unique_ptr<PluginParseTreeAction> p(plugin.instantiate());
         return std::move(p);
       }
     }
     unsigned diagID = ci.getDiagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "unable to find plugin '%0'");
     ci.getDiagnostics().Report(diagID) << ci.getFrontendOpts().actionName;
     return nullptr;
   }
   }
 
   llvm_unreachable("Invalid program action!");
 }
 
 bool executeCompilerInvocation(CompilerInstance *flang) {
   // Honor -help.
   if (flang->getFrontendOpts().showHelp) {
-    clang::driver::getDriverOptTable().printHelp(llvm::outs(),
-        "flang-new -fc1 [options] file...", "LLVM 'Flang' Compiler",
+    clang::driver::getDriverOptTable().printHelp(
+        llvm::outs(), "flang-new -fc1 [options] file...",
+        "LLVM 'Flang' Compiler",
         /*Include=*/clang::driver::options::FC1Option,
         /*Exclude=*/llvm::opt::DriverFlag::HelpHidden,
         /*ShowAllAliases=*/false);
     return true;
   }
 
   // Honor -version.
   if (flang->getFrontendOpts().showVersion) {

flang/lib/Optimizer/Builder/MutableBox.cpp

auto ifOp =
               // padding/trimming will occur in later assignment to it.
               assert(!lengthParams.empty() &&
                      "must provide length parameters for character");
               compareProperty(reader.readCharacterLength(), lengthParams[0]);
             } else if (box.isDerivedWithLenParameters()) {
               TODO(loc, "automatic allocation of derived type allocatable with "
                         "length parameters");
             }
-            auto ifOp =
-                builder
+            auto ifOp = builder
                             .genIfOp(loc, {addrType}, mustReallocate,
                                      /*withElseRegion=*/true)
                             .genThen([&]() {
-                      // If shape or length mismatch, allocate new storage.
-                      // When rhs is a scalar, keep the previous shape
-                      auto extents = shape.empty()
-                                         ? mlir::ValueRange(previousExtents)
-                                         : shape;
+                              // If shape or length mismatch, allocate new
+                              // storage. When rhs is a scalar, keep the
+                              // previous shape
+                              auto extents =
+                                  shape.empty()
                               auto heap = allocateAndInitNewStorage(
                                   builder, loc, box, extents, lengthParams,
                                   ".auto.alloc");
                               if (storageHandler)
                                 storageHandler(getExtValForStorage(heap));
                               builder.create<fir::ResultOp>(loc, heap);
                             })
                             .genElse([&]() {
                               if (storageHandler)
                                 storageHandler(getExtValForStorage(addr));
                               builder.create<fir::ResultOp>(loc, addr);
                             });
             ifOp.end();
             auto newAddr = ifOp.getResults()[0];
             builder.create<fir::ResultOp>(
                 loc, mlir::ValueRange{mustReallocate, newAddr});
           })
           .genElse([&]() {
             auto trueValue = builder.createBool(loc, true);
             // The box is not yet allocated, simply allocate it.

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

void doComplexArg(mlir::func::FuncOp func, A cmplx, B &newInTys, C &fixups) {
     for (auto e : llvm::enumerate(m)) {
       auto &tup = e.value();
       auto index = e.index();
       auto attr = std::get<fir::CodeGenSpecifics::Attributes>(tup);
       auto argTy = std::get<mlir::Type>(tup);
       auto argNo = newInTys.size();
       if (attr.isByVal()) {
         if (auto align = attr.getAlignment())
-          fixups.emplace_back(
-              FixupTy::Codes::ArgumentAsLoad, argNo,
+          fixups.emplace_back(FixupTy::Codes::ArgumentAsLoad, argNo,
                               [=](mlir::func::FuncOp func) {
                                 auto elemType = fir::dyn_cast_ptrOrBoxEleTy(
                                     func.getFunctionType().getInput(argNo));
                                 func.setArgAttr(argNo, "llvm.byval",
                                                 mlir::TypeAttr::get(elemType));
-                func.setArgAttr(argNo, "llvm.align",
+                                func.setArgAttr(
+                                    argNo, "llvm.align",
                                     rewriter->getIntegerAttr(
                                         rewriter->getIntegerType(32), align));
                               });
         else
           fixups.emplace_back(FixupTy::Codes::ArgumentAsLoad, newInTys.size(),
                               [=](mlir::func::FuncOp func) {
                                 auto elemType = fir::dyn_cast_ptrOrBoxEleTy(
                                     func.getFunctionType().getInput(argNo));
                                 func.setArgAttr(argNo, "llvm.byval",
                                                 mlir::TypeAttr::get(elemType));
                               });

flang/lib/Semantics/check-acc-structure.h

#include "llvm/Frontend/OpenACC/ACC.inc"
   // Clauses
   void Leave(const parser::AccClauseList &);
   void Enter(const parser::AccClause &);
 
 #define GEN_FLANG_CLAUSE_CHECK_ENTER
 #include "llvm/Frontend/OpenACC/ACC.inc"
 
 private:
-
   bool CheckAllowedModifier(llvm::acc::Clause clause);
   bool IsComputeConstruct(llvm::acc::Directive directive) const;
   bool IsInsideComputeConstruct() const;
   void CheckNotInComputeConstruct();
   llvm::StringRef getClauseName(llvm::acc::Clause clause) override;
   llvm::StringRef getDirectiveName(llvm::acc::Directive directive) override;
 };
 
 } // namespace Fortran::semantics
 
 #endif // FORTRAN_SEMANTICS_CHECK_ACC_STRUCTURE_H_

flang/lib/Semantics/check-declarations.cpp

 // C760 constraints on the passed-object dummy argument
 // C757 constraints on procedure pointer components
 void CheckHelper::CheckPassArg(
     const Symbol &proc, const Symbol *interface0, const WithPassArg &details) {
   if (proc.attrs().test(Attr::NOPASS)) {
     return;
   }
   const auto &name{proc.name()};
-  const Symbol *interface {
-    interface0 ? FindInterface(*interface0) : nullptr
-  };
+  const Symbol *interface { interface0 ? FindInterface(*interface0) : nullptr };
   if (!interface) {
     messages_.Say(name,
         "Procedure component '%s' must have NOPASS attribute or explicit interface"_err_en_US,
         name);
     return;
   }
   const auto *subprogram{interface->detailsIf<SubprogramDetails>()};
   if (!subprogram) {

flang/lib/Semantics/data-to-inits.h

 #include "flang/Common/interval.h"
 #include "flang/Evaluate/initial-image.h"
 #include <list>
 #include <map>
 
 namespace Fortran::parser {
 struct DataStmtSet;
 struct DataStmtValue;
-}
+} // namespace Fortran::parser
 namespace Fortran::evaluate {
 class ExpressionAnalyzer;
 }
 namespace Fortran::semantics {
 
 class Symbol;
 
 struct SymbolDataInitialization {

flang/lib/Semantics/expression.cpp

Say(dueToNullActuals
           : "No specific procedure of generic '%s' matches the actual arguments"_err_en_US,
       symbol.name());
 }
 
 auto ExpressionAnalyzer::GetCalleeAndArguments(
     const parser::ProcedureDesignator &pd, ActualArguments &&arguments,
     bool isSubroutine, bool mightBeStructureConstructor)
     -> std::optional<CalleeAndArguments> {
-  return common::visit(
-      common::visitors{
+  return common::visit(common::visitors{
                            [&](const parser::Name &name) {
-            return GetCalleeAndArguments(name, std::move(arguments),
-                isSubroutine, mightBeStructureConstructor);
+                             return GetCalleeAndArguments(name,
+                                 std::move(arguments), isSubroutine,
+                                 mightBeStructureConstructor);
                            },
                            [&](const parser::ProcComponentRef &pcr) {
                              return AnalyzeProcedureComponentRef(
                                  pcr, std::move(arguments), isSubroutine);
                            },
                        },
       pd.u);
 }
 
 auto ExpressionAnalyzer::GetCalleeAndArguments(const parser::Name &name,
     ActualArguments &&arguments, bool isSubroutine,
     bool mightBeStructureConstructor) -> std::optional<CalleeAndArguments> {
   const Symbol *symbol{name.symbol};
   if (context_.HasError(symbol)) {

 }
 
 void ArgumentAnalyzer::Analyze(
     const parser::ActualArgSpec &arg, bool isSubroutine) {
   // TODO: Actual arguments that are procedures and procedure pointers need to
   // be detected and represented (they're not expressions).
   // TODO: C1534: Don't allow a "restricted" specific intrinsic to be passed.
   std::optional<ActualArgument> actual;
-  common::visit(
-      common::visitors{
+  common::visit(common::visitors{
                     [&](const common::Indirection<parser::Expr> &x) {
                       actual = AnalyzeExpr(x.value());
                       SetArgSourceLocation(actual, x.value().source);
                     },
                     [&](const parser::AltReturnSpec &label) {
                       if (!isSubroutine) {
-              context_.Say("alternate return specification may not appear on"
+                        context_.Say(
+                            "alternate return specification may not appear on"
                             " function reference"_err_en_US);
                       }
                       actual = ActualArgument(label.v);
                     },
                     [&](const parser::ActualArg::PercentRef &) {
                       context_.Say("%REF() intrinsic for arguments"_todo_en_US);
                     },
                     [&](const parser::ActualArg::PercentVal &) {
                       context_.Say("%VAL() intrinsic for arguments"_todo_en_US);
                     },
                 },
       std::get<parser::ActualArg>(arg.t).u);
   if (actual) {
     if (const auto &argKW{std::get<std::optional<parser::Keyword>>(arg.t)}) {
       actual->set_keyword(argKW->v.source);
     }
     actuals_.emplace_back(std::move(*actual));
   } else {
     fatalErrors_ = true;

flang/lib/Semantics/mod-file.cpp

void ModFileWriter::PutProcEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   if (symbol.attrs().test(Attr::INTRINSIC)) {
     os << "intrinsic::" << symbol.name() << '\n';
     if (symbol.attrs().test(Attr::PRIVATE)) {
       os << "private::" << symbol.name() << '\n';
     }
     return;
   }
   const auto &details{symbol.get<ProcEntityDetails>()};
-  const ProcInterface &interface{details.interface()};
+  const ProcInterface &interface { details.interface() };
   Attrs attrs{symbol.attrs()};
   if (details.passName()) {
     attrs.reset(Attr::PASS);
   }
   PutEntity(
       os, symbol,
       [&]() {
         os << "procedure(";

flang/lib/Semantics/symbol.cpp

SourceName GenericKind::AsFortran(DefinedIo x) {
   return {name, std::strlen(name)};
 }
 
 bool GenericKind::Is(GenericKind::OtherKind x) const {
   const OtherKind *y{std::get_if<OtherKind>(&u)};
   return y && *y == x;
 }
 
-bool SymbolOffsetCompare::operator()(const SymbolRef &x, const SymbolRef &y) const {
+bool SymbolOffsetCompare::operator()(
+    const SymbolRef &x, const SymbolRef &y) const {
   const Symbol *xCommon{FindCommonBlockContaining(*x)};
   const Symbol *yCommon{FindCommonBlockContaining(*y)};
   if (xCommon) {
     if (yCommon) {
       const SymbolSourcePositionCompare sourceCmp;
       if (sourceCmp(*xCommon, *yCommon)) {
         return true;
       } else if (sourceCmp(*yCommon, *xCommon)) {

flang/lib/Semantics/tools.cpp

const evaluate::Assignment *GetAssignment(
   return x.typedAssignment ? common::GetPtrFromOptional(x.typedAssignment->v)
                            : nullptr;
 }
 
 const Symbol *FindInterface(const Symbol &symbol) {
   return common::visit(
       common::visitors{
           [](const ProcEntityDetails &details) {
-            const Symbol *interface {
-              details.interface().symbol()
-            };
+            const Symbol *interface { details.interface().symbol() };
             return interface ? FindInterface(*interface) : nullptr;
           },
           [](const ProcBindingDetails &details) {
             return FindInterface(details.symbol());
           },
           [&](const SubprogramDetails &) { return &symbol; },
           [](const UseDetails &details) {
             return FindInterface(details.symbol());

flang/lib/Semantics/type.cpp

if (MaybeExpr & init{details->init()}) {
       init = IsPointer(newSymbol)
           ? Fold(std::move(*init))
           : evaluate::NonPointerInitializationExpr(
                 newSymbol, std::move(*init), foldingContext());
     }
   } else if (auto *procDetails{newSymbol.detailsIf<ProcEntityDetails>()}) {
     // We have a procedure pointer.  Instantiate its return type
     if (const DeclTypeSpec * returnType{InstantiateType(newSymbol)}) {
-      ProcInterface &interface{procDetails->interface()};
+      ProcInterface &interface { procDetails->interface() };
       if (!interface.symbol()) {
         // Don't change the type for interfaces based on symbols
         interface.set_type(*returnType);
       }
     }
   }
 }
 

flang/runtime/derived.cpp

void Finalize(
   bool recurse{parentType && !parentType->noFinalizationNeeded()};
   // If there's a finalizable parent component, handle it last, as required
   // by the Fortran standard (7.5.6.2), and do so recursively with the same
   // descriptor so that the rank is preserved.
   const Descriptor &componentDesc{derived.component()};
   std::size_t myComponents{componentDesc.Elements()};
   std::size_t elements{descriptor.Elements()};
   std::size_t byteStride{descriptor.ElementBytes()};
-  for (auto k{recurse
-               ? std::size_t{1} /* skip first component, it's the parent */
+  for (auto k{recurse ? std::size_t{1}
+                      /* skip first component, it's the parent */
                       : 0};
        k < myComponents; ++k) {
     const auto &comp{
         *componentDesc.ZeroBasedIndexedElement<typeInfo::Component>(k)};
     if (comp.genre() == typeInfo::Component::Genre::Allocatable ||
         comp.genre() == typeInfo::Component::Genre::Automatic) {
       if (const typeInfo::DerivedType * compType{comp.derivedType()}) {
         if (!compType->noFinalizationNeeded()) {
           for (std::size_t j{0}; j < elements; ++j) {

flang/tools/flang-driver/driver.cpp

static int executeFC1Tool(llvm::SmallVectorImpl<const char *> &argV) {
 
   // Reject unknown tools.
   // ATM it only supports fc1. Any fc1[*] is rejected.
   llvm::errs() << "error: unknown integrated tool '" << tool << "'. "
                << "Valid tools include '-fc1'.\n";
   return 1;
 }
 
-static void ExpandResponseFiles(
-    llvm::StringSaver &saver, llvm::SmallVectorImpl<const char *> &args) {
+static void ExpandResponseFiles(llvm::StringSaver &saver,
+                                llvm::SmallVectorImpl<const char *> &args) {
   // We're defaulting to the GNU syntax, since we don't have a CL mode.
   llvm::cl::TokenizerCallback tokenizer = &llvm::cl::TokenizeGNUCommandLine;
   llvm::cl::ExpansionContext ExpCtx(saver.getAllocator(), tokenizer);
   if (llvm::Error Err = ExpCtx.expandResponseFiles(args)) {
     llvm::errs() << toString(std::move(Err)) << '\n';
   }
 }
 
 int main(int argc, const char **argv) {
 
   // Initialize variables to call the driver
   llvm::InitLLVM x(argc, argv);
   llvm::SmallVector<const char *, 256> args(argv, argv + argc);
 
   clang::driver::ParsedClangName targetandMode("flang", "--driver-mode=flang");
   std::string driverPath = getExecutablePath(args[0]);
 
   llvm::BumpPtrAllocator a;
   llvm::StringSaver saver(a);
   ExpandResponseFiles(saver, args);
 
   // Check if flang-new is in the frontend mode
-  auto firstArg = std::find_if(
-      args.begin() + 1, args.end(), [](const char *a) { return a != nullptr; });
+  auto firstArg = std::find_if(args.begin() + 1, args.end(),
+                               [](const char *a) { return a != nullptr; });
   if (firstArg != args.end()) {
     if (llvm::StringRef(args[1]).startswith("-cc1")) {
       llvm::errs() << "error: unknown integrated tool '" << args[1] << "'. "
                    << "Valid tools include '-fc1'.\n";
       return 1;
     }
     // Call flang-new frontend
     if (llvm::StringRef(args[1]).startswith("-fc1")) {
int main(int argc, const char **argv) {
 
   diagClient->setPrefix(
       std::string(llvm::sys::path::stem(getExecutablePath(args[0]))));
 
   clang::DiagnosticsEngine diags(diagID, &*diagOpts, diagClient);
 
   // Prepare the driver
   clang::driver::Driver theDriver(driverPath,
-      llvm::sys::getDefaultTargetTriple(), diags, "flang LLVM compiler");
+                                  llvm::sys::getDefaultTargetTriple(), diags,
+                                  "flang LLVM compiler");
   theDriver.setTargetAndMode(targetandMode);
   std::unique_ptr<clang::driver::Compilation> c(
       theDriver.BuildCompilation(args));
   llvm::SmallVector<std::pair<int, const clang::driver::Command *>, 4>
       failingCommands;
 
   // Run the driver
   int res = 1;

flang/unittests/Optimizer/FIRContextTest.cpp

 //===- FIRContextTest.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Support/FIRContext.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "gtest/gtest.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinOps.h"
+#include "flang/Optimizer/Support/KindMapping.h"
 #include "llvm/Support/Host.h"
-#include "gtest/gtest.h"
 #include <string>
 
 using namespace fir;
 
 struct StringAttributesTests : public testing::Test {
 public:
   void SetUp() {
     kindMap = new KindMapping(&context, kindMapInit, "r42a10c14d28i40l41");

flang/unittests/Runtime/Time.cpp

ASSERT_TRUE(ec != std::errc::invalid_argument &&
         ec != std::errc::result_out_of_range);
     ASSERT_GE(number, 0);
     auto hours = number / 100;
     auto minutes = number % 100;
     EXPECT_LE(hours, 23);
     EXPECT_LE(minutes, 59);
   }
 }
-