[flang] Add clang-tidy check for braces around if

[rovka]

Summary

Flang diverges from the llvm coding style in that it requires braces
around the bodies of if/while/etc statements, even when the body is
a single statement.

This commit adds the readability-braces-around-statements check to
flang's clang-tidy config file. Hopefully the premerge bots will pick it
up and report violations in Phabricator.

We also explicitly disable the check in the directories corresponding to
the Lower and Optimizer libraries, which rely heavily on mlir and llvm
and therefore follow their coding style.

[klausler]

This should probably not be applied to all of f18; the lowering code, which interacts heavily with mlir and llvm, respects their styles.

[rovka]

In D104100#2813793, @klausler wrote:

This should probably not be applied to all of f18; the lowering code, which interacts heavily with mlir and llvm, respects their styles.

Right, makes sense. I'll look into that and try to update the patch. Thanks.

[rovka]

I disabled the check for Optimizer and Lower. With the newest version of the patch, I'm seeing several violations in lib/Semantics, tools (f18, f18-parse-demo, tco) and 2 rogue ones in the runtime. I'm going to fix the ones from the runtime, but I'm not sure about the others. What's the preferred style for lib/Semantics and tools?

[jeanPerier]

tco, fir-opt and bbc tools are lowering tools, so they currently use llvm style.

[klausler]

In D104100#2816392, @rovka wrote:

I disabled the check for Optimizer and Lower. With the newest version of the patch, I'm seeing several violations in lib/Semantics, tools (f18, f18-parse-demo, tco) and 2 rogue ones in the runtime. I'm going to fix the ones from the runtime, but I'm not sure about the others. What's the preferred style for lib/Semantics and tools?

I wouldn't worry about the tools; few if any of those will survive in the llvm tree. The semantics code uses the stricter style.

[mehdi_amini]

In D104100#2813793, @klausler wrote:

This should probably not be applied to all of f18; the lowering code, which interacts heavily with mlir and llvm, respects their styles.

I thought not having readability-braces-around-statements was the llvm/mlir default?

[mehdi_amini]

In D104100#2817259, @mehdi_amini wrote:

In D104100#2813793, @klausler wrote:

This should probably not be applied to all of f18; the lowering code, which interacts heavily with mlir and llvm, respects their styles.

I thought not having readability-braces-around-statements was the llvm/mlir default?

Ah I misunderstood what the current patch is doing...

[schweitz]

flang/include/flang/Lower/.clang-tidy

1

Are this explicit removals really required? clang-tidy is supposed to use the .clang-tidy from the nearest parent and InheritParentConfig is not set.

[rovka]

In D104100#2817080, @klausler wrote:

In D104100#2816392, @rovka wrote:

I disabled the check for Optimizer and Lower. With the newest version of the patch, I'm seeing several violations in lib/Semantics, tools (f18, f18-parse-demo, tco) and 2 rogue ones in the runtime. I'm going to fix the ones from the runtime, but I'm not sure about the others. What's the preferred style for lib/Semantics and tools?

I wouldn't worry about the tools; few if any of those will survive in the llvm tree. The semantics code uses the stricter style.

Just to clarify, by stricter style you mean *with* braces?

In any case, I'm uploading a new version with all the changes required to make flang clean with respect to this check - no braces in Lower, Optimizer and tools, braces everywhere else.

flang/include/flang/Lower/.clang-tidy

1

Actually InheritParentConfig is set to true in all of these, so we do need to explicitly remove them.

[awarzynski]

Could you also update https://github.com/llvm/llvm-project/blob/main/flang/docs/C%2B%2Bstyle.md#layout to reflect this change? Otherwise our documentation and clang-tidy scripts are out-of-sync. Thank you!

[klausler]

Just to clarify, by stricter style you mean *with* braces?

Yes, I do.

[rovka]

In D104100#2819439, @awarzynski wrote:

Could you also update https://github.com/llvm/llvm-project/blob/main/flang/docs/C%2B%2Bstyle.md#layout to reflect this change? Otherwise our documentation and clang-tidy scripts are out-of-sync. Thank you!

Right, thanks for pointing that out! I added something, feel free to rephrase it :)

flang/.clang-tidy

-Checks: '-llvm-include-order,-readability-identifier-naming,-clang-diagnostic-*'
+Checks: '-llvm-include-order,readability-braces-around-statements,-readability-identifier-naming,-clang-diagnostic-*'
 InheritParentConfig: true

flang/docs/C++style.md

 1. Don't indent the bodies of namespaces, even when nested.
 1. Function result types go on the same line as the function and argument
 names.
 
 Don't try to make columns of variable names or comments
 align vertically -- they are maintenance problems.
 
 Always wrap the bodies of `if()`, `else`, `while()`, `for()`, `do`, &c.
-with braces, even when the body is a single statement or empty.  The
+with braces, even when the body is a single statement or empty.  Note that this
+diverges from the LLVM coding style.  In parts of the codebase that make heavy
+use of LLVM or MLIR APIs (e.g. the Lower and Optimizer libraries), use the
+LLVM style instead.  The
 opening `{` goes on
 the end of the line, not on the next line.  Functions also put the opening
 `{` after the formal arguments or new-style result type, not on the next
 line.  Use `{}` for empty inline constructors and destructors in classes.
 
 If any branch of an `if`/`else if`/`else` cascade ends with a return statement,
 they all should, with the understanding that the cases are all unexceptional.
 When testing for an error case that should cause an early return, do so with

flang/include/flang/Lower/.clang-tidy

-Checks: 'readability-identifier-naming,llvm-include-order,clang-diagnostic-*'
+Checks: '-readability-braces-around-statements,readability-identifier-naming,llvm-include-order,clang-diagnostic-*'
 InheritParentConfig: true
 CheckOptions:
   - key:             readability-identifier-naming.MemberCase
     value:           camelBack
   - key:             readability-identifier-naming.ParameterCase
     value:           camelBack
   - key:             readability-identifier-naming.VariableCase
     value:           camelBack

flang/include/flang/Optimizer/.clang-tidy

-Checks: 'readability-identifier-naming,llvm-include-order,clang-diagnostic-*'
+Checks: '-readability-braces-around-statements,readability-identifier-naming,llvm-include-order,clang-diagnostic-*'
 InheritParentConfig: true
 CheckOptions:
   - key:             readability-identifier-naming.MemberCase
     value:           camelBack
   - key:             readability-identifier-naming.ParameterCase
     value:           camelBack
   - key:             readability-identifier-naming.VariableCase
     value:           camelBack

flang/lib/Lower/.clang-tidy

-Checks: 'readability-identifier-naming,llvm-include-order,clang-diagnostic-*'
+Checks: '-readability-braces-around-statements,readability-identifier-naming,llvm-include-order,clang-diagnostic-*'
 InheritParentConfig: true
 CheckOptions:
   - key:             readability-identifier-naming.MemberCase
     value:           camelBack
   - key:             readability-identifier-naming.ParameterCase
     value:           camelBack
   - key:             readability-identifier-naming.VariableCase
     value:           camelBack

flang/lib/Optimizer/.clang-tidy

-Checks: 'readability-identifier-naming,llvm-include-order,clang-diagnostic-*'
+Checks: '-readability-braces-around-statements,readability-identifier-naming,llvm-include-order,clang-diagnostic-*'
 InheritParentConfig: true
 CheckOptions:
   - key:             readability-identifier-naming.MemberCase
     value:           camelBack
   - key:             readability-identifier-naming.ParameterCase
     value:           camelBack
   - key:             readability-identifier-naming.VariableCase
     value:           camelBack

flang/lib/Semantics/canonicalize-acc.cpp

void CheckTileClauseRestriction(const C &x) {
     for (const auto &clause : accClauseList.v) {
       if (const auto *tileClause =
               std::get_if<parser::AccClause::Tile>(&clause.u)) {
         const parser::AccTileExprList &tileExprList = tileClause->v;
         const std::list<parser::AccTileExpr> &listTileExpr = tileExprList.v;
         std::size_t tileArgNb = listTileExpr.size();
 
         const auto &outer{std::get<std::optional<parser::DoConstruct>>(x.t)};
-        if (outer->IsDoConcurrent())
+        if (outer->IsDoConcurrent()) {
           return; // Tile is not allowed on DO CONURRENT
+        }
         for (const parser::DoConstruct *loop{&*outer}; loop && tileArgNb > 0;
              --tileArgNb) {
           const auto &block{std::get<parser::Block>(loop->t)};
           const auto it{block.begin()};
           loop = it != block.end() ? parser::Unwrap<parser::DoConstruct>(*it)
                                    : nullptr;
         }
 
         if (tileArgNb > 0) {
           messages_.Say(beginLoopDirective.source,
               "The loop construct with the TILE clause must be followed by %d "
               "tightly-nested loops"_err_en_US,
               listTileExpr.size());
         }
       }
     }
   }
 
   // Check constraint on line 1835 in Section 2.9
   // A tile and collapse clause may not appear on loop that is associated with
   // do concurrent.
   template <typename C, typename D>
   void CheckDoConcurrentClauseRestriction(const C &x) {
     const auto &doCons{std::get<std::optional<parser::DoConstruct>>(x.t)};
-    if (!doCons->IsDoConcurrent())
+    if (!doCons->IsDoConcurrent()) {
       return;
+    }
     const auto &beginLoopDirective = std::get<D>(x.t);
     const auto &accClauseList =
         std::get<parser::AccClauseList>(beginLoopDirective.t);
     for (const auto &clause : accClauseList.v) {
       if (std::holds_alternative<parser::AccClause::Collapse>(clause.u) ||
           std::holds_alternative<parser::AccClause::Tile>(clause.u)) {
         messages_.Say(beginLoopDirective.source,
             "TILE and COLLAPSE clause may not appear on loop construct "

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

return directive == llvm::acc::ACCD_parallel ||
       directive == llvm::acc::ACCD_parallel_loop ||
       directive == llvm::acc::ACCD_serial ||
       directive == llvm::acc::ACCD_serial_loop ||
       directive == llvm::acc::ACCD_kernels ||
       directive == llvm::acc::ACCD_kernels_loop;
 }
 
 bool AccStructureChecker::IsInsideComputeConstruct() const {
-  if (dirContext_.size() <= 1)
+  if (dirContext_.size() <= 1) {
     return false;
+  }
 
   // Check all nested context skipping the first one.
   for (std::size_t i = dirContext_.size() - 1; i > 0; --i) {
-    if (IsComputeConstruct(dirContext_[i - 1].directive))
+    if (IsComputeConstruct(dirContext_[i - 1].directive)) {
       return true;
     }
+  }
   return false;
 }
 
 void AccStructureChecker::CheckNotInComputeConstruct() {
-  if (IsInsideComputeConstruct())
+  if (IsInsideComputeConstruct()) {
     context_.Say(GetContext().directiveSource,
         "Directive %s may not be called within a compute region"_err_en_US,
         ContextDirectiveAsFortran());
   }
+}
 
 void AccStructureChecker::Enter(const parser::AccClause &x) {
   SetContextClause(x);
 }
 
 void AccStructureChecker::Leave(const parser::AccClauseList &) {}
 
 void AccStructureChecker::Enter(const parser::OpenACCBlockConstruct &x) {
void AccStructureChecker::Leave(
   const auto &declarativeDir{std::get<parser::AccDeclarativeDirective>(x.t)};
   const auto &scope{context_.FindScope(declarativeDir.source)};
   const Scope &containingScope{GetProgramUnitContaining(scope)};
   if (containingScope.kind() == Scope::Kind::Module) {
     for (auto cl : GetContext().actualClauses) {
       if (cl != llvm::acc::Clause::ACCC_create &&
           cl != llvm::acc::Clause::ACCC_copyin &&
           cl != llvm::acc::Clause::ACCC_device_resident &&
-          cl != llvm::acc::Clause::ACCC_link)
+          cl != llvm::acc::Clause::ACCC_link) {
         context_.Say(GetContext().directiveSource,
             "%s clause is not allowed on the %s directive in module "
             "declaration "
             "section"_err_en_US,
             parser::ToUpperCaseLetters(
                 llvm::acc::getOpenACCClauseName(cl).str()),
             ContextDirectiveAsFortran());
       }
     }
+  }
   dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCCombinedConstruct &x) {
   const auto &beginCombinedDir{
       std::get<parser::AccBeginCombinedDirective>(x.t)};
   const auto &combinedDir{
       std::get<parser::AccCombinedDirective>(beginCombinedDir.t)};
void AccStructureChecker::Enter(const parser::AccClause::Create &c) {
   }
 }
 
 void AccStructureChecker::Enter(const parser::AccClause::Copyin &c) {
   CheckAllowed(llvm::acc::Clause::ACCC_copyin);
   const auto &modifierClause{c.v};
   if (const auto &modifier{
           std::get<std::optional<parser::AccDataModifier>>(modifierClause.t)}) {
-    if (CheckAllowedModifier(llvm::acc::Clause::ACCC_copyin))
+    if (CheckAllowedModifier(llvm::acc::Clause::ACCC_copyin)) {
       return;
+    }
     if (modifier->v != parser::AccDataModifier::Modifier::ReadOnly) {
       context_.Say(GetContext().clauseSource,
           "Only the READONLY modifier is allowed for the %s clause "
           "on the %s directive"_err_en_US,
           parser::ToUpperCaseLetters(
               llvm::acc::getOpenACCClauseName(llvm::acc::Clause::ACCC_copyin)
                   .str()),
           ContextDirectiveAsFortran());
     }
   }
 }
 
 void AccStructureChecker::Enter(const parser::AccClause::Copyout &c) {
   CheckAllowed(llvm::acc::Clause::ACCC_copyout);
   const auto &modifierClause{c.v};
   if (const auto &modifier{
           std::get<std::optional<parser::AccDataModifier>>(modifierClause.t)}) {
-    if (CheckAllowedModifier(llvm::acc::Clause::ACCC_copyout))
+    if (CheckAllowedModifier(llvm::acc::Clause::ACCC_copyout)) {
       return;
+    }
     if (modifier->v != parser::AccDataModifier::Modifier::Zero) {
       context_.Say(GetContext().clauseSource,
           "Only the ZERO modifier is allowed for the %s clause "
           "on the %s directive"_err_en_US,
           parser::ToUpperCaseLetters(
               llvm::acc::getOpenACCClauseName(llvm::acc::Clause::ACCC_copyout)
                   .str()),
           ContextDirectiveAsFortran());

flang/lib/Semantics/check-omp-structure.cpp

if (const auto *linearClause{
       }
     }
   }
 
   if (!indexVars.empty()) {
     // Get collapse level, if given, to find which loops are "associated."
     std::int64_t collapseVal{GetOrdCollapseLevel(x)};
     // Include the top loop if no collapse is specified
-    if (collapseVal == 0)
+    if (collapseVal == 0) {
       collapseVal = 1;
+    }
 
     // Match the loop index variables with the collected symbols from linear
     // clauses.
     if (const auto &loopConstruct{
             std::get<std::optional<parser::DoConstruct>>(x.t)}) {
       for (const parser::DoConstruct *loop{&*loopConstruct}; loop;) {
         if (loop->IsDoNormal()) {
           const parser::Name &itrVal{GetLoopIndex(loop)};
           if (itrVal.symbol) {
             // Remove the symbol from the collcted set
             indexVars.erase(*(itrVal.symbol));
           }
           collapseVal--;
-          if (collapseVal == 0)
+          if (collapseVal == 0) {
             break;
           }
+        }
         // Get the next DoConstruct if block is not empty.
         const auto &block{std::get<parser::Block>(loop->t)};
         const auto it{block.begin()};
         loop = it != block.end() ? parser::Unwrap<parser::DoConstruct>(*it)
                                  : nullptr;
       }
     }
 
void OmpStructureChecker::Leave(const parser::OpenMPDeclareTargetConstruct &) {
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPExecutableAllocate &x) {
   isPredefinedAllocator = true;
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   const auto &objectList{std::get<std::optional<parser::OmpObjectList>>(x.t)};
   PushContextAndClauseSets(dir.source, llvm::omp::Directive::OMPD_allocate);
-  if (objectList)
+  if (objectList) {
     CheckIsVarPartOfAnotherVar(dir.source, *objectList);
   }
+}
 
 void OmpStructureChecker::Leave(const parser::OpenMPExecutableAllocate &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   const auto &objectList{std::get<std::optional<parser::OmpObjectList>>(x.t)};
   if (objectList)
     CheckPredefinedAllocatorRestriction(dir.source, *objectList);
   dirContext_.pop_back();
 }

flang/lib/Semantics/resolve-directives.cpp

if (prev != name.symbol) {
     name.symbol = prev;
   }
   return prev;
 }
 
 bool AccAttributeVisitor::Pre(const parser::OpenACCRoutineConstruct &x) {
   const auto &optName{std::get<std::optional<parser::Name>>(x.t)};
   if (optName) {
-    if (!ResolveName(*optName))
+    if (!ResolveName(*optName)) {
       context_.Say((*optName).source,
           "No function or subroutine declared for '%s'"_err_en_US,
           (*optName).source);
     }
+  }
   return true;
 }
 
 bool AccAttributeVisitor::Pre(const parser::AccBindClause &x) {
   if (const auto *name{std::get_if<parser::Name>(&x.u)}) {
-    if (!ResolveName(*name))
+    if (!ResolveName(*name)) {
       context_.Say(name->source,
           "No function or subroutine declared for '%s'"_err_en_US,
           name->source);
     }
+  }
   return true;
 }
 
 bool AccAttributeVisitor::Pre(const parser::OpenACCCombinedConstruct &x) {
   const auto &beginBlockDir{std::get<parser::AccBeginCombinedDirective>(x.t)};
   const auto &combinedDir{
       std::get<parser::AccCombinedDirective>(beginBlockDir.t)};
   switch (combinedDir.v) {

 }
 
 void AccAttributeVisitor::AllowOnlyArrayAndSubArray(
     const parser::AccObjectList &objectList) {
   for (const auto &accObject : objectList.v) {
     std::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
-              if (!IsLastNameArray(designator))
+              if (!IsLastNameArray(designator)) {
                 context_.Say(designator.source,
                     "Only array element or subarray are allowed in %s directive"_err_en_US,
                     parser::ToUpperCaseLetters(
                         llvm::acc::getOpenACCDirectiveName(
                             GetContext().directive)
                             .str()));
+              }
             },
             [&](const auto &name) {
               context_.Say(name.source,
                   "Only array element or subarray are allowed in %s directive"_err_en_US,
                   parser::ToUpperCaseLetters(
                       llvm::acc::getOpenACCDirectiveName(GetContext().directive)
                           .str()));
             },
         },
         accObject.u);
   }
 }
 
 void AccAttributeVisitor::DoNotAllowAssumedSizedArray(
     const parser::AccObjectList &objectList) {
   for (const auto &accObject : objectList.v) {
     std::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
               const auto &name{GetLastName(designator)};
-              if (name.symbol && semantics::IsAssumedSizeArray(*name.symbol))
+              if (name.symbol && semantics::IsAssumedSizeArray(*name.symbol)) {
                 context_.Say(designator.source,
                     "Assumed-size dummy arrays may not appear on the %s "
                     "directive"_err_en_US,
                     parser::ToUpperCaseLetters(
                         llvm::acc::getOpenACCDirectiveName(
                             GetContext().directive)
                             .str()));
+              }
             },
             [&](const auto &name) {
 
             },
         },
         accObject.u);
   }
 }

 
 void AccAttributeVisitor::EnsureAllocatableOrPointer(
     const llvm::acc::Clause clause, const parser::AccObjectList &objectList) {
   for (const auto &accObject : objectList.v) {
     std::visit(
         common::visitors{
             [&](const parser::Designator &designator) {
               const auto &lastName{GetLastName(designator)};
-              if (!IsAllocatableOrPointer(*lastName.symbol))
+              if (!IsAllocatableOrPointer(*lastName.symbol)) {
                 context_.Say(designator.source,
                     "Argument `%s` on the %s clause must be a variable or "
                     "array with the POINTER or ALLOCATABLE attribute"_err_en_US,
                     lastName.symbol->name(),
                     parser::ToUpperCaseLetters(
                         llvm::acc::getOpenACCClauseName(clause).str()));
+              }
             },
             [&](const auto &name) {
               context_.Say(name.source,
                   "Argument on the %s clause must be a variable or "
                   "array with the POINTER or ALLOCATABLE attribute"_err_en_US,
                   parser::ToUpperCaseLetters(
                       llvm::acc::getOpenACCClauseName(clause).str()));
             },
bool OmpAttributeVisitor::Pre(const parser::OpenMPDeclarativeAllocate &x) {
   const auto &list{std::get<parser::OmpObjectList>(x.t)};
   ResolveOmpObjectList(list, Symbol::Flag::OmpDeclarativeAllocateDirective);
   return false;
 }
 
 bool OmpAttributeVisitor::Pre(const parser::OpenMPExecutableAllocate &x) {
   PushContext(x.source, llvm::omp::Directive::OMPD_allocate);
   const auto &list{std::get<std::optional<parser::OmpObjectList>>(x.t)};
-  if (list)
+  if (list) {
     ResolveOmpObjectList(*list, Symbol::Flag::OmpExecutableAllocateDirective);
+  }
   return true;
 }
 
 void OmpAttributeVisitor::Post(const parser::OmpDefaultClause &x) {
   if (!dirContext_.empty()) {
     switch (x.v) {
     case parser::OmpDefaultClause::Type::Private:
       SetContextDefaultDSA(Symbol::Flag::OmpPrivate);
case parser::OmpDefaultClause::Type::None:
       break;
     }
   }
 }
 
 bool OmpAttributeVisitor::IsNestedInDirective(llvm::omp::Directive directive) {
   if (dirContext_.size() >= 1) {
     for (std::size_t i = dirContext_.size() - 1; i > 0; --i) {
-      if (dirContext_[i - 1].directive == directive)
+      if (dirContext_[i - 1].directive == directive) {
         return true;
       }
     }
+  }
   return false;
 }
 
 void OmpAttributeVisitor::Post(const parser::OpenMPExecutableAllocate &x) {
   bool hasAllocator = false;
   // TODO: Investigate whether searching the clause list can be done with
   // parser::Unwrap instead of the following loop
   const auto &clauseList{std::get<parser::OmpClauseList>(x.t)};
   for (const auto &clause : clauseList.v) {
-    if (std::get_if<parser::OmpClause::Allocator>(&clause.u))
+    if (std::get_if<parser::OmpClause::Allocator>(&clause.u)) {
       hasAllocator = true;
     }
+  }
 
-  if (IsNestedInDirective(llvm::omp::Directive::OMPD_target) && !hasAllocator)
+  if (IsNestedInDirective(llvm::omp::Directive::OMPD_target) && !hasAllocator) {
     // TODO: expand this check to exclude the case when a requires
     //       directive with the dynamic_allocators clause is present
     //       in the same compilation unit (OMP5.0 2.11.3).
     context_.Say(x.source,
         "ALLOCATE directives that appear in a TARGET region "
         "must specify an allocator clause"_err_en_US);
+  }
   PopContext();
 }
 
 // For OpenMP constructs, check all the data-refs within the constructs
 // and adjust the symbol for each Name if necessary
 void OmpAttributeVisitor::Post(const parser::Name &name) {
   auto *symbol{name.symbol};
   if (symbol && !dirContext_.empty() && GetContext().withinConstruct) {
if (!context.AnyFatalError()) {
       OmpAttributeVisitor{context}.Walk(node);
     }
   }
 }
 
 void OmpAttributeVisitor::CheckDataCopyingClause(
     const parser::Name &name, const Symbol &symbol, Symbol::Flag ompFlag) {
   const auto *checkSymbol{&symbol};
-  if (const auto *details{symbol.detailsIf<HostAssocDetails>()})
+  if (const auto *details{symbol.detailsIf<HostAssocDetails>()}) {
     checkSymbol = &details->symbol();
+  }
 
   if (ompFlag == Symbol::Flag::OmpCopyIn) {
     // List of items/objects that can appear in a 'copyin' clause must be
     // 'threadprivate'
-    if (!checkSymbol->test(Symbol::Flag::OmpThreadprivate))
+    if (!checkSymbol->test(Symbol::Flag::OmpThreadprivate)) {
       context_.Say(name.source,
           "Non-THREADPRIVATE object '%s' in COPYIN clause"_err_en_US,
           checkSymbol->name());
+    }
   } else if (ompFlag == Symbol::Flag::OmpCopyPrivate &&
       GetContext().directive == llvm::omp::Directive::OMPD_single) {
     // A list item that appears in a 'copyprivate' clause may not appear on a
     // 'private' or 'firstprivate' clause on a single construct
     if (IsObjectWithDSA(symbol) &&
         (symbol.test(Symbol::Flag::OmpPrivate) ||
             symbol.test(Symbol::Flag::OmpFirstPrivate))) {
       context_.Say(name.source,
if (ompFlag == Symbol::Flag::OmpCopyIn) {
     }
   }
 }
 
 void OmpAttributeVisitor::CheckPrivateDSAObject(
     const parser::Name &name, const Symbol &symbol, Symbol::Flag ompFlag) {
   const auto &ultimateSymbol{symbol.GetUltimate()};
   llvm::StringRef clauseName{"PRIVATE"};
-  if (ompFlag == Symbol::Flag::OmpFirstPrivate)
+  if (ompFlag == Symbol::Flag::OmpFirstPrivate) {
     clauseName = "FIRSTPRIVATE";
-  else if (ompFlag == Symbol::Flag::OmpLastPrivate)
+  } else if (ompFlag == Symbol::Flag::OmpLastPrivate) {
     clauseName = "LASTPRIVATE";
+  }
 
   if (ultimateSymbol.test(Symbol::Flag::InNamelist)) {
     context_.Say(name.source,
         "Variable '%s' in NAMELIST cannot be in a %s clause"_err_en_US,
         name.ToString(), clauseName.str());
   }
 
   if (stmtFunctionExprSymbols_.find(ultimateSymbol) !=

flang/runtime/ISO_Fortran_binding.cpp

int CFI_establish(CFI_cdesc_t *descriptor, void *base_addr,
   if (type < CFI_type_signed_char || type > CFI_TYPE_LAST) {
     return CFI_INVALID_TYPE;
   }
   if (!descriptor) {
     return CFI_INVALID_DESCRIPTOR;
   }
   if (type == CFI_type_struct || type == CFI_type_other ||
       IsCharacterType(type)) {
-    if (elem_len <= 0)
+    if (elem_len <= 0) {
       return CFI_INVALID_ELEM_LEN;
+    }
   } else {
     elem_len = MinElemLen(type);
     assert(elem_len > 0 && "Unknown element length for type");
   }
   descriptor->base_addr = base_addr;
   descriptor->elem_len = elem_len;
   descriptor->version = CFI_VERSION;
   descriptor->rank = rank;

flang/tools/.clang-tidy

+Checks: '-readability-braces-around-statements'
+InheritParentConfig: true

flang/unittests/RuntimeGTest/CrashHandlerFixture.cpp

llvm::errs()
       << (sourceFile ? sourceFile : "unknown source file") << '(' << sourceLine
       << "): " << buffer << '\n';
   std::exit(EXIT_FAILURE);
 }
 
 // Register the crash handler above when creating each unit test in this suite
 void CrashHandlerFixture::SetUp() {
   static bool isCrashHanlderRegistered{false};
-  if (!isCrashHanlderRegistered)
+
+  if (!isCrashHanlderRegistered) {
     Fortran::runtime::Terminator::RegisterCrashHandler(CatchCrash);
+  }
+
   isCrashHanlderRegistered = true;
 }