[flang NFC] Run latest clang-format on .h and .cpp files

[PeteSteinfeld]

Summary

This change brings files up to version 16.0.0 of clang-format.

This will make it easier for me to review patches.

flang/include/flang/Common/uint128.h

 public:
   constexpr Int128() {}
   // This means of definition provides some portability for
   // "size_t" operands.
   constexpr Int128(unsigned n) : low_{n} {}
   constexpr Int128(unsigned long n) : low_{n} {}
   constexpr Int128(unsigned long long n) : low_{n} {}
   constexpr Int128(int n)
-      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                                 n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)},
+        high_{-static_cast<std::uint64_t>(n < 0)} {}
   constexpr Int128(long n)
-      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                                 n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)},
+        high_{-static_cast<std::uint64_t>(n < 0)} {}
   constexpr Int128(long long n)
-      : low_{static_cast<std::uint64_t>(n)}, high_{-static_cast<std::uint64_t>(
-                                                 n < 0)} {}
+      : low_{static_cast<std::uint64_t>(n)},
+        high_{-static_cast<std::uint64_t>(n < 0)} {}
   constexpr Int128(const Int128 &) = default;
   constexpr Int128(Int128 &&) = default;
   constexpr Int128 &operator=(const Int128 &) = default;
   constexpr Int128 &operator=(Int128 &&) = default;
 
   explicit constexpr Int128(const Int128<!IS_SIGNED> &n)
       : low_{n.low()}, high_{n.high()} {}
   explicit constexpr Int128(Int128<!IS_SIGNED> &&n)

flang/include/flang/Common/unwrap.h

 };
 
 template <typename A, typename B> auto Unwrap(B &x) -> Constify<A, B> * {
   return UnwrapperHelper::Unwrap<A>(x);
 }
 
 // Returns a copy of a wrapped value, if present, otherwise a vacant optional.
 template <typename A, typename B> std::optional<A> UnwrapCopy(const B &x) {
-  if (const A * p{Unwrap<A>(x)}) {
+  if (const A *p{Unwrap<A>(x)}) {
     return std::make_optional<A>(*p);
   } else {
     return std::nullopt;
   }
 }
 } // namespace Fortran::common
 #endif // FORTRAN_COMMON_UNWRAP_H_

flang/include/flang/Evaluate/call.h

if (const auto *p{
             std::get_if<common::CopyableIndirection<Expr<SomeType>>>(&u_)}) {
       return &p->value();
     } else {
       return nullptr;
     }
   }
 
   const Symbol *GetAssumedTypeDummy() const {
-    if (const AssumedType * aType{std::get_if<AssumedType>(&u_)}) {
+    if (const AssumedType *aType{std::get_if<AssumedType>(&u_)}) {
       return &aType->symbol();
     } else {
       return nullptr;
     }
   }
 
   common::Label GetLabel() const { return std::get<common::Label>(u_); }
 

flang/include/flang/Evaluate/tools.h

 
 // Predicate: is an expression is an array element reference?
 template <typename T>
 bool IsArrayElement(const Expr<T> &expr, bool intoSubstring = true,
     bool skipComponents = false) {
   if (auto dataRef{ExtractDataRef(expr, intoSubstring)}) {
     const DataRef *ref{&*dataRef};
     if (skipComponents) {
-      while (const Component * component{std::get_if<Component>(&ref->u)}) {
+      while (const Component *component{std::get_if<Component>(&ref->u)}) {
         ref = &component->base();
       }
     }
     if (const auto *coarrayRef{std::get_if<CoarrayRef>(&ref->u)}) {
       return !coarrayRef->subscript().empty();
     } else {
       return std::holds_alternative<ArrayRef>(ref->u);
     }
struct ExtractCoindexedObjectHelper {
   template <typename A>
   std::optional<CoarrayRef> operator()(const Expr<A> &expr) const {
     return common::visit(*this, expr.u);
   }
   std::optional<CoarrayRef> operator()(const DataRef &dataRef) const {
     return common::visit(*this, dataRef.u);
   }
   std::optional<CoarrayRef> operator()(const NamedEntity &named) const {
-    if (const Component * component{named.UnwrapComponent()}) {
+    if (const Component *component{named.UnwrapComponent()}) {
       return (*this)(*component);
     } else {
       return std::nullopt;
     }
   }
   std::optional<CoarrayRef> operator()(const ProcedureDesignator &des) const {
     if (const auto *component{
             std::get_if<common::CopyableIndirection<Component>>(&des.u)}) {
if (auto dataRef{ExtractDataRef(x, true)}) {
     return ExtractCoindexedObjectHelper{}(x);
   }
 }
 
 // If an expression is simply a whole symbol data designator,
 // extract and return that symbol, else null.
 template <typename A> const Symbol *UnwrapWholeSymbolDataRef(const A &x) {
   if (auto dataRef{ExtractDataRef(x)}) {
-    if (const SymbolRef * p{std::get_if<SymbolRef>(&dataRef->u)}) {
+    if (const SymbolRef *p{std::get_if<SymbolRef>(&dataRef->u)}) {
       return &p->get();
     }
   }
   return nullptr;
 }
 
 // If an expression is a whole symbol or a whole component desginator,
 // extract and return that symbol, else null.
 template <typename A>
 const Symbol *UnwrapWholeSymbolOrComponentDataRef(const A &x) {
   if (auto dataRef{ExtractDataRef(x)}) {
-    if (const SymbolRef * p{std::get_if<SymbolRef>(&dataRef->u)}) {
+    if (const SymbolRef *p{std::get_if<SymbolRef>(&dataRef->u)}) {
       return &p->get();
-    } else if (const Component * c{std::get_if<Component>(&dataRef->u)}) {
+    } else if (const Component *c{std::get_if<Component>(&dataRef->u)}) {
       if (c->base().Rank() == 0) {
         return &c->GetLastSymbol();
       }
     }
   }
   return nullptr;
 }
 
 // If an expression is a whole symbol or a whole component designator,
 // potentially followed by an image selector, extract and return that symbol,
 // else null.
 template <typename A>
 const Symbol *UnwrapWholeSymbolOrComponentOrCoarrayRef(const A &x) {
   if (auto dataRef{ExtractDataRef(x)}) {
-    if (const SymbolRef * p{std::get_if<SymbolRef>(&dataRef->u)}) {
+    if (const SymbolRef *p{std::get_if<SymbolRef>(&dataRef->u)}) {
       return &p->get();
-    } else if (const Component * c{std::get_if<Component>(&dataRef->u)}) {
+    } else if (const Component *c{std::get_if<Component>(&dataRef->u)}) {
       if (c->base().Rank() == 0) {
         return &c->GetLastSymbol();
       }
-    } else if (const CoarrayRef * c{std::get_if<CoarrayRef>(&dataRef->u)}) {
+    } else if (const CoarrayRef *c{std::get_if<CoarrayRef>(&dataRef->u)}) {
       if (c->subscript().empty()) {
         return &c->GetLastSymbol();
       }
     }
   }
   return nullptr;
 }
 

 // If a function reference constitutes an entire expression, return a pointer
 // to its PrcedureRef.
 const ProcedureRef *GetProcedureRef(const Expr<SomeType> &);
 
 // For everyday variables: if GetLastSymbol() succeeds on the argument, return
 // its set of attributes, otherwise the empty set.  Also works on variables that
 // are pointer results of functions.
 template <typename A> semantics::Attrs GetAttrs(const A &x) {
-  if (const Symbol * symbol{GetLastSymbol(x)}) {
+  if (const Symbol *symbol{GetLastSymbol(x)}) {
     return symbol->attrs();
   } else {
     return {};
   }
 }
 
 template <>
 inline semantics::Attrs GetAttrs<Expr<SomeType>>(const Expr<SomeType> &x) {
   if (IsVariable(x)) {
     if (const auto *procRef{GetProcedureRef(x)}) {
-      if (const Symbol * interface{procRef->proc().GetInterfaceSymbol()}) {
+      if (const Symbol *interface{procRef->proc().GetInterfaceSymbol()}) {
         if (const auto *details{
                 interface->detailsIf<semantics::SubprogramDetails>()}) {
           if (details->isFunction() &&
               details->result().attrs().test(semantics::Attr::POINTER)) {
             // N.B.: POINTER becomes TARGET in SetAttrsFromAssociation()
             return details->result().attrs();
           }
         }
       }
     }
   }
-  if (const Symbol * symbol{GetLastSymbol(x)}) {
+  if (const Symbol *symbol{GetLastSymbol(x)}) {
     return symbol->attrs();
   } else {
     return {};
   }
 }
 
 template <typename A> semantics::Attrs GetAttrs(const std::optional<A> &x) {
   if (x) {

flang/include/flang/Evaluate/traverse.h

public:
   Result operator()(const ImpliedDoIndex &) const { return visitor_.Default(); }
 
   // Variables
   Result operator()(const BaseObject &x) const { return visitor_(x.u); }
   Result operator()(const Component &x) const {
     return Combine(x.base(), x.symbol());
   }
   Result operator()(const NamedEntity &x) const {
-    if (const Component * component{x.UnwrapComponent()}) {
+    if (const Component *component{x.UnwrapComponent()}) {
       return visitor_(*component);
     } else {
       return visitor_(DEREF(x.UnwrapSymbolRef()));
     }
   }
   Result operator()(const TypeParamInquiry &x) const {
     return visitor_(x.base());
   }
Result operator()(const DescriptorInquiry &x) const {
     return visitor_(x.base());
   }
 
   // Calls
   Result operator()(const SpecificIntrinsic &) const {
     return visitor_.Default();
   }
   Result operator()(const ProcedureDesignator &x) const {
-    if (const Component * component{x.GetComponent()}) {
+    if (const Component *component{x.GetComponent()}) {
       return visitor_(*component);
-    } else if (const Symbol * symbol{x.GetSymbol()}) {
+    } else if (const Symbol *symbol{x.GetSymbol()}) {
       return visitor_(*symbol);
     } else {
       return visitor_(DEREF(x.GetSpecificIntrinsic()));
     }
   }
   Result operator()(const ActualArgument &x) const {
     if (const auto *symbol{x.GetAssumedTypeDummy()}) {
       return visitor_(*symbol);

flang/include/flang/Evaluate/type.h

 public:
   constexpr DynamicType(TypeCategory cat, int k) : category_{cat}, kind_{k} {
     CHECK(IsValidKindOfIntrinsicType(category_, kind_));
   }
   DynamicType(int charKind, const semantics::ParamValue &len);
   // When a known length is presented, resolve it to its effective
   // length of zero if it is negative.
   constexpr DynamicType(int k, std::int64_t len)
-      : category_{TypeCategory::Character}, kind_{k}, knownLength_{
-                                                          len >= 0 ? len : 0} {
+      : category_{TypeCategory::Character}, kind_{k},
+        knownLength_{len >= 0 ? len : 0} {
     CHECK(IsValidKindOfIntrinsicType(category_, kind_));
   }
   explicit constexpr DynamicType(
       const semantics::DerivedTypeSpec &dt, bool poly = false)
       : category_{TypeCategory::Derived}, derived_{&dt} {
     if (poly) {
       kind_ = ClassKind;
     }

flang/include/flang/Lower/BoxAnalyzer.h

struct DynamicArray : ScalarSym, DynamicBound {
   static constexpr bool staticSize() { return DynamicBound::staticSize(); }
 };
 
 /// Array of CHARACTER with statically known LEN, origin, and shape.
 struct StaticArrayStaticChar : ScalarStaticChar, LBoundsAndShape {
   StaticArrayStaticChar(const Fortran::semantics::Symbol &sym, int64_t len,
                         llvm::SmallVectorImpl<int64_t> &&lbounds,
                         llvm::SmallVectorImpl<int64_t> &&shapes)
-      : ScalarStaticChar{sym, len}, LBoundsAndShape{std::move(lbounds),
-                                                    std::move(shapes)} {}
+      : ScalarStaticChar{sym, len},
+        LBoundsAndShape{std::move(lbounds), std::move(shapes)} {}
 
   static constexpr bool staticSize() {
     return ScalarStaticChar::staticSize() && LBoundsAndShape::staticSize();
   }
 };
 
 /// Array of CHARACTER with dynamic LEN but constant origin, shape.
 struct StaticArrayDynamicChar : ScalarDynamicChar, LBoundsAndShape {
   StaticArrayDynamicChar(const Fortran::semantics::Symbol &sym,
                          const Fortran::lower::SomeExpr &len,
                          llvm::SmallVectorImpl<int64_t> &&lbounds,
                          llvm::SmallVectorImpl<int64_t> &&shapes)
-      : ScalarDynamicChar{sym, len}, LBoundsAndShape{std::move(lbounds),
-                                                     std::move(shapes)} {}
+      : ScalarDynamicChar{sym, len},
+        LBoundsAndShape{std::move(lbounds), std::move(shapes)} {}
   StaticArrayDynamicChar(const Fortran::semantics::Symbol &sym,
                          llvm::SmallVectorImpl<int64_t> &&lbounds,
                          llvm::SmallVectorImpl<int64_t> &&shapes)
-      : ScalarDynamicChar{sym}, LBoundsAndShape{std::move(lbounds),
-                                                std::move(shapes)} {}
+      : ScalarDynamicChar{sym},
+        LBoundsAndShape{std::move(lbounds), std::move(shapes)} {}
 
   static constexpr bool staticSize() {
     return ScalarDynamicChar::staticSize() && LBoundsAndShape::staticSize();
   }
 };
 
 /// Array of CHARACTER with constant LEN but dynamic origin, shape.
 struct DynamicArrayStaticChar : ScalarStaticChar, DynamicBound {

flang/include/flang/Lower/OpenACC.h

 #define FORTRAN_LOWER_OPENACC_H
 
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 
 namespace llvm {
 template <typename T, unsigned N>
 class SmallVector;
 class StringRef;
-}
+} // namespace llvm
 
 namespace mlir {
 class Location;
 class Type;
 class OpBuilder;
 class Value;
 } // namespace mlir
 

flang/include/flang/Lower/VectorSubscripts.h

public:
   using LoweredSubscript =
       std::variant<mlir::Value, LoweredTriplet, LoweredVectorSubscript>;
   using MaybeSubstring = llvm::SmallVector<mlir::Value, 2>;
   VectorSubscriptBox(
       fir::ExtendedValue &&loweredBase,
       llvm::SmallVector<LoweredSubscript, 16> &&loweredSubscripts,
       llvm::SmallVector<mlir::Value> &&componentPath,
       MaybeSubstring substringBounds, mlir::Type elementType)
-      : loweredBase{std::move(loweredBase)}, loweredSubscripts{std::move(
-                                                 loweredSubscripts)},
+      : loweredBase{std::move(loweredBase)},
+        loweredSubscripts{std::move(loweredSubscripts)},
         componentPath{std::move(componentPath)},
         substringBounds{substringBounds}, elementType{elementType} {};
 
   /// Loop over the elements described by the VectorSubscriptBox, and call
   /// \p elementalGenerator inside the loops with the element addresses.
   void loopOverElements(fir::FirOpBuilder &builder, mlir::Location loc,
                         const ElementalGenerator &elementalGenerator);
 

flang/include/flang/Optimizer/Builder/BoxValue.h

 /// Expressions of type array have at minimum a shape. These expressions may
 /// have lbound attributes (dynamic values) that affect the interpretation of
 /// indexing expressions.
 class AbstractArrayBox {
 public:
   AbstractArrayBox() = default;
   AbstractArrayBox(llvm::ArrayRef<mlir::Value> extents,
                    llvm::ArrayRef<mlir::Value> lbounds)
-      : extents{extents.begin(), extents.end()}, lbounds{lbounds.begin(),
-                                                         lbounds.end()} {}
+      : extents{extents.begin(), extents.end()},
+        lbounds{lbounds.begin(), lbounds.end()} {}
 
   // Every array has extents that describe its shape.
   const llvm::SmallVectorImpl<mlir::Value> &getExtents() const {
     return extents;
   }
 
   // An array expression may have user-defined lower bound values.
   // If this vector is empty, the default in all dimensions in `1`.

 class MutableBoxValue : public AbstractIrBox {
 public:
   /// Create MutableBoxValue given the address \p addr of the box and the non
   /// deferred LEN parameters \p lenParameters. The non deferred LEN parameters
   /// must always be provided, even if they are constant and already reflected
   /// in the address type.
   MutableBoxValue(mlir::Value addr, mlir::ValueRange lenParameters,
                   MutableProperties mutableProperties)
-      : AbstractIrBox(addr), lenParams{lenParameters.begin(),
-                                       lenParameters.end()},
+      : AbstractIrBox(addr),
+        lenParams{lenParameters.begin(), lenParameters.end()},
         mutableProperties{mutableProperties} {
     // Currently only accepts fir.(ref/ptr/heap)<fir.box<type>> mlir::Value for
     // the address. This may change if we accept
     // fir.(ref/ptr/heap)<fir.heap<type>> for scalar without LEN parameters.
     assert(verify() &&
            "MutableBoxValue requires mem ref to fir.box<fir.[heap|ptr]<type>>");
   }
   /// Is this a Fortran pointer ?

flang/include/flang/Optimizer/Support/InternalNames.h

struct NameUniquer {
   };
 
   /// Components of an unparsed unique name
   struct DeconstructedName {
     DeconstructedName(llvm::StringRef name) : name{name} {}
     DeconstructedName(llvm::ArrayRef<std::string> modules,
                       llvm::ArrayRef<std::string> procs, std::int64_t blockId,
                       llvm::StringRef name, llvm::ArrayRef<std::int64_t> kinds)
-        : modules{modules.begin(), modules.end()}, procs{procs.begin(),
-                                                         procs.end()},
-          blockId{blockId}, name{name}, kinds{kinds.begin(), kinds.end()} {}
+        : modules{modules.begin(), modules.end()},
+          procs{procs.begin(), procs.end()}, blockId{blockId}, name{name},
+          kinds{kinds.begin(), kinds.end()} {}
 
     llvm::SmallVector<std::string> modules;
     llvm::SmallVector<std::string> procs;
     std::int64_t blockId;
     std::string name;
     llvm::SmallVector<std::int64_t> kinds;
   };
 

flang/include/flang/Parser/format-specification.h

 // R1311 e -> digit-string
 struct IntrinsicTypeDataEditDesc {
   enum class Kind { I, B, O, Z, F, E, EN, ES, EX, G, L, A, D };
   IntrinsicTypeDataEditDesc() = delete;
   IntrinsicTypeDataEditDesc(IntrinsicTypeDataEditDesc &&) = default;
   IntrinsicTypeDataEditDesc &operator=(IntrinsicTypeDataEditDesc &&) = default;
   IntrinsicTypeDataEditDesc(Kind &&k, std::optional<int> &&w,
       std::optional<int> &&d, std::optional<int> &&e)
-      : kind{k}, width{std::move(w)}, digits{std::move(d)}, exponentWidth{
-                                                                std::move(e)} {}
+      : kind{k}, width{std::move(w)}, digits{std::move(d)},
+        exponentWidth{std::move(e)} {}
   Kind kind;
   std::optional<int> width; // w
   std::optional<int> digits; // m or d
   std::optional<int> exponentWidth; // e
 };
 
 // R1307 data-edit-desc (part 2 of 2) ->
 //         DT [char-literal-constant] [( v-list )]

flang/include/flang/Parser/instrumented-parser.h

 
 template <typename PA> class InstrumentedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr InstrumentedParser(const InstrumentedParser &) = default;
   constexpr InstrumentedParser(const MessageFixedText &tag, const PA &parser)
       : tag_{tag}, parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
-    if (UserState * ustate{state.userState()}) {
-      if (ParsingLog * log{ustate->log()}) {
+    if (UserState *ustate{state.userState()}) {
+      if (ParsingLog *log{ustate->log()}) {
         const char *at{state.GetLocation()};
         if (log->Fails(at, tag_, state)) {
           return std::nullopt;
         }
         Messages messages{std::move(state.messages())};
         std::optional<resultType> result{parser_.Parse(state)};
         log->Note(at, tag_, result.has_value(), state);
         state.messages().Annex(std::move(messages));

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

std::variant<common::Indirection<CharLiteralConstantSubstring>,
       u;
 };
 
 // R912 part-ref -> part-name [( section-subscript-list )] [image-selector]
 struct PartRef {
   BOILERPLATE(PartRef);
   PartRef(Name &&n, std::list<SectionSubscript> &&ss,
       std::optional<ImageSelector> &&is)
-      : name{std::move(n)},
-        subscripts(std::move(ss)), imageSelector{std::move(is)} {}
+      : name{std::move(n)}, subscripts(std::move(ss)),
+        imageSelector{std::move(is)} {}
   Name name;
   std::list<SectionSubscript> subscripts;
   std::optional<ImageSelector> imageSelector;
 };
 
 // R911 data-ref -> part-ref [% part-ref]...
 struct DataRef {
   UNION_CLASS_BOILERPLATE(DataRef);

flang/include/flang/Runtime/array-constructor.h

 // Runtime data structure to hold information about the storage of
 // an array constructor being constructed.
 struct ArrayConstructorVector {
   ArrayConstructorVector(class Descriptor &to, SubscriptValue nextValuePosition,
       SubscriptValue actualAllocationSize, const char *sourceFile,
       int sourceLine, bool useValueLengthParameters)
       : to{to}, nextValuePosition{nextValuePosition},
         actualAllocationSize{actualAllocationSize}, sourceFile{sourceFile},
-        sourceLine{sourceLine}, useValueLengthParameters_{
-                                    useValueLengthParameters} {}
+        sourceLine{sourceLine},
+        useValueLengthParameters_{useValueLengthParameters} {}
 
   bool useValueLengthParameters() const { return useValueLengthParameters_; }
 
   class Descriptor &to;
   SubscriptValue nextValuePosition;
   SubscriptValue actualAllocationSize;
   const char *sourceFile;
   int sourceLine;

flang/include/flang/Runtime/descriptor.h

public:
   }
   const RT_API_ATTRS Descriptor &descriptor() const {
     return *reinterpret_cast<const Descriptor *>(storage_);
   }
 
   RT_API_ATTRS void Check() {
     assert(descriptor().rank() <= maxRank);
     assert(descriptor().SizeInBytes() <= byteSize);
-    if (DescriptorAddendum * addendum{descriptor().Addendum()}) {
+    if (DescriptorAddendum *addendum{descriptor().Addendum()}) {
       assert(hasAddendum);
       assert(addendum->LenParameters() <= maxLengthTypeParameters);
     } else {
       assert(!hasAddendum);
       assert(maxLengthTypeParameters == 0);
     }
     descriptor().Check();
   }
 
 private:
   char storage_[byteSize]{};
 };
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_DESCRIPTOR_H_

flang/include/flang/Semantics/scope.h

 
 class SemanticsContext;
 
 // An equivalence object is represented by a symbol for the variable name,
 // the indices for an array element, and the lower bound for a substring.
 struct EquivalenceObject {
   EquivalenceObject(Symbol &symbol, std::vector<ConstantSubscript> subscripts,
       std::optional<ConstantSubscript> substringStart, parser::CharBlock source)
-      : symbol{symbol}, subscripts{subscripts},
-        substringStart{substringStart}, source{source} {}
+      : symbol{symbol}, subscripts{subscripts}, substringStart{substringStart},
+        source{source} {}
   explicit EquivalenceObject(Symbol &symbol)
       : symbol{symbol}, source{symbol.name()} {}
 
   bool operator==(const EquivalenceObject &) const;
   bool operator<(const EquivalenceObject &) const;
   std::string AsFortran() const;
 
   Symbol &symbol;

flang/include/flang/Semantics/tools.h

 bool HasCoarray(const parser::Expr &);
 bool IsAssumedType(const Symbol &);
 bool IsPolymorphic(const Symbol &);
 bool IsUnlimitedPolymorphic(const Symbol &);
 bool IsPolymorphicAllocatable(const Symbol &);
 
 inline bool IsCUDADeviceContext(const Scope *scope) {
   if (scope) {
-    if (const Symbol * symbol{scope->symbol()}) {
+    if (const Symbol *symbol{scope->symbol()}) {
       if (const auto *subp{symbol->detailsIf<SubprogramDetails>()}) {
         if (auto attrs{subp->cudaSubprogramAttrs()}) {
           return *attrs != common::CUDASubprogramAttrs::Host;
         }
       }
     }
   }
   return false;

 template <typename A>
 const Symbol *FindExternallyVisibleObject(const A &, const Scope &) {
   return nullptr; // default base case
 }
 
 template <typename T>
 const Symbol *FindExternallyVisibleObject(
     const evaluate::Designator<T> &designator, const Scope &scope) {
-  if (const Symbol * symbol{designator.GetBaseObject().symbol()}) {
+  if (const Symbol *symbol{designator.GetBaseObject().symbol()}) {
     return FindExternallyVisibleObject(*symbol, scope, false);
   } else if (std::holds_alternative<evaluate::CoarrayRef>(designator.u)) {
     // Coindexed values are visible even if their image-local objects are not.
     return designator.GetBaseObject().symbol();
   } else {
     return nullptr;
   }
 }

 
 // The LabelEnforce class (given a set of labels) provides an error message if
 // there is a branch to a label which is not in the given set.
 class LabelEnforce {
 public:
   LabelEnforce(SemanticsContext &context, std::set<parser::Label> &&labels,
       parser::CharBlock constructSourcePosition, const char *construct)
       : context_{context}, labels_{labels},
-        constructSourcePosition_{constructSourcePosition}, construct_{
-                                                               construct} {}
+        constructSourcePosition_{constructSourcePosition},
+        construct_{construct} {}
   template <typename T> bool Pre(const T &) { return true; }
   template <typename T> bool Pre(const parser::Statement<T> &statement) {
     currentStatementSourcePosition_ = statement.source;
     return true;
   }
 
   template <typename T> void Post(const T &) {}
 

flang/lib/Evaluate/call.cpp

 }
 
 void ActualArgument::Parenthesize() {
   u_ = evaluate::Parenthesize(std::move(DEREF(UnwrapExpr())));
 }
 
 SpecificIntrinsic::SpecificIntrinsic(
     IntrinsicProcedure n, characteristics::Procedure &&chars)
-    : name{n}, characteristics{
-                   new characteristics::Procedure{std::move(chars)}} {}
+    : name{n},
+      characteristics{new characteristics::Procedure{std::move(chars)}} {}
 
 DEFINE_DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(SpecificIntrinsic)
 
 SpecificIntrinsic::~SpecificIntrinsic() {}
 
 bool SpecificIntrinsic::operator==(const SpecificIntrinsic &that) const {
   return name == that.name && characteristics == that.characteristics;
 }
if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&u)}) {
     }
   } else {
     return DynamicType::From(GetSymbol());
   }
   return std::nullopt;
 }
 
 int ProcedureDesignator::Rank() const {
-  if (const Symbol * symbol{GetSymbol()}) {
+  if (const Symbol *symbol{GetSymbol()}) {
     // Subtle: will be zero for functions returning procedure pointers
     return symbol->Rank();
   }
   if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&u)}) {
     if (const auto &result{intrinsic->characteristics.value().functionResult}) {
       if (const auto *typeAndShape{result->GetTypeAndShape()}) {
         CHECK(!typeAndShape->attrs().test(
             characteristics::TypeAndShape::Attr::AssumedRank));
         return typeAndShape->Rank();
       }
       // Otherwise, intrinsic returns a procedure pointer (e.g. NULL(MOLD=pptr))
     }
   }
   return 0;
 }
 
 const Symbol *ProcedureDesignator::GetInterfaceSymbol() const {
-  if (const Symbol * symbol{GetSymbol()}) {
+  if (const Symbol *symbol{GetSymbol()}) {
     const Symbol &ultimate{symbol->GetUltimate()};
     if (const auto *proc{ultimate.detailsIf<semantics::ProcEntityDetails>()}) {
       return proc->procInterface();
     } else if (const auto *binding{
                    ultimate.detailsIf<semantics::ProcBindingDetails>()}) {
       return &binding->symbol();
     } else if (ultimate.has<semantics::SubprogramDetails>()) {
       return &ultimate;
     }
   }
   return nullptr;
 }
 
 bool ProcedureDesignator::IsElemental() const {
-  if (const Symbol * interface{GetInterfaceSymbol()}) {
+  if (const Symbol *interface{GetInterfaceSymbol()}) {
     return IsElementalProcedure(*interface);
-  } else if (const Symbol * symbol{GetSymbol()}) {
+  } else if (const Symbol *symbol{GetSymbol()}) {
     return IsElementalProcedure(*symbol);
   } else if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&u)}) {
     return intrinsic->characteristics.value().attrs.test(
         characteristics::Procedure::Attr::Elemental);
   } else {
     DIE("ProcedureDesignator::IsElemental(): no case");
   }
   return false;
 }
 
 bool ProcedureDesignator::IsPure() const {
-  if (const Symbol * interface{GetInterfaceSymbol()}) {
+  if (const Symbol *interface{GetInterfaceSymbol()}) {
     return IsPureProcedure(*interface);
-  } else if (const Symbol * symbol{GetSymbol()}) {
+  } else if (const Symbol *symbol{GetSymbol()}) {
     return IsPureProcedure(*symbol);
   } else if (const auto *intrinsic{std::get_if<SpecificIntrinsic>(&u)}) {
     return intrinsic->characteristics.value().attrs.test(
         characteristics::Procedure::Attr::Pure);
   } else {
     DIE("ProcedureDesignator::IsPure(): no case");
   }
   return false;

flang/lib/Evaluate/characteristics.cpp

return common::visit(
           [&](const semantics::ProcBindingDetails &binding) {
             return Characterize(binding.symbol(), context);
           },
           [&](const auto &x) -> std::optional<TypeAndShape> {
             using Ty = std::decay_t<decltype(x)>;
             if constexpr (std::is_same_v<Ty, semantics::EntityDetails> ||
                 std::is_same_v<Ty, semantics::ObjectEntityDetails> ||
                 std::is_same_v<Ty, semantics::TypeParamDetails>) {
-              if (const semantics::DeclTypeSpec * type{ultimate.GetType()}) {
+              if (const semantics::DeclTypeSpec *type{ultimate.GetType()}) {
                 if (auto dyType{DynamicType::From(*type)}) {
                   TypeAndShape result{
                       std::move(*dyType), GetShape(context, ultimate)};
                   result.AcquireAttrs(ultimate);
                   result.AcquireLEN(ultimate);
                   return std::move(result.Rewrite(context));
                 }
               }
if (auto type{DynamicType::From(spec)}) {
     return std::nullopt;
   }
 }
 
 std::optional<TypeAndShape> TypeAndShape::Characterize(
     const ActualArgument &arg, FoldingContext &context) {
   if (const auto *expr{arg.UnwrapExpr()}) {
     return Characterize(*expr, context);
-  } else if (const Symbol * assumed{arg.GetAssumedTypeDummy()}) {
+  } else if (const Symbol *assumed{arg.GetAssumedTypeDummy()}) {
     return Characterize(*assumed, context);
   } else {
     return std::nullopt;
   }
 }
 
 bool TypeAndShape::IsCompatibleWith(parser::ContextualMessages &messages,
     const TypeAndShape &that, const char *thisIs, const char *thatIs,
if (auto type{TypeAndShape::Characterize(symbol, context)}) {
       }
       return result;
     }
   }
   return std::nullopt;
 }
 
 bool DummyDataObject::CanBePassedViaImplicitInterface() const {
-  if ((attrs &
-          Attrs{Attr::Allocatable, Attr::Asynchronous, Attr::Optional,
-              Attr::Pointer, Attr::Target, Attr::Value, Attr::Volatile})
+  if ((attrs &Attrs{Attr::Allocatable, Attr::Asynchronous, Attr::Optional,
           .any()) {
     return false; // 15.4.2.2(3)(a)
   } else if ((type.attrs() &
                  TypeAndShape::Attrs{TypeAndShape::Attr::AssumedShape,
                      TypeAndShape::Attr::AssumedRank,
                      TypeAndShape::Attr::Coarray})
                  .any()) {
     return false; // 15.4.2.2(3)(b-d)
if (whyNot) {
       *whyNot = "incompatible dummy procedure interfaces: "s + *whyNot;
     }
     return false;
   }
   return true;
 }
 
 bool DummyProcedure::CanBePassedViaImplicitInterface() const {
-  if ((attrs & Attrs{Attr::Optional, Attr::Pointer}).any()) {
+  if ((attrs &Attrs{Attr::Optional, Attr::Pointer}).any()) {
     return false; // 15.4.2.2(3)(a)
   }
   return true;
 }
 
 static std::string GetSeenProcs(
     const semantics::UnorderedSymbolSet &seenProcs) {
   // Sort the symbols so that they appear in the same order on all platforms
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;
             }
-            if (const semantics::Symbol *
-                interfaceSymbol{proc.procInterface()}) {
+            if (const semantics::Symbol *interfaceSymbol{
+                    proc.procInterface()}) {
               auto interface {
                 CharacterizeProcedure(*interfaceSymbol, context, seenProcs)
               };
               if (interface && IsPointer(symbol)) {
                 interface->attrs.reset(Procedure::Attr::Elemental);
               }
               return interface;
             } else {
return common::visit(
             // Ambiguous use-association will be handled later during symbol
             // checks, ignore UseErrorDetails here without actual symbol usage.
             return std::optional<Procedure>{};
           },
           [&](const semantics::HostAssocDetails &assoc) {
             return CharacterizeProcedure(assoc.symbol(), context, seenProcs);
           },
           [&](const semantics::GenericDetails &generic) {
-            if (const semantics::Symbol * specific{generic.specific()}) {
+            if (const semantics::Symbol *specific{generic.specific()}) {
               return CharacterizeProcedure(*specific, context, seenProcs);
             } else {
               return std::optional<Procedure>{};
             }
           },
           [&](const semantics::EntityDetails &) {
             context.messages().Say(
                 "Procedure '%s' is referenced before being sufficiently defined in a context where it must be so"_err_en_US,
std::optional<Procedure> Procedure::Characterize(
   }
   return std::nullopt;
 }
 
 std::optional<Procedure> Procedure::Characterize(
     const ProcedureRef &ref, FoldingContext &context) {
   if (auto callee{Characterize(ref.proc(), context)}) {
     if (callee->functionResult) {
-      if (const Procedure *
-          proc{callee->functionResult->IsProcedurePointer()}) {
+      if (const Procedure *proc{callee->functionResult->IsProcedurePointer()}) {
         return {*proc};
       }
     }
   }
   return std::nullopt;
 }
 
 std::optional<Procedure> Procedure::FromActuals(const ProcedureDesignator &proc,

flang/lib/Evaluate/check-expression.cpp

public:
   template <typename D, typename R, typename... O>
   bool operator()(const Operation<D, R, O...> &) const {
     return false;
   }
   template <typename T> bool operator()(const Parentheses<T> &x) const {
     return (*this)(x.left());
   }
   bool operator()(const ProcedureRef &x) const {
-    if (const SpecificIntrinsic * intrinsic{x.proc().GetSpecificIntrinsic()}) {
+    if (const SpecificIntrinsic *intrinsic{x.proc().GetSpecificIntrinsic()}) {
       return intrinsic->characteristics.value().attrs.test(
           characteristics::Procedure::Attr::NullPointer);
     }
     return false;
   }
   bool operator()(const Relational<SomeType> &) const { return false; }
 
 private:
return parser::Message{sf_.name(),
         sf_.name()};
   }
   Result operator()(const TypeParamInquiry &) const {
     return parser::Message{sf_.name(),
         "Statement function '%s' should not contain a type parameter inquiry"_port_en_US,
         sf_.name()};
   }
   Result operator()(const ProcedureDesignator &proc) const {
-    if (const Symbol * symbol{proc.GetSymbol()}) {
+    if (const Symbol *symbol{proc.GetSymbol()}) {
       const Symbol &ultimate{symbol->GetUltimate()};
       if (const auto *subp{
               ultimate.detailsIf<semantics::SubprogramDetails>()}) {
         if (subp->stmtFunction() && &ultimate.owner() == &sf_.owner()) {
           if (ultimate.name().begin() > sf_.name().begin()) {
             return parser::Message{sf_.name(),
                 "Statement function '%s' may not reference another statement function '%s' that is defined later"_err_en_US,
                 sf_.name(), ultimate.name()};

flang/lib/Evaluate/constant.cpp

 // Constant<Type<TypeCategory::Character, KIND> specializations
 template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(
     const Scalar<Result> &str)
     : values_{str}, length_{static_cast<ConstantSubscript>(values_.size())} {}
 
 template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(Scalar<Result> &&str)
-    : values_{std::move(str)}, length_{static_cast<ConstantSubscript>(
-                                   values_.size())} {}
+    : values_{std::move(str)},
+      length_{static_cast<ConstantSubscript>(values_.size())} {}
 
 template <int KIND>
 Constant<Type<TypeCategory::Character, KIND>>::Constant(ConstantSubscript len,
     std::vector<Scalar<Result>> &&strings, ConstantSubscripts &&sh)
     : ConstantBounds(std::move(sh)), length_{len} {
   CHECK(strings.size() == TotalElementCount(shape()));
   values_.assign(strings.size() * length_,
       static_cast<typename Scalar<Result>::value_type>(' '));

flang/lib/Evaluate/expression.cpp

 bool Expr<SomeType>::operator==(const Expr<SomeType> &that) const {
   return u == that.u;
 }
 
 DynamicType StructureConstructor::GetType() const { return result_.GetType(); }
 
 std::optional<Expr<SomeType>> StructureConstructor::CreateParentComponent(
     const Symbol &component) const {
-  if (const semantics::DerivedTypeSpec *
-      parentSpec{GetParentTypeSpec(derivedTypeSpec())}) {
+  if (const semantics::DerivedTypeSpec *parentSpec{
+          GetParentTypeSpec(derivedTypeSpec())}) {
     StructureConstructor structureConstructor{*parentSpec};
     if (const auto *parentDetails{
             component.detailsIf<semantics::DerivedTypeDetails>()}) {
       auto parentIter{parentDetails->componentNames().begin()};
       for (const auto &childIter : values_) {
         if (parentIter == parentDetails->componentNames().end()) {
           break; // There are more components in the child
         }
std::optional<Expr<SomeType>> StructureConstructor::CreateParentComponent(
   }
   return std::nullopt;
 }
 
 static const Symbol *GetParentComponentSymbol(const Symbol &symbol) {
   if (symbol.test(Symbol::Flag::ParentComp)) {
     // we have a created parent component
     const auto &compObject{symbol.get<semantics::ObjectEntityDetails>()};
-    if (const semantics::DeclTypeSpec * compType{compObject.type()}) {
+    if (const semantics::DeclTypeSpec *compType{compObject.type()}) {
       const semantics::DerivedTypeSpec &dtSpec{compType->derivedTypeSpec()};
       const semantics::Symbol &compTypeSymbol{dtSpec.typeSymbol()};
       return &compTypeSymbol;
     }
   }
   if (symbol.detailsIf<semantics::DerivedTypeDetails>()) {
     // we have an implicit parent type component
     return &symbol;
   }
   return nullptr;
 }
 
 std::optional<Expr<SomeType>> StructureConstructor::Find(
     const Symbol &component) const {
   if (auto iter{values_.find(component)}; iter != values_.end()) {
     return iter->second.value();
   }
   // The component wasn't there directly, see if we're looking for the parent
   // component of an extended type
-  if (const Symbol * typeSymbol{GetParentComponentSymbol(component)}) {
+  if (const Symbol *typeSymbol{GetParentComponentSymbol(component)}) {
     return CreateParentComponent(*typeSymbol);
   }
   // Look for the component in the parent type component.  The parent type
   // component is always the first one
   if (!values_.empty()) {
     const Expr<SomeType> *parentExpr{&values_.begin()->second.value()};
     if (const Expr<SomeDerived> *derivedExpr{
             std::get_if<Expr<SomeDerived>>(&parentExpr->u)}) {

flang/lib/Evaluate/fold-designator.cpp

 
 std::optional<OffsetSymbol> DesignatorFolder::FoldDesignator(
     const CoarrayRef &, ConstantSubscript) {
   return std::nullopt;
 }
 
 std::optional<OffsetSymbol> DesignatorFolder::FoldDesignator(
     const ProcedureDesignator &proc, ConstantSubscript which) {
-  if (const Symbol * symbol{proc.GetSymbol()}) {
-    if (const Component * component{proc.GetComponent()}) {
+  if (const Symbol *symbol{proc.GetSymbol()}) {
+    if (const Component *component{proc.GetComponent()}) {
       return FoldDesignator(*component, which);
     } else if (which > 0) {
       isEmpty_ = true;
     } else {
       return FoldDesignator(*symbol, 0);
     }
   }
   return std::nullopt;
static std::optional<ArrayRef> OffsetToArrayRef(FoldingContext &context,
   offset -= element * static_cast<std::size_t>(*elementBytes);
   return ArrayRef{std::move(entity), std::move(subscripts)};
 }
 
 // Maps an offset back to a component, when unambiguous.
 static const Symbol *OffsetToUniqueComponent(
     const semantics::DerivedTypeSpec &spec, ConstantSubscript offset) {
   const Symbol *result{nullptr};
-  if (const semantics::Scope * scope{spec.scope()}) {
+  if (const semantics::Scope *scope{spec.scope()}) {
     for (const auto &pair : *scope) {
       const Symbol &component{*pair.second};
       if (offset >= static_cast<ConstantSubscript>(component.offset()) &&
           offset < static_cast<ConstantSubscript>(
                        component.offset() + component.size())) {
         if (result) {
           return nullptr; // MAP overlap or error recovery
         }
if (!type->IsUnlimitedPolymorphic()) {
           }
         } else {
           result = entity.IsSymbol()
               ? DataRef{symbol}
               : DataRef{std::move(entity.GetComponent())};
         }
         if (result && type->category() == TypeCategory::Derived &&
             size < result->GetLastSymbol().size()) {
-          if (const Symbol *
-              component{OffsetToUniqueComponent(
+          if (const Symbol *component{OffsetToUniqueComponent(
                   type->GetDerivedTypeSpec(), offset)}) {
             offset -= component->offset();
             return OffsetToDataRef(context,
                 NamedEntity{Component{std::move(*result), *component}}, offset,
                 size);
           }
           result.reset();
         }

flang/lib/Evaluate/fold-implementation.h

std::optional<Constant<T>> Folder<T>::Folding(ArrayRef &aRef) {
   int dim{0};
   for (Subscript &ss : aRef.subscript()) {
     if (auto constant{GetConstantSubscript(context_, ss, aRef.base(), dim++)}) {
       subscripts.emplace_back(std::move(*constant));
     } else {
       return std::nullopt;
     }
   }
-  if (Component * component{aRef.base().UnwrapComponent()}) {
+  if (Component *component{aRef.base().UnwrapComponent()}) {
     return GetConstantComponent(*component, &subscripts);
   } else if (std::optional<Constant<T>> array{
                  GetNamedConstant(aRef.base().GetLastSymbol())}) {
     return ApplySubscripts(*array, subscripts);
   } else {
     return std::nullopt;
   }
 }

flang/lib/Evaluate/fold-integer.cpp

 // the known value is constant.
 Expr<TypeParamInquiry::Result> FoldOperation(
     FoldingContext &context, TypeParamInquiry &&inquiry) {
   std::optional<NamedEntity> base{inquiry.base()};
   parser::CharBlock parameterName{inquiry.parameter().name()};
   if (base) {
     // Handling "designator%typeParam".  Get the value of the type parameter
     // from the instantiation of the base
-    if (const semantics::DeclTypeSpec *
-        declType{base->GetLastSymbol().GetType()}) {
-      if (const semantics::ParamValue *
-          paramValue{
+    if (const semantics::DeclTypeSpec *declType{
+            base->GetLastSymbol().GetType()}) {
+      if (const semantics::ParamValue *paramValue{
               declType->derivedTypeSpec().FindParameter(parameterName)}) {
         const semantics::MaybeIntExpr &paramExpr{paramValue->GetExplicit()};
         if (paramExpr && IsConstantExpr(*paramExpr)) {
           Expr<SomeInteger> intExpr{*paramExpr};
           return Fold(context,
               ConvertToType<TypeParamInquiry::Result>(std::move(intExpr)));
         }
       }
     }
   } else {
     // A "bare" type parameter: replace with its value, if that's now known
     // in a current derived type instantiation.
     if (const auto *pdt{context.pdtInstance()}) {
       auto restorer{context.WithoutPDTInstance()}; // don't loop
       bool isLen{false};
-      if (const semantics::Scope * scope{pdt->scope()}) {
+      if (const semantics::Scope *scope{pdt->scope()}) {
         auto iter{scope->find(parameterName)};
         if (iter != scope->end()) {
           const Symbol &symbol{*iter->second};
           const auto *details{symbol.detailsIf<semantics::TypeParamDetails>()};
           if (details) {
             isLen = details->attr() == common::TypeParamAttr::Len;
             const semantics::MaybeIntExpr &initExpr{details->init()};
             if (initExpr && IsConstantExpr(*initExpr) &&

flang/lib/Evaluate/fold-logical.cpp

if (name == "all") {
 
     // The arguments to these intrinsics can be of different types. In that
     // case, the shorter of the two would need to be zero-extended to match
     // the size of the other. If at least one of the operands is not a constant,
     // the zero-extending will be done during lowering. Otherwise, the folding
     // must be done here.
     std::optional<Expr<SomeType>> constArgs[2];
     for (int i{0}; i <= 1; i++) {
-      if (BOZLiteralConstant * x{UnwrapExpr<BOZLiteralConstant>(args[i])}) {
+      if (BOZLiteralConstant *x{UnwrapExpr<BOZLiteralConstant>(args[i])}) {
         constArgs[i] = AsGenericExpr(Constant<LargestInt>{std::move(*x)});
       } else if (auto *x{UnwrapExpr<Expr<SomeInteger>>(args[i])}) {
         common::visit(
             [&](const auto &ix) {
               using IntT = typename std::decay_t<decltype(ix)>::Result;
               if (auto *c{UnwrapConstantValue<IntT>(ix)}) {
                 constArgs[i] = ZeroExtend(*c);
               }

flang/lib/Evaluate/fold.cpp

 }
 
 Component FoldOperation(FoldingContext &context, Component &&component) {
   return {FoldOperation(context, std::move(component.base())),
       component.GetLastSymbol()};
 }
 
 NamedEntity FoldOperation(FoldingContext &context, NamedEntity &&x) {
-  if (Component * c{x.UnwrapComponent()}) {
+  if (Component *c{x.UnwrapComponent()}) {
     return NamedEntity{FoldOperation(context, std::move(*c))};
   } else {
     return std::move(x);
   }
 }
 
 Triplet FoldOperation(FoldingContext &context, Triplet &&triplet) {
   MaybeExtentExpr lower{triplet.lower()};
return common::visit(common::visitors{
                            },
                        },
       std::move(dataRef.u));
 }
 
 Substring FoldOperation(FoldingContext &context, Substring &&substring) {
   auto lower{Fold(context, substring.lower())};
   auto upper{Fold(context, substring.upper())};
-  if (const DataRef * dataRef{substring.GetParentIf<DataRef>()}) {
+  if (const DataRef *dataRef{substring.GetParentIf<DataRef>()}) {
     return Substring{FoldOperation(context, DataRef{*dataRef}),
         std::move(lower), std::move(upper)};
   } else {
     auto p{*substring.GetParentIf<StaticDataObject::Pointer>()};
     return Substring{std::move(p), std::move(lower), std::move(upper)};
   }
 }
 

flang/lib/Evaluate/shape.cpp

Result operator()(const Component &component) const {
     if (component.base().Rank() == 0) {
       return GetLowerBound(
           component.GetLastSymbol(), NamedEntity{common::Clone(component)});
     }
     return Result{1};
   }
 
   template <typename T> Result operator()(const Expr<T> &expr) const {
-    if (const Symbol * whole{UnwrapWholeSymbolOrComponentDataRef(expr)}) {
+    if (const Symbol *whole{UnwrapWholeSymbolOrComponentDataRef(expr)}) {
       return (*this)(*whole);
     } else if constexpr (common::HasMember<Constant<T>, decltype(expr.u)>) {
       if (const auto *con{std::get_if<Constant<T>>(&expr.u)}) {
         ConstantSubscripts lb{con->lbounds()};
         if (dimension_ < GetRank(lb)) {
           return Result{lb[dimension_]};
         }
       } else { // operation
return common::visit(
               NamedEntity base{symbol};
               return Result{CreateShape(n, base)};
             }
           },
           [](const semantics::EntityDetails &) {
             return ScalarShape(); // no dimensions seen
           },
           [&](const semantics::ProcEntityDetails &proc) {
-            if (const Symbol * interface{proc.procInterface()}) {
+            if (const Symbol *interface{proc.procInterface()}) {
               return (*this)(*interface);
             } else {
               return ScalarShape();
             }
           },
           [&](const semantics::AssocEntityDetails &assoc) {
             NamedEntity base{symbol};
             if (assoc.rank()) { // SELECT RANK case
auto GetShapeHelper::operator()(const ArrayRef &arrayRef) const -> Result {
   const NamedEntity &base{arrayRef.base()};
   for (const Subscript &ss : arrayRef.subscript()) {
     if (ss.Rank() > 0) {
       shape.emplace_back(GetExtent(ss, base, dimension));
     }
     ++dimension;
   }
   if (shape.empty()) {
-    if (const Component * component{base.UnwrapComponent()}) {
+    if (const Component *component{base.UnwrapComponent()}) {
       return (*this)(component->base());
     }
   }
   return shape;
 }
 
 auto GetShapeHelper::operator()(const CoarrayRef &coarrayRef) const -> Result {
   NamedEntity base{coarrayRef.GetBase()};
if (context_) {
           // because all of them might be OPTIONAL dummy arguments
           // of the caller. Return unknown shape ranked according
           // to the last actual array argument.
           return Shape(anyArrayArgRank, MaybeExtentExpr{});
         }
       }
     }
     return ScalarShape();
-  } else if (const Symbol * symbol{call.proc().GetSymbol()}) {
+  } else if (const Symbol *symbol{call.proc().GetSymbol()}) {
     return (*this)(*symbol);
   } else if (const auto *intrinsic{call.proc().GetSpecificIntrinsic()}) {
     if (intrinsic->name == "shape" || intrinsic->name == "lbound" ||
         intrinsic->name == "ubound") {
       // For LBOUND/UBOUND, these are the array-valued cases (no DIM=)
       if (!call.arguments().empty() && call.arguments().front()) {
         return Shape{
             MaybeExtentExpr{ExtentExpr{call.arguments().front()->Rank()}}};

flang/lib/Evaluate/target.cpp

int TargetCharacteristics::SelectedIntKind(std::int64_t precision) const {
   }
 }
 
 // SELECTED_REAL_KIND() -- F'2018 16.9.170
 class SelectedRealKindVisitor {
 public:
   SelectedRealKindVisitor(const TargetCharacteristics &targetCharacteristics,
       std::int64_t p, std::int64_t r)
-      : targetCharacteristics_{targetCharacteristics}, precision_{p}, range_{
-                                                                          r} {}
+      : targetCharacteristics_{targetCharacteristics}, precision_{p},
+        range_{r} {}
   using Result = std::optional<int>;
   using Types = RealTypes;
   template <typename T> Result Test() const {
     if (Scalar<T>::PRECISION >= precision_ && Scalar<T>::RANGE >= range_ &&
         targetCharacteristics_.IsTypeEnabled(T::category, T::kind)) {
       return {T::kind};
     } else {
       return std::nullopt;

flang/lib/Evaluate/tools.cpp

 auto IsVariableHelper::operator()(const ArrayRef &x) const -> Result {
   return (*this)(x.base());
 }
 auto IsVariableHelper::operator()(const Substring &x) const -> Result {
   return (*this)(x.GetBaseObject());
 }
 auto IsVariableHelper::operator()(const ProcedureDesignator &x) const
     -> Result {
-  if (const Symbol * symbol{x.GetSymbol()}) {
+  if (const Symbol *symbol{x.GetSymbol()}) {
     const Symbol *result{FindFunctionResult(*symbol)};
     return result && IsPointer(*result) && !IsProcedurePointer(*result);
   }
   return false;
 }
 
 // Conversions of COMPLEX component expressions to REAL.
 ConvertRealOperandsResult ConvertRealOperands(

 // IsObjectPointer()
 bool IsObjectPointer(const Expr<SomeType> &expr, FoldingContext &context) {
   if (IsNullObjectPointer(expr)) {
     return true;
   } else if (IsProcedurePointerTarget(expr)) {
     return false;
   } else if (const auto *funcRef{UnwrapProcedureRef(expr)}) {
     return IsVariable(*funcRef);
-  } else if (const Symbol * symbol{UnwrapWholeSymbolOrComponentDataRef(expr)}) {
+  } else if (const Symbol *symbol{UnwrapWholeSymbolOrComponentDataRef(expr)}) {
     return IsPointer(symbol->GetUltimate());
   } else {
     return false;
   }
 }
 
 const ProcedureRef *GetProcedureRef(const Expr<SomeType> &expr) {
   return UnwrapProcedureRef(expr);
bool IsAllocatableOrPointerObject(
     const Expr<SomeType> &expr, FoldingContext &context) {
   const semantics::Symbol *sym{UnwrapWholeSymbolOrComponentDataRef(expr)};
   return (sym && semantics::IsAllocatableOrPointer(sym->GetUltimate())) ||
       evaluate::IsObjectPointer(expr, context);
 }
 
 bool IsAllocatableDesignator(const Expr<SomeType> &expr) {
   // Allocatable sub-objects are not themselves allocatable (9.5.3.1 NOTE 2).
-  if (const semantics::Symbol *
-      sym{UnwrapWholeSymbolOrComponentOrCoarrayRef(expr)}) {
+  if (const semantics::Symbol *sym{
+          UnwrapWholeSymbolOrComponentOrCoarrayRef(expr)}) {
     return semantics::IsAllocatable(sym->GetUltimate());
   }
   return false;
 }
 
 bool MayBePassedAsAbsentOptional(
     const Expr<SomeType> &expr, FoldingContext &context) {
   const semantics::Symbol *sym{UnwrapWholeSymbolOrComponentDataRef(expr)};

 
 } // namespace Fortran::evaluate
 
 namespace Fortran::semantics {
 
 const Symbol &ResolveAssociations(const Symbol &original) {
   const Symbol &symbol{original.GetUltimate()};
   if (const auto *details{symbol.detailsIf<AssocEntityDetails>()}) {
-    if (const Symbol * nested{UnwrapWholeSymbolDataRef(details->expr())}) {
+    if (const Symbol *nested{UnwrapWholeSymbolDataRef(details->expr())}) {
       return ResolveAssociations(*nested);
     }
   }
   return symbol;
 }
 
 const Symbol &ResolveAssociationsExceptSelectRank(const Symbol &original) {
   const Symbol &symbol{original.GetUltimate()};
   if (const auto *details{symbol.detailsIf<AssocEntityDetails>()}) {
     if (!details->rank()) {
-      if (const Symbol * nested{UnwrapWholeSymbolDataRef(details->expr())}) {
+      if (const Symbol *nested{UnwrapWholeSymbolDataRef(details->expr())}) {
         return ResolveAssociations(*nested);
       }
     }
   }
   return symbol;
 }
 
 // When a construct association maps to a variable, and that variable
 // is not an array with a vector-valued subscript, return the base
 // Symbol of that variable, else nullptr.  Descends into other construct
 // associations when one associations maps to another.
 static const Symbol *GetAssociatedVariable(const AssocEntityDetails &details) {
   if (const auto &expr{details.expr()}) {
     if (IsVariable(*expr) && !HasVectorSubscript(*expr)) {
-      if (const Symbol * varSymbol{GetFirstSymbol(*expr)}) {
+      if (const Symbol *varSymbol{GetFirstSymbol(*expr)}) {
         return &GetAssociationRoot(*varSymbol);
       }
     }
   }
   return nullptr;
 }
 
 const Symbol &GetAssociationRoot(const Symbol &original) {
   const Symbol &symbol{ResolveAssociations(original)};
   if (const auto *details{symbol.detailsIf<AssocEntityDetails>()}) {
-    if (const Symbol * root{GetAssociatedVariable(*details)}) {
+    if (const Symbol *root{GetAssociatedVariable(*details)}) {
       return *root;
     }
   }
   return symbol;
 }
 
 const Symbol *GetMainEntry(const Symbol *symbol) {
   if (symbol) {
     if (const auto *subpDetails{symbol->detailsIf<SubprogramDetails>()}) {
-      if (const Scope * scope{subpDetails->entryScope()}) {
-        if (const Symbol * main{scope->symbol()}) {
+      if (const Scope *scope{subpDetails->entryScope()}) {
+        if (const Symbol *main{scope->symbol()}) {
           return main;
         }
       }
     }
   }
   return symbol;
 }
 
bool IsPureProcedure(const Scope &scope) {
   const Symbol *symbol{scope.GetSymbol()};
   return symbol && IsPureProcedure(*symbol);
 }
 
 bool IsElementalProcedure(const Symbol &original) {
   // An ENTRY is elemental if its containing subprogram is
   const Symbol &symbol{DEREF(GetMainEntry(&original.GetUltimate()))};
   if (const auto *procDetails{symbol.detailsIf<ProcEntityDetails>()}) {
-    if (const Symbol * procInterface{procDetails->procInterface()}) {
+    if (const Symbol *procInterface{procDetails->procInterface()}) {
       // procedure with an elemental interface, ignoring the elemental
       // aspect of intrinsic functions
       return !procInterface->attrs().test(Attr::INTRINSIC) &&
           IsElementalProcedure(*procInterface);
     }
   } else if (const auto *details{symbol.detailsIf<ProcBindingDetails>()}) {
     return !details->symbol().attrs().test(Attr::INTRINSIC) &&
         IsElementalProcedure(details->symbol());
bool IsProcedurePointer(const Symbol &original) {
   return IsPointer(symbol) && IsProcedure(symbol);
 }
 
 // 3.11 automatic data object
 bool IsAutomatic(const Symbol &original) {
   const Symbol &symbol{original.GetUltimate()};
   if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
     if (!object->isDummy() && !IsAllocatable(symbol) && !IsPointer(symbol)) {
-      if (const DeclTypeSpec * type{symbol.GetType()}) {
+      if (const DeclTypeSpec *type{symbol.GetType()}) {
         // If a type parameter value is not a constant expression, the
         // object is automatic.
         if (type->category() == DeclTypeSpec::Character) {
           if (const auto &length{
                   type->characterTypeSpec().length().GetExplicit()}) {
             if (!evaluate::IsConstantExpr(*length)) {
               return true;
             }
           }
-        } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+        } else if (const DerivedTypeSpec *derived{type->AsDerived()}) {
           for (const auto &pair : derived->parameters()) {
             if (const auto &value{pair.second.GetExplicit()}) {
               if (!evaluate::IsConstantExpr(*value)) {
                 return true;
               }
             }
           }
         }
bool IsSaved(const Symbol &original) {
   } else if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()};
              object && object->init()) {
     return true;
   } else if (IsProcedurePointer(symbol) && symbol.has<ProcEntityDetails>() &&
       symbol.get<ProcEntityDetails>().init()) {
     return true;
   } else if (scope.hasSAVE()) {
     return true; // bare SAVE statement
-  } else if (const Symbol * block{FindCommonBlockContaining(symbol)};
+  } else if (const Symbol *block{FindCommonBlockContaining(symbol)};
              block && block->attrs().test(Attr::SAVE)) {
     return true; // in COMMON with SAVE
   } else {
     return false;
   }
 }
 
 bool IsDummy(const Symbol &symbol) {
bool AreTkCompatibleTypes(const DeclTypeSpec *x, const DeclTypeSpec *y) {
   }
   return false;
 }
 
 common::IgnoreTKRSet GetIgnoreTKR(const Symbol &symbol) {
   common::IgnoreTKRSet result;
   if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
     result = object->ignoreTKR();
-    if (const Symbol * ownerSymbol{symbol.owner().symbol()}) {
+    if (const Symbol *ownerSymbol{symbol.owner().symbol()}) {
       if (const auto *ownerSubp{ownerSymbol->detailsIf<SubprogramDetails>()}) {
         if (ownerSubp->defaultIgnoreTKR()) {
           result |= common::ignoreTKRAll;
         }
       }
     }
   }
   return result;
 }
 
 } // namespace Fortran::semantics

flang/lib/Evaluate/type.cpp

static const semantics::Symbol *FindParentComponent(
   if (!scope) {
     scope = typeSymbol.scope();
   }
   if (scope) {
     const auto &dtDetails{typeSymbol.get<semantics::DerivedTypeDetails>()};
     // TODO: Combine with semantics::DerivedTypeDetails::GetParentComponent
     if (auto extends{dtDetails.GetParentComponentName()}) {
       if (auto iter{scope->find(*extends)}; iter != scope->cend()) {
-        if (const semantics::Symbol & symbol{*iter->second};
+        if (const semantics::Symbol &symbol{*iter->second};
             symbol.test(semantics::Symbol::Flag::ParentComp)) {
           return &symbol;
         }
       }
     }
   }
   return nullptr;
 }
 
 const semantics::DerivedTypeSpec *GetParentTypeSpec(
     const semantics::DerivedTypeSpec &derived) {
-  if (const semantics::Symbol * parent{FindParentComponent(derived)}) {
+  if (const semantics::Symbol *parent{FindParentComponent(derived)}) {
     return &parent->get<semantics::ObjectEntityDetails>()
                 .type()
                 ->derivedTypeSpec();
   } else {
     return nullptr;
   }
 }
 

 // dependency and should be repackaged into then "namespace semantics"
 // part of Evaluate/tools.cpp.
 
 static const semantics::Symbol *GetParentComponent(
     const semantics::DerivedTypeDetails &details,
     const semantics::Scope &scope) {
   if (auto extends{details.GetParentComponentName()}) {
     if (auto iter{scope.find(*extends)}; iter != scope.cend()) {
-      if (const Symbol & symbol{*iter->second};
+      if (const Symbol &symbol{*iter->second};
           symbol.test(semantics::Symbol::Flag::ParentComp)) {
         return &symbol;
       }
     }
   }
   return nullptr;
 }
 
 static const semantics::Symbol *GetParentComponent(
     const semantics::Symbol *symbol, const semantics::Scope &scope) {
   if (symbol) {
     if (const auto *dtDetails{
             symbol->detailsIf<semantics::DerivedTypeDetails>()}) {
       return GetParentComponent(*dtDetails, scope);
     }
   }
   return nullptr;
 }
 
 static const semantics::DerivedTypeSpec *GetParentTypeSpec(
     const semantics::Symbol *symbol, const semantics::Scope &scope) {
-  if (const Symbol * parentComponent{GetParentComponent(symbol, scope)}) {
+  if (const Symbol *parentComponent{GetParentComponent(symbol, scope)}) {
     return &parentComponent->get<semantics::ObjectEntityDetails>()
                 .type()
                 ->derivedTypeSpec();
   } else {
     return nullptr;
   }
 }
 

flang/lib/Evaluate/variable.cpp

 
 int ArrayRef::Rank() const {
   int rank{0};
   for (const auto &expr : subscript_) {
     rank += expr.Rank();
   }
   if (rank > 0) {
     return rank;
-  } else if (const Component * component{base_.UnwrapComponent()}) {
+  } else if (const Component *component{base_.UnwrapComponent()}) {
     return component->base().Rank();
   } else {
     return 0;
   }
 }
 
 int CoarrayRef::Rank() const {
   if (!subscript_.empty()) {
if (std::holds_alternative<Substring>(u)) {
       if (auto len{LEN()}) {
         if (auto n{ToInt64(*len)}) {
           return DynamicType{T::kind, *n};
         }
       }
       return DynamicType{TypeCategory::Character, T::kind};
     }
   }
-  if (const Symbol * symbol{GetLastSymbol()}) {
+  if (const Symbol *symbol{GetLastSymbol()}) {
     return DynamicType::From(*symbol);
   }
   return std::nullopt;
 }
 
 static NamedEntity AsNamedEntity(const SymbolVector &x) {
   CHECK(!x.empty());
   NamedEntity result{x.front()};
static bool AreSameSymbol(const Symbol &x, const Symbol &y) {
   }
   return false;
 }
 
 // Implements operator==() for a union type, using special case handling
 // for Symbol references.
 template <typename A> static bool TestVariableEquality(const A &x, const A &y) {
   const SymbolRef *xSymbol{std::get_if<SymbolRef>(&x.u)};
-  if (const SymbolRef * ySymbol{std::get_if<SymbolRef>(&y.u)}) {
+  if (const SymbolRef *ySymbol{std::get_if<SymbolRef>(&y.u)}) {
     return xSymbol && AreSameSymbol(*xSymbol, *ySymbol);
   } else {
     return x.u == y.u;
   }
 }
 
 bool BaseObject::operator==(const BaseObject &that) const {
   return TestVariableEquality(*this, that);

flang/lib/Frontend/CompilerInvocation.cpp

bool CompilerInvocation::createFromArgs(
   }
 
   // -flang-experimental-hlfir
   if (args.hasArg(clang::driver::options::OPT_flang_experimental_hlfir) ||
       args.hasArg(clang::driver::options::OPT_emit_hlfir)) {
     res.loweringOpts.setLowerToHighLevelFIR(true);
   }
 
-  if (args.hasArg(clang::driver::options::OPT_flang_experimental_polymorphism)) {
+  if (args.hasArg(
+          clang::driver::options::OPT_flang_experimental_polymorphism)) {
     res.loweringOpts.setPolymorphicTypeImpl(true);
   }
 
   success &= parseFrontendArgs(res.getFrontendOpts(), args, diags);
   parseTargetArgs(res.getTargetOpts(), args);
   parsePreprocessorArgs(res.getPreprocessorOpts(), args);
   parseCodeGenArgs(res.getCodeGenOpts(), args, diags);
   success &= parseDebugArgs(res.getCodeGenOpts(), args, diags);

flang/lib/Frontend/FrontendActions.cpp

if (auto offloadMod = llvm::dyn_cast<mlir::omp::OffloadModuleInterface>(
       isDevice = offloadMod.getIsTargetDevice();
 
     pm.addPass(fir::createOMPMarkDeclareTargetPass());
     if (isDevice) {
       pm.addPass(fir::createOMPEarlyOutliningPass());
       // FIXME: This should eventually be moved out of the
       // if, so that it also functions for host, however,
       // we must fix the filtering to function reasonably
-      // for host first.  
+      // for host first.
       pm.addPass(fir::createOMPFunctionFilteringPass());
     }
   }
 
   pm.enableVerifier(/*verifyPasses=*/true);
   pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
 
   if (mlir::failed(pm.run(*mlirModule))) {

flang/lib/Lower/ConvertCall.cpp

 /// Lower calls to intrinsic procedures with custom optional handling where the
 /// actual arguments have been pre-lowered
 static std::optional<hlfir::EntityWithAttributes> genCustomIntrinsicRefCore(
     Fortran::lower::PreparedActualArguments &loweredActuals,
     const Fortran::evaluate::SpecificIntrinsic *intrinsic,
     CallContext &callContext) {
   auto &builder = callContext.getBuilder();
   const auto &loc = callContext.loc;
-  assert(intrinsic && Fortran::lower::intrinsicRequiresCustomOptionalHandling(
-                          callContext.procRef, *intrinsic, callContext.converter));
+  assert(intrinsic &&
+         Fortran::lower::intrinsicRequiresCustomOptionalHandling(
 
   // helper to get a particular prepared argument
   auto getArgument = [&](std::size_t i, bool loadArg) -> fir::ExtendedValue {
     if (!loweredActuals[i])
       return fir::getAbsentIntrinsicArgument();
     hlfir::Entity actual = loweredActuals[i]->getActual(loc, builder);
     if (loadArg && fir::conformsWithPassByRef(actual.getType())) {
       return hlfir::loadTrivialScalar(loc, builder, actual);

flang/lib/Lower/ConvertExpr.cpp

fir::MutableBoxValue Fortran::lower::createMutableBox(
   // resulting MutableBoxValue. Variables of all other types are handled in the
   // bridge.
   Fortran::lower::StatementContext dummyStmtCtx;
   return ScalarExprLowering{loc, converter, symMap, dummyStmtCtx}
       .genMutableBoxValue(expr);
 }
 
 bool Fortran::lower::isParentComponent(const Fortran::lower::SomeExpr &expr) {
-  if (const Fortran::semantics::Symbol * symbol{GetLastSymbol(expr)}) {
+  if (const Fortran::semantics::Symbol *symbol{GetLastSymbol(expr)}) {
     if (symbol->test(Fortran::semantics::Symbol::Flag::ParentComp))
       return true;
   }
   return false;
 }
 
 // Handling special case where the last component is referring to the
 // parent component.

flang/lib/Lower/OpenACC.cpp

if (const auto *ifClause =
                                  dataClauseOperands.end());
     } else if (const auto *asyncClause =
                    std::get_if<Fortran::parser::AccClause::Async>(&clause.u)) {
       genAsyncClause(converter, asyncClause, async, addAsyncAttr, stmtCtx);
     } else if (const auto *waitClause =
                    std::get_if<Fortran::parser::AccClause::Wait>(&clause.u)) {
       genWaitClause(converter, waitClause, waitOperands, waitDevnum,
                     addWaitAttr, stmtCtx);
-    } else if(const auto *defaultClause = 
-                  std::get_if<Fortran::parser::AccClause::Default>(&clause.u)) {
+    } else if (const auto *defaultClause =
+                   std::get_if<Fortran::parser::AccClause::Default>(
+                       &clause.u)) {
       if ((defaultClause->v).v == llvm::acc::DefaultValue::ACC_Default_none)
         hasDefaultNone = true;
-      else if ((defaultClause->v).v == llvm::acc::DefaultValue::ACC_Default_present)
+      else if ((defaultClause->v).v ==
+               llvm::acc::DefaultValue::ACC_Default_present)
         hasDefaultPresent = true;
     }
   }
 
   // Prepare the operand segment size attribute and the operands value range.
   llvm::SmallVector<mlir::Value> operands;
   llvm::SmallVector<int32_t> operandSegments;
   addOperand(operands, operandSegments, ifCond);

flang/lib/Lower/OpenMP.cpp

if (const auto &redDefinedOp =
     default:
       TODO(currentLocation,
            "Reduction of some intrinsic operators is not supported");
       break;
     }
     for (const Fortran::parser::OmpObject &ompObject : objectList.v) {
       if (const auto *name{
               Fortran::parser::Unwrap<Fortran::parser::Name>(ompObject)}) {
-        if (const Fortran::semantics::Symbol * symbol{name->symbol}) {
+        if (const Fortran::semantics::Symbol *symbol{name->symbol}) {
           mlir::Value symVal = converter.getSymbolAddress(*symbol);
           mlir::Type redType =
               symVal.getType().cast<fir::ReferenceType>().getEleTy();
           reductionVars.push_back(symVal);
           if (redType.isa<fir::LogicalType>())
             decl = createReductionDecl(
                 firOpBuilder,
                 getReductionName(intrinsicOp, firOpBuilder.getI1Type()),
if (const auto *name{Fortran::parser::Unwrap<Fortran::parser::Name>(
           (name->source != "iand")) {
         TODO(currentLocation,
              "Reduction of intrinsic procedures is not supported");
       }
       std::string intrinsicOp = name->ToString();
       for (const Fortran::parser::OmpObject &ompObject : objectList.v) {
         if (const auto *name{
                 Fortran::parser::Unwrap<Fortran::parser::Name>(ompObject)}) {
-          if (const Fortran::semantics::Symbol * symbol{name->symbol}) {
+          if (const Fortran::semantics::Symbol *symbol{name->symbol}) {
             mlir::Value symVal = converter.getSymbolAddress(*symbol);
             mlir::Type redType =
                 symVal.getType().cast<fir::ReferenceType>().getEleTy();
             reductionVars.push_back(symVal);
             assert(redType.isIntOrIndexOrFloat() &&
                    "Unsupported reduction type");
             decl = createReductionDecl(
                 firOpBuilder, getReductionName(intrinsicOp, redType),
if (const auto &reductionClause =
         case Fortran::parser::DefinedOperator::IntrinsicOperator::NEQV:
           break;
         default:
           continue;
         }
         for (const Fortran::parser::OmpObject &ompObject : objectList.v) {
           if (const auto *name{
                   Fortran::parser::Unwrap<Fortran::parser::Name>(ompObject)}) {
-            if (const Fortran::semantics::Symbol * symbol{name->symbol}) {
+            if (const Fortran::semantics::Symbol *symbol{name->symbol}) {
               mlir::Value reductionVal = converter.getSymbolAddress(*symbol);
               mlir::Type reductionType =
                   reductionVal.getType().cast<fir::ReferenceType>().getEleTy();
               if (!reductionType.isa<fir::LogicalType>()) {
                 if (!reductionType.isIntOrIndexOrFloat())
                   continue;
               }
               for (mlir::OpOperand &reductionValUse : reductionVal.getUses()) {
if (const auto &reductionClause =
           if ((name->source != "max") && (name->source != "min") &&
               (name->source != "ior") && (name->source != "ieor") &&
               (name->source != "iand")) {
             continue;
           }
           for (const Fortran::parser::OmpObject &ompObject : objectList.v) {
             if (const auto *name{Fortran::parser::Unwrap<Fortran::parser::Name>(
                     ompObject)}) {
-              if (const Fortran::semantics::Symbol * symbol{name->symbol}) {
+              if (const Fortran::semantics::Symbol *symbol{name->symbol}) {
                 mlir::Value reductionVal = converter.getSymbolAddress(*symbol);
                 for (const mlir::OpOperand &reductionValUse :
                      reductionVal.getUses()) {
                   if (auto loadOp = mlir::dyn_cast<fir::LoadOp>(
                           reductionValUse.getOwner())) {
                     mlir::Value loadVal = loadOp.getRes();
                     // Max is lowered as a compare -> select.
                     // Match the pattern here.

flang/lib/Lower/PFTBuilder.cpp

 
 //===----------------------------------------------------------------------===//
 // FunctionLikeUnit implementation
 //===----------------------------------------------------------------------===//
 
 Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::MainProgram &func, const lower::pft::PftNode &parent,
     const semantics::SemanticsContext &semanticsContext)
-    : ProgramUnit{func, parent}, endStmt{
-                                     getFunctionStmt<parser::EndProgramStmt>(
-                                         func)} {
+    : ProgramUnit{func, parent},
+      endStmt{getFunctionStmt<parser::EndProgramStmt>(func)} {
   const auto &programStmt =
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t);
   if (programStmt.has_value()) {
     beginStmt = FunctionStatement(programStmt.value());
     const semantics::Symbol *symbol = getSymbol(*beginStmt);
     entryPointList[0].first = symbol;
     scope = symbol->scope();
   } else {

 
 Fortran::lower::pft::ModuleLikeUnit::ModuleLikeUnit(
     const parser::Module &m, const lower::pft::PftNode &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::ModuleStmt>(m)},
       endStmt{getModuleStmt<parser::EndModuleStmt>(m)} {}
 
 Fortran::lower::pft::ModuleLikeUnit::ModuleLikeUnit(
     const parser::Submodule &m, const lower::pft::PftNode &parent)
-    : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::SubmoduleStmt>(
-                                  m)},
+    : ProgramUnit{m, parent},
+      beginStmt{getModuleStmt<parser::SubmoduleStmt>(m)},
       endStmt{getModuleStmt<parser::EndSubmoduleStmt>(m)} {}
 
 parser::CharBlock
 Fortran::lower::pft::ModuleLikeUnit::getStartingSourceLoc() const {
   return stmtSourceLoc(beginStmt);
 }
 const Fortran::semantics::Scope &
 Fortran::lower::pft::ModuleLikeUnit::getScope() const {

flang/lib/Parser/basic-parsers.h

 template <LanguageFeature LF, typename PA> class NonstandardParser {
 public:
   using resultType = typename PA::resultType;
   constexpr NonstandardParser(const NonstandardParser &) = default;
   constexpr NonstandardParser(PA parser, MessageFixedText msg)
       : parser_{parser}, message_{msg} {}
   constexpr NonstandardParser(PA parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
-    if (UserState * ustate{state.userState()}) {
+    if (UserState *ustate{state.userState()}) {
       if (!ustate->features().IsEnabled(LF)) {
         return std::nullopt;
       }
     }
     auto at{state.GetLocation()};
     auto result{parser_.Parse(state)};
     if (result && !message_.empty()) {
       state.Nonstandard(

 // deprecated<LF>(a) is a parser that is optionally enabled, sets a strict
 // conformance violation flag, and may emit a warning message, if enabled.
 template <LanguageFeature LF, typename PA> class DeprecatedParser {
 public:
   using resultType = typename PA::resultType;
   constexpr DeprecatedParser(const DeprecatedParser &) = default;
   constexpr DeprecatedParser(PA parser) : parser_{parser} {}
   std::optional<resultType> Parse(ParseState &state) const {
-    if (UserState * ustate{state.userState()}) {
+    if (UserState *ustate{state.userState()}) {
       if (!ustate->features().IsEnabled(LF)) {
         return std::nullopt;
       }
     }
     auto at{state.GetLocation()};
     auto result{parser_.Parse(state)};
     if (result) {
       state.Nonstandard(CharBlock{at, state.GetLocation()}, LF,

flang/lib/Parser/message.cpp

return common::visit(
           },
           [](const MessageFormattedText &t) { return t.string(); },
           [](const MessageExpectedText &e) { return e.ToString(); },
       },
       text_);
 }
 
 void Message::ResolveProvenances(const AllCookedSources &allCooked) {
-  if (CharBlock * cb{std::get_if<CharBlock>(&location_)}) {
+  if (CharBlock *cb{std::get_if<CharBlock>(&location_)}) {
     if (std::optional<ProvenanceRange> resolved{
             allCooked.GetProvenanceRange(*cb)}) {
       location_ = *resolved;
     }
   }
-  if (Message * attachment{attachment_.get()}) {
+  if (Message *attachment{attachment_.get()}) {
     attachment->ResolveProvenances(allCooked);
   }
 }
 
 std::optional<ProvenanceRange> Message::GetProvenanceRange(
     const AllCookedSources &allCooked) const {
   return common::visit(
       common::visitors{

flang/lib/Parser/openmp-parsers.cpp

construct<OmpLinearClause>(
             nonemptyList(name), maybe(":" >> scalarIntConstantExpr)))))
 
 // 2.8.1 ALIGNED (list: alignment)
 TYPE_PARSER(construct<OmpAlignedClause>(
     Parser<OmpObjectList>{}, maybe(":" >> scalarIntConstantExpr)))
 
 // 2.9.5 ORDER ([order-modifier :]concurrent)
 TYPE_PARSER(construct<OmpOrderModifier>(
                 "REPRODUCIBLE" >> pure(OmpOrderModifier::Kind::Reproducible)) ||
     construct<OmpOrderModifier>(
         "UNCONSTRAINED" >> pure(OmpOrderModifier::Kind::Unconstrained)))
 
-TYPE_PARSER(construct<OmpOrderClause>(
-    maybe(Parser<OmpOrderModifier>{} / ":"),
+TYPE_PARSER(construct<OmpOrderClause>(maybe(Parser<OmpOrderModifier>{} / ":"),
     "CONCURRENT" >> pure(OmpOrderClause::Type::Concurrent)))
 
 TYPE_PARSER(
     construct<OmpObject>(designator) || construct<OmpObject>("/" >> name / "/"))
 
 TYPE_PARSER(
     "ACQUIRE" >> construct<OmpClause>(construct<OmpClause::Acquire>()) ||
     "ACQ_REL" >> construct<OmpClause>(construct<OmpClause::AcqRel>()) ||

flang/lib/Parser/preprocessor.cpp

 
 Definition::Definition(
     const TokenSequence &repl, std::size_t firstToken, std::size_t tokens)
     : replacement_{Tokenize({}, repl, firstToken, tokens)} {}
 
 Definition::Definition(const std::vector<std::string> &argNames,
     const TokenSequence &repl, std::size_t firstToken, std::size_t tokens,
     bool isVariadic)
-    : isFunctionLike_{true},
-      argumentCount_(argNames.size()), isVariadic_{isVariadic},
+    : isFunctionLike_{true}, argumentCount_(argNames.size()),
+      isVariadic_{isVariadic},
       replacement_{Tokenize(argNames, repl, firstToken, tokens)} {}
 
 Definition::Definition(const std::string &predefined, AllSources &sources)
     : isPredefined_{true},
       replacement_{
           predefined, sources.AddCompilerInsertion(predefined).start()} {}
 
 bool Definition::set_isDisabled(bool disable) {

flang/lib/Parser/prescan.cpp

: messages_{messages}, cooked_{cooked}, preprocessor_{preprocessor},
       allSources_{preprocessor_.allSources()}, features_{lfc},
       encoding_{allSources_.encoding()} {}
 
 Prescanner::Prescanner(const Prescanner &that)
     : messages_{that.messages_}, cooked_{that.cooked_},
       preprocessor_{that.preprocessor_}, allSources_{that.allSources_},
       features_{that.features_}, inFixedForm_{that.inFixedForm_},
       fixedFormColumnLimit_{that.fixedFormColumnLimit_},
-      encoding_{that.encoding_}, prescannerNesting_{that.prescannerNesting_ +
-                                     1},
+      encoding_{that.encoding_},
+      prescannerNesting_{that.prescannerNesting_ + 1},
       skipLeadingAmpersand_{that.skipLeadingAmpersand_},
       compilerDirectiveBloomFilter_{that.compilerDirectiveBloomFilter_},
       compilerDirectiveSentinels_{that.compilerDirectiveSentinels_} {}
 
 static inline constexpr bool IsFixedFormCommentChar(char ch) {
   return ch == '!' || ch == '*' || ch == 'C' || ch == 'c';
 }
 
if (*p != '\n' && *p != '!') {
     }
     Say(GetProvenanceRange(garbage, p),
         "excess characters after path name"_warn_en_US);
   }
   std::string buf;
   llvm::raw_string_ostream error{buf};
   Provenance provenance{GetProvenance(nextLine_)};
   std::optional<std::string> prependPath;
-  if (const SourceFile * currentFile{allSources_.GetSourceFile(provenance)}) {
+  if (const SourceFile *currentFile{allSources_.GetSourceFile(provenance)}) {
     prependPath = DirectoryName(currentFile->path());
   }
   const SourceFile *included{
       allSources_.Open(path, error, std::move(prependPath))};
   if (!included) {
     Say(provenance, "INCLUDE: %s"_err_en_US, error.str());
   } else if (included->bytes() > 0) {
     ProvenanceRange includeLineRange{

flang/lib/Parser/provenance.cpp

if (iter->second.AsCharBlock().Contains(x)) {
       return &iter->second;
     }
   }
   return nullptr;
 }
 
 std::optional<ProvenanceRange> AllCookedSources::GetProvenanceRange(
     CharBlock cb) const {
-  if (const CookedSource * c{Find(cb)}) {
+  if (const CookedSource *c{Find(cb)}) {
     return c->GetProvenanceRange(cb);
   } else {
     return std::nullopt;
   }
 }
 
 std::optional<CharBlock> AllCookedSources::GetCharBlockFromLineAndColumns(
     int line, int startColumn, int endColumn) const {
void AllCookedSources::Dump(llvm::raw_ostream &o) const {
   o << "AllSources:\n";
   allSources_.Dump(o);
   for (const auto &c : cooked_) {
     c.Dump(o);
   }
 }
 
 bool AllCookedSources::Precedes(CharBlock x, CharBlock y) const {
-  if (const CookedSource * xSource{Find(x)}) {
+  if (const CookedSource *xSource{Find(x)}) {
     if (xSource->AsCharBlock().Contains(y)) {
       return x.begin() < y.begin();
-    } else if (const CookedSource * ySource{Find(y)}) {
+    } else if (const CookedSource *ySource{Find(y)}) {
       return xSource->number() < ySource->number();
     } else {
       return true; // by fiat, all cooked source < anything outside
     }
   } else if (Find(y)) {
     return false;
   } else {
     // Both names are compiler-created (SaveTempName).

flang/lib/Parser/token-parsers.h

 
 // Skip over empty lines, leading spaces, and some compiler directives (viz.,
 // the ones that specify the source form) that might appear before the
 // next statement.  Skip over empty statements (bare semicolons) when
 // not in strict standard conformance mode.  Always succeeds.
 struct SkipStuffBeforeStatement {
   using resultType = Success;
   static std::optional<Success> Parse(ParseState &state) {
-    if (UserState * ustate{state.userState()}) {
-      if (ParsingLog * log{ustate->log()}) {
+    if (UserState *ustate{state.userState()}) {
+      if (ParsingLog *log{ustate->log()}) {
         // Save memory: vacate the parsing log before each statement unless
         // we're logging the whole parse for debugging.
         if (!ustate->instrumentedParse()) {
           log->clear();
         }
       }
     }
     while (std::optional<const char *> at{state.PeekAtNextChar()}) {

flang/lib/Parser/token-sequence.h

public:
   TokenSequence() {}
   TokenSequence(const TokenSequence &that) { Put(that); }
   TokenSequence(
       const TokenSequence &that, std::size_t at, std::size_t count = 1) {
     Put(that, at, count);
   }
   TokenSequence(TokenSequence &&that)
       : start_{std::move(that.start_)}, nextStart_{that.nextStart_},
-        char_{std::move(that.char_)}, provenances_{
-                                          std::move(that.provenances_)} {}
+        char_{std::move(that.char_)},
+        provenances_{std::move(that.provenances_)} {}
   TokenSequence(const std::string &s, Provenance p) { Put(s, p); }
 
   TokenSequence &operator=(const TokenSequence &that) {
     clear();
     Put(that);
     return *this;
   }
   TokenSequence &operator=(TokenSequence &&that);

flang/lib/Semantics/assignment.cpp

private:
 
   SemanticsContext &context_;
   int whereDepth_{0}; // number of WHEREs currently nested in
   // shape of masks in LHS of assignments in current WHERE:
   std::vector<std::optional<std::int64_t>> whereExtents_;
 };
 
 void AssignmentContext::Analyze(const parser::AssignmentStmt &stmt) {
-  if (const evaluate::Assignment * assignment{GetAssignment(stmt)}) {
+  if (const evaluate::Assignment *assignment{GetAssignment(stmt)}) {
     const SomeExpr &lhs{assignment->lhs};
     const SomeExpr &rhs{assignment->rhs};
     auto lhsLoc{std::get<parser::Variable>(stmt.t).GetSource()};
     const Scope &scope{context_.FindScope(lhsLoc)};
     if (auto whyNot{WhyNotDefinable(lhsLoc, scope,
             DefinabilityFlags{DefinabilityFlag::VectorSubscriptIsOk}, lhs)}) {
       if (auto *msg{Say(lhsLoc,
               "Left-hand side of assignment is not definable"_err_en_US)}) {
if (const evaluate::Assignment *assignment{GetAssignment(stmt)}) {
     if (whereDepth_ > 0) {
       CheckShape(lhsLoc, &lhs);
     }
   }
 }
 
 void AssignmentContext::Analyze(const parser::PointerAssignmentStmt &stmt) {
   CHECK(whereDepth_ == 0);
-  if (const evaluate::Assignment * assignment{GetAssignment(stmt)}) {
+  if (const evaluate::Assignment *assignment{GetAssignment(stmt)}) {
     parser::CharBlock at{context_.location().value()};
     auto restorer{foldingContext().messages().SetLocation(at)};
     CheckPointerAssignment(context_, *assignment, context_.FindScope(at));
   }
 }
 
 static std::optional<std::string> GetPointerComponentDesignatorName(
     const SomeExpr &expr) {
   if (const auto *derived{
           evaluate::GetDerivedTypeSpec(evaluate::DynamicType::From(expr))}) {
     PotentialAndPointerComponentIterator potentials{*derived};
     if (auto pointer{
             std::find_if(potentials.begin(), potentials.end(), IsPointer)}) {
       return pointer.BuildResultDesignatorName();
     }
   }
   return std::nullopt;
 }
 
 // Checks C1594(5,6); false if check fails
 bool CheckCopyabilityInPureScope(parser::ContextualMessages &messages,
     const SomeExpr &expr, const Scope &scope) {
-  if (const Symbol * base{GetFirstSymbol(expr)}) {
+  if (const Symbol *base{GetFirstSymbol(expr)}) {
     if (const char *why{
             WhyBaseObjectIsSuspicious(base->GetUltimate(), scope)}) {
       if (auto pointer{GetPointerComponentDesignatorName(expr)}) {
         evaluate::SayWithDeclaration(messages, *base,
             "A pure subprogram may not copy the value of '%s' because it is %s"
             " and has the POINTER potential subobject component '%s'"_err_en_US,
             base->name(), why, *pointer);
         return false;

flang/lib/Semantics/check-allocate.cpp

struct AllocateCheckerInfo {
   bool gotStream{false};
   bool gotPinned{false};
 };
 
 class AllocationCheckerHelper {
 public:
   AllocationCheckerHelper(
       const parser::Allocation &alloc, AllocateCheckerInfo &info)
-      : allocateInfo_{info}, allocateObject_{std::get<parser::AllocateObject>(
-                                 alloc.t)},
+      : allocateInfo_{info},
+        allocateObject_{std::get<parser::AllocateObject>(alloc.t)},
         name_{parser::GetLastName(allocateObject_)},
         symbol_{name_.symbol ? &name_.symbol->GetUltimate() : nullptr},
         type_{symbol_ ? symbol_->GetType() : nullptr},
-        allocateShapeSpecRank_{ShapeSpecRank(alloc)}, rank_{symbol_
-                                                              ? symbol_->Rank()
-                                                              : 0},
+        allocateShapeSpecRank_{ShapeSpecRank(alloc)},
+        rank_{symbol_ ? symbol_->Rank() : 0},
         allocateCoarraySpecRank_{CoarraySpecRank(alloc)},
         corank_{symbol_ ? symbol_->Corank() : 0} {}
 
   bool RunChecks(SemanticsContext &context);
 
 private:
   bool hasAllocateShapeSpecList() const { return allocateShapeSpecRank_ != 0; }
   bool hasAllocateCoarraySpec() const { return allocateCoarraySpecRank_ != 0; }
if (const auto &coarraySpec{
       return 0;
     }
   }
 
   void GatherAllocationBasicInfo() {
     if (type_->category() == DeclTypeSpec::Category::Character) {
       hasDeferredTypeParameter_ =
           type_->characterTypeSpec().length().isDeferred();
-    } else if (const DerivedTypeSpec * derivedTypeSpec{type_->AsDerived()}) {
+    } else if (const DerivedTypeSpec *derivedTypeSpec{type_->AsDerived()}) {
       for (const auto &pair : derivedTypeSpec->parameters()) {
         hasDeferredTypeParameter_ |= pair.second.isDeferred();
       }
       isAbstract_ = derivedTypeSpec->typeSymbol().attrs().test(Attr::ABSTRACT);
     }
     isUnlimitedPolymorphic_ =
         type_->category() == DeclTypeSpec::Category::ClassStar;
   }
if (const auto &typeSpec{
           std::get<std::optional<parser::TypeSpec>>(allocateStmt.t)}) {
     info.typeSpec = typeSpec->declTypeSpec;
     if (!info.typeSpec) {
       CHECK(context.AnyFatalError());
       return std::nullopt;
     }
     info.gotTypeSpec = true;
     info.typeSpecLoc = parser::FindSourceLocation(*typeSpec);
-    if (const DerivedTypeSpec * derived{info.typeSpec->AsDerived()}) {
+    if (const DerivedTypeSpec *derived{info.typeSpec->AsDerived()}) {
       // C937
       if (auto it{FindCoarrayUltimateComponent(*derived)}) {
         context
             .Say("Type-spec in ALLOCATE must not specify a type with a coarray"
                  " ultimate component"_err_en_US)
             .Attach(it->name(),
                 "Type '%s' has coarray ultimate component '%s' declared here"_en_US,
                 info.typeSpec->AsFortran(), it.BuildResultDesignatorName());
if (const auto *expr{GetExpr(context, DEREF(parserSourceExpr))}) {
       info.sourceExprType = expr->GetType();
       if (!info.sourceExprType) {
         context.Say(at,
             "Typeless item not allowed as SOURCE or MOLD in ALLOCATE"_err_en_US);
         return std::nullopt;
       }
       info.sourceExprRank = expr->Rank();
       info.sourceExprLoc = parserSourceExpr->source;
-      if (const DerivedTypeSpec *
-          derived{evaluate::GetDerivedTypeSpec(info.sourceExprType)}) {
+      if (const DerivedTypeSpec *derived{
+              evaluate::GetDerivedTypeSpec(info.sourceExprType)}) {
         // C949
         if (auto it{FindCoarrayUltimateComponent(*derived)}) {
           context
               .Say(at,
                   "SOURCE or MOLD expression must not have a type with a coarray ultimate component"_err_en_US)
               .Attach(it->name(),
                   "Type '%s' has coarray ultimate component '%s' declared here"_en_US,
                   info.sourceExprType.value().AsFortran(),
static std::optional<AllocateCheckerInfo> CheckAllocateOptions(
   return info;
 }
 
 // Beware, type compatibility is not symmetric, IsTypeCompatible checks that
 // type1 is type compatible with type2. Note: type parameters are not considered
 // in this test.
 static bool IsTypeCompatible(
     const DeclTypeSpec &type1, const DerivedTypeSpec &derivedType2) {
-  if (const DerivedTypeSpec * derivedType1{type1.AsDerived()}) {
+  if (const DerivedTypeSpec *derivedType1{type1.AsDerived()}) {
     if (type1.category() == DeclTypeSpec::Category::TypeDerived) {
       return &derivedType1->typeSymbol() == &derivedType2.typeSymbol();
     } else if (type1.category() == DeclTypeSpec::Category::ClassDerived) {
       for (const DerivedTypeSpec *parent{&derivedType2}; parent;
            parent = parent->typeSymbol().GetParentTypeSpec()) {
         if (&derivedType1->typeSymbol() == &parent->typeSymbol()) {
           return true;
         }
       }
     }
   }
   return false;
 }
 
 static bool IsTypeCompatible(
     const DeclTypeSpec &type1, const DeclTypeSpec &type2) {
   if (type1.category() == DeclTypeSpec::Category::ClassStar) {
     // TypeStar does not make sense in allocate context because assumed type
     // cannot be allocatable (C709)
     return true;
   }
-  if (const IntrinsicTypeSpec * intrinsicType2{type2.AsIntrinsic()}) {
-    if (const IntrinsicTypeSpec * intrinsicType1{type1.AsIntrinsic()}) {
+  if (const IntrinsicTypeSpec *intrinsicType2{type2.AsIntrinsic()}) {
+    if (const IntrinsicTypeSpec *intrinsicType1{type1.AsIntrinsic()}) {
       return intrinsicType1->category() == intrinsicType2->category();
     } else {
       return false;
     }
-  } else if (const DerivedTypeSpec * derivedType2{type2.AsDerived()}) {
+  } else if (const DerivedTypeSpec *derivedType2{type2.AsDerived()}) {
     return IsTypeCompatible(type1, *derivedType2);
   }
   return false;
 }
 
 static bool IsTypeCompatible(
     const DeclTypeSpec &type1, const evaluate::DynamicType &type2) {
   if (type1.category() == DeclTypeSpec::Category::ClassStar) {
     // TypeStar does not make sense in allocate context because assumed type
     // cannot be allocatable (C709)
     return true;
   }
   if (type2.category() != evaluate::TypeCategory::Derived) {
-    if (const IntrinsicTypeSpec * intrinsicType1{type1.AsIntrinsic()}) {
+    if (const IntrinsicTypeSpec *intrinsicType1{type1.AsIntrinsic()}) {
       return intrinsicType1->category() == type2.category();
     } else {
       return false;
     }
   } else if (!type2.IsUnlimitedPolymorphic()) {
     return IsTypeCompatible(type1, type2.GetDerivedTypeSpec());
   }
   return false;
 }
 
 // Note: Check assumes  type1 is compatible with type2. type2 may have more type
 // parameters than type1 but if a type2 type parameter is assumed, then this
 // check enforce that type1 has it. type1 can be unlimited polymorphic, but not
 // type2.
 static bool HaveSameAssumedTypeParameters(
     const DeclTypeSpec &type1, const DeclTypeSpec &type2) {
   if (type2.category() == DeclTypeSpec::Category::Character) {
     bool type2LengthIsAssumed{type2.characterTypeSpec().length().isAssumed()};
     if (type1.category() == DeclTypeSpec::Category::Character) {
       return type1.characterTypeSpec().length().isAssumed() ==
           type2LengthIsAssumed;
     }
     // It is possible to reach this if type1 is unlimited polymorphic
     return !type2LengthIsAssumed;
-  } else if (const DerivedTypeSpec * derivedType2{type2.AsDerived()}) {
+  } else if (const DerivedTypeSpec *derivedType2{type2.AsDerived()}) {
     int type2AssumedParametersCount{0};
     int type1AssumedParametersCount{0};
     for (const auto &pair : derivedType2->parameters()) {
       type2AssumedParametersCount += pair.second.isAssumed();
     }
     // type1 may be unlimited polymorphic
-    if (const DerivedTypeSpec * derivedType1{type1.AsDerived()}) {
+    if (const DerivedTypeSpec *derivedType1{type1.AsDerived()}) {
       for (auto it{derivedType1->parameters().begin()};
            it != derivedType1->parameters().end(); ++it) {
         if (it->second.isAssumed()) {
           ++type1AssumedParametersCount;
           const ParamValue *param{derivedType2->FindParameter(it->first)};
           if (!param || !param->isAssumed()) {
             // type1 has an assumed parameter that is not a type parameter of
             // type2 or not assumed in type2.
             return false;
           }
         }
       }
     }
     // Will return false if type2 has type parameters that are not assumed in
     // type1 or do not exist in type1
     return type1AssumedParametersCount == type2AssumedParametersCount;
   }
   return true; // other intrinsic types have no length type parameters
 }
 
 static std::optional<std::int64_t> GetTypeParameterInt64Value(
     const Symbol &parameterSymbol, const DerivedTypeSpec &derivedType) {
-  if (const ParamValue *
-      paramValue{derivedType.FindParameter(parameterSymbol.name())}) {
+  if (const ParamValue *paramValue{
+          derivedType.FindParameter(parameterSymbol.name())}) {
     return evaluate::ToInt64(paramValue->GetExplicit());
   }
   return std::nullopt;
 }
 
 static bool HaveCompatibleTypeParameters(
     const DerivedTypeSpec &derivedType1, const DerivedTypeSpec &derivedType2) {
   for (const Symbol &symbol :
       OrderParameterDeclarations(derivedType1.typeSymbol())) {
     auto v1{GetTypeParameterInt64Value(symbol, derivedType1)};
     auto v2{GetTypeParameterInt64Value(symbol, derivedType2)};
     if (v1 && v2 && *v1 != *v2) {
       return false;
     }
   }
   return true;
 }
 
 static bool HaveCompatibleTypeParameters(
     const DeclTypeSpec &type1, const evaluate::DynamicType &type2) {
   if (type1.category() == DeclTypeSpec::Category::ClassStar) {
     return true;
   }
-  if (const IntrinsicTypeSpec * intrinsicType1{type1.AsIntrinsic()}) {
+  if (const IntrinsicTypeSpec *intrinsicType1{type1.AsIntrinsic()}) {
     return evaluate::ToInt64(intrinsicType1->kind()).value() == type2.kind();
   } else if (type2.IsUnlimitedPolymorphic()) {
     return false;
-  } else if (const DerivedTypeSpec * derivedType1{type1.AsDerived()}) {
+  } else if (const DerivedTypeSpec *derivedType1{type1.AsDerived()}) {
     return HaveCompatibleTypeParameters(
         *derivedType1, type2.GetDerivedTypeSpec());
   } else {
     common::die("unexpected type1 category");
   }
 }
 
 static bool HaveCompatibleTypeParameters(
     const DeclTypeSpec &type1, const DeclTypeSpec &type2) {
   if (type1.category() == DeclTypeSpec::Category::ClassStar) {
     return true;
-  } else if (const IntrinsicTypeSpec * intrinsicType1{type1.AsIntrinsic()}) {
+  } else if (const IntrinsicTypeSpec *intrinsicType1{type1.AsIntrinsic()}) {
     const IntrinsicTypeSpec *intrinsicType2{type2.AsIntrinsic()};
     return !intrinsicType2 || intrinsicType1->kind() == intrinsicType2->kind();
-  } else if (const DerivedTypeSpec * derivedType1{type1.AsDerived()}) {
+  } else if (const DerivedTypeSpec *derivedType1{type1.AsDerived()}) {
     const DerivedTypeSpec *derivedType2{type2.AsDerived()};
     return !derivedType2 ||
         HaveCompatibleTypeParameters(*derivedType1, *derivedType2);
   } else {
     common::die("unexpected type1 category");
   }
 }
 
bool AllocationCheckerHelper::RunCoarrayRelatedChecks(
     SemanticsContext &context) const {
   if (!symbol_) {
     CHECK(context.AnyFatalError());
     return false;
   }
   if (evaluate::IsCoarray(*symbol_)) {
     if (allocateInfo_.gotTypeSpec) {
       // C938
-      if (const DerivedTypeSpec *
-          derived{allocateInfo_.typeSpec->AsDerived()}) {
+      if (const DerivedTypeSpec *derived{allocateInfo_.typeSpec->AsDerived()}) {
         if (IsTeamType(derived)) {
           context
               .Say(allocateInfo_.typeSpecLoc.value(),
                   "Type-Spec in ALLOCATE must not be TEAM_TYPE from ISO_FORTRAN_ENV when an allocatable object is a coarray"_err_en_US)
               .Attach(name_.source, "'%s' is a coarray"_en_US, name_.source);
           return false;
         } else if (IsIsoCType(derived)) {
           context
bool AllocationCheckerHelper::RunCoarrayRelatedChecks(
   } else { // Not a coarray
     if (hasAllocateCoarraySpec()) {
       // C941
       context.Say(name_.source,
           "Coarray specification must not appear in ALLOCATE when allocatable object is not a coarray"_err_en_US);
       return false;
     }
   }
-  if (const parser::CoindexedNamedObject *
-      coindexedObject{parser::GetCoindexedNamedObject(allocateObject_)}) {
+  if (const parser::CoindexedNamedObject *coindexedObject{
+          parser::GetCoindexedNamedObject(allocateObject_)}) {
     // C950
     context.Say(parser::FindSourceLocation(*coindexedObject),
         "Allocatable object must not be coindexed in ALLOCATE"_err_en_US);
     return false;
   }
   return true;
 }
 

flang/lib/Semantics/check-call.cpp

static void CheckImplicitInterfaceArg(evaluate::ActualArgument &arg,
   }
   if (auto type{arg.GetType()}) {
     if (type->IsAssumedType()) {
       messages.Say(
           "Assumed type argument requires an explicit interface"_err_en_US);
     } else if (type->IsPolymorphic()) {
       messages.Say(
           "Polymorphic argument requires an explicit interface"_err_en_US);
-    } else if (const DerivedTypeSpec * derived{GetDerivedTypeSpec(type)}) {
+    } else if (const DerivedTypeSpec *derived{GetDerivedTypeSpec(type)}) {
       if (!derived->parameters().empty()) {
         messages.Say(
             "Parameterized derived type argument requires an explicit interface"_err_en_US);
       }
     }
   }
   if (const auto *expr{arg.UnwrapExpr()}) {
     if (IsBOZLiteral(*expr)) {
static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
   const auto *derived{evaluate::GetDerivedTypeSpec(actualType.type())};
   if (derived && !derived->IsVectorType()) {
     if (dummy.type.type().IsAssumedType()) {
       if (!derived->parameters().empty()) { // 15.5.2.4(2)
         messages.Say(
             "Actual argument associated with TYPE(*) %s may not have a parameterized derived type"_err_en_US,
             dummyName);
       }
-      if (const Symbol *
-          tbp{FindImmediateComponent(*derived, [](const Symbol &symbol) {
+      if (const Symbol *tbp{
+              FindImmediateComponent(*derived, [](const Symbol &symbol) {
                 return symbol.has<ProcBindingDetails>();
               })}) { // 15.5.2.4(2)
         evaluate::SayWithDeclaration(messages, *tbp,
             "Actual argument associated with TYPE(*) %s may not have type-bound procedure '%s'"_err_en_US,
             dummyName, tbp->name());
       }
       auto finals{FinalsForDerivedTypeInstantiation(*derived)};
       if (!finals.empty()) { // 15.5.2.4(2)
         SourceName name{finals.front()->name()};
         if (auto *msg{messages.Say(
if (actualIsCoindexed) {
                 FindAllocatableUltimateComponent(*derived)}) { // 15.5.2.4(6)
           evaluate::SayWithDeclaration(messages, *bad,
               "Coindexed actual argument with ALLOCATABLE ultimate component '%s' must be associated with a %s with VALUE or INTENT(IN) attributes"_err_en_US,
               bad.BuildResultDesignatorName(), dummyName);
         }
       }
       if (auto coarrayRef{evaluate::ExtractCoarrayRef(actual)}) { // C1537
         const Symbol &coarray{coarrayRef->GetLastSymbol()};
-        if (const DeclTypeSpec * type{coarray.GetType()}) {
-          if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+        if (const DeclTypeSpec *type{coarray.GetType()}) {
+          if (const DerivedTypeSpec *derived{type->AsDerived()}) {
             if (auto bad{semantics::FindPointerUltimateComponent(*derived)}) {
               evaluate::SayWithDeclaration(messages, coarray,
                   "Coindexed object '%s' with POINTER ultimate component '%s' cannot be associated with %s"_err_en_US,
                   coarray.name(), bad.BuildResultDesignatorName(), dummyName);
             }
           }
         }
       }

 static void CheckProcedureArg(evaluate::ActualArgument &arg,
     const characteristics::Procedure &proc,
     const characteristics::DummyProcedure &dummy, const std::string &dummyName,
     SemanticsContext &context) {
   evaluate::FoldingContext &foldingContext{context.foldingContext()};
   parser::ContextualMessages &messages{foldingContext.messages()};
   auto restorer{
       messages.SetLocation(arg.sourceLocation().value_or(messages.at()))};
-  const characteristics::Procedure &interface { dummy.procedure.value() };
+  const characteristics::Procedure &interface {
+    dummy.procedure.value()
+  };
   if (const auto *expr{arg.UnwrapExpr()}) {
     bool dummyIsPointer{
         dummy.attrs.test(characteristics::DummyProcedure::Attr::Pointer)};
     const auto *argProcDesignator{
         std::get_if<evaluate::ProcedureDesignator>(&expr->u)};
     const auto *argProcSymbol{
         argProcDesignator ? argProcDesignator->GetSymbol() : nullptr};
     if (argProcSymbol) {
common::visit(
                                object.attrs.test(characteristics::
                                        DummyDataObject::Attr::Optional)) &&
                     evaluate::IsNullObjectPointer(*expr)) {
                   // FOO(NULL(without MOLD=))
                   if (object.type.type().IsAssumedLengthCharacter()) {
                     messages.Say(
                         "Actual argument associated with %s is a NULL() pointer without a MOLD= to provide a character length"_err_en_US,
                         dummyName);
-                  } else if (const DerivedTypeSpec *
-                      derived{GetDerivedTypeSpec(object.type.type())}) {
+                  } else if (const DerivedTypeSpec *derived{
+                                 GetDerivedTypeSpec(object.type.type())}) {
                     for (const auto &[pName, pValue] : derived->parameters()) {
                       if (pValue.isAssumed()) {
                         messages.Say(
                             "Actual argument associated with %s is a NULL() pointer without a MOLD= to provide a value for the assumed type parameter '%s'"_err_en_US,
                             dummyName, pName.ToString());
                         break;
                       }
                     }
if (auto source{characteristics::TypeAndShape::Characterize(
           } else {
             messages.Say(
                 "Element size of MOLD= array may not be zero unless SOURCE= is empty"_warn_en_US);
           }
         }
       }
     }
     if (arguments.size() > 2) { // SIZE=
-      if (const Symbol *
-          whole{UnwrapWholeSymbolOrComponentDataRef(arguments[2])}) {
+      if (const Symbol *whole{
+              UnwrapWholeSymbolOrComponentDataRef(arguments[2])}) {
         if (IsOptional(*whole)) {
           messages.Say(
               "SIZE= argument may not be the optional dummy argument '%s'"_err_en_US,
               whole->name());
         } else if (context.ShouldWarn(
                        common::UsageWarning::TransferSizePresence) &&
             IsAllocatableOrPointer(*whole)) {
           messages.Say(

flang/lib/Semantics/check-cuda.cpp

 
 struct DeviceExprChecker
     : public evaluate::AnyTraverse<DeviceExprChecker, MaybeMsg> {
   using Result = MaybeMsg;
   using Base = evaluate::AnyTraverse<DeviceExprChecker, Result>;
   DeviceExprChecker() : Base(*this) {}
   using Base::operator();
   Result operator()(const evaluate::ProcedureDesignator &x) const {
-    if (const Symbol * sym{x.GetInterfaceSymbol()}) {
+    if (const Symbol *sym{x.GetInterfaceSymbol()}) {
       const auto *subp{
           sym->GetUltimate().detailsIf<semantics::SubprogramDetails>()};
       if (subp) {
         if (auto attrs{subp->cudaSubprogramAttrs()}) {
           if (*attrs == common::CUDASubprogramAttrs::HostDevice ||
               *attrs == common::CUDASubprogramAttrs::Device) {
             return {};
           }

flang/lib/Semantics/check-declarations.cpp

void CheckHelper::CheckExplicitSave(const Symbol &symbol) {
   } else if (IsDummy(ultimate)) {
     messages_.Say(
         "The dummy argument '%s' may not have an explicit SAVE attribute"_err_en_US,
         symbol.name());
   } else if (IsFunctionResult(ultimate)) {
     messages_.Say(
         "The function result variable '%s' may not have an explicit SAVE attribute"_err_en_US,
         symbol.name());
-  } else if (const Symbol * common{FindCommonBlockContaining(ultimate)}) {
+  } else if (const Symbol *common{FindCommonBlockContaining(ultimate)}) {
     messages_.Say(
         "The entity '%s' in COMMON block /%s/ may not have an explicit SAVE attribute"_err_en_US,
         symbol.name(), common->name());
   } else if (IsAutomatic(ultimate)) {
     messages_.Say(
         "The automatic object '%s' may not have an explicit SAVE attribute"_err_en_US,
         symbol.name());
   } else if (!evaluate::IsVariable(ultimate) && !IsProcedurePointer(ultimate)) {
     messages_.Say(
         "The entity '%s' with an explicit SAVE attribute must be a variable, procedure pointer, or COMMON block"_err_en_US,
         symbol.name());
   }
 }
 
 void CheckHelper::CheckBindCFunctionResult(const Symbol &symbol) { // C1553
   if (!innermostSymbol_ || !IsBindCProcedure(*innermostSymbol_)) {
     return;
   }
   if (IsPointer(symbol) || IsAllocatable(symbol)) {
     messages_.Say(
         "BIND(C) function result cannot have ALLOCATABLE or POINTER attribute"_err_en_US);
   }
-  if (const DeclTypeSpec * type{symbol.GetType()};
+  if (const DeclTypeSpec *type{symbol.GetType()};
       type && type->category() == DeclTypeSpec::Character) {
     bool isConstOne{false}; // 18.3.1(1)
     if (const auto &len{type->characterTypeSpec().length().GetExplicit()}) {
       if (auto constLen{evaluate::ToInt64(*len)}) {
         isConstOne = constLen == 1;
       }
     }
     if (!isConstOne) {
if (subpDetails /* not a module variable */ && IsSaved(symbol) &&
       messages_.Say(
           "Saved object '%s' in host code may not have ATTRIBUTES(DEVICE) unless allocatable"_err_en_US,
           symbol.name(),
           parser::ToUpperCaseLetters(common::EnumToString(attr)));
     }
     if (isComponent) {
       if (attr == common::CUDADataAttr::Device) {
         const DeclTypeSpec *type{symbol.GetType()};
-        if (const DerivedTypeSpec *
-            derived{type ? type->AsDerived() : nullptr}) {
+        if (const DerivedTypeSpec *derived{
+                type ? type->AsDerived() : nullptr}) {
           DirectComponentIterator directs{*derived};
           if (auto iter{std::find_if(directs.begin(), directs.end(),
                   [](const Symbol &) { return false; })}) {
             messages_.Say(
                 "Derived type component '%s' may not have ATTRIBUTES(DEVICE) as it has a direct device component '%s'"_err_en_US,
                 symbol.name(), iter.BuildResultDesignatorName());
           }
         }
if (!symbol.attrs().test(Attr::POINTER)) { // C756
       messages_.Say(name,
           "Procedure component '%s' must have POINTER attribute"_err_en_US,
           name);
     }
     CheckPassArg(symbol, details.procInterface(), details);
   }
   if (IsPointer(symbol)) {
     CheckPointerInitialization(symbol);
-    if (const Symbol * interface{details.procInterface()}) {
+    if (const Symbol *interface{details.procInterface()}) {
       const Symbol &ultimate{interface->GetUltimate()};
       if (ultimate.attrs().test(Attr::INTRINSIC)) {
         if (const auto intrinsic{
                 context_.intrinsics().IsSpecificIntrinsicFunction(
                     ultimate.name().ToString())};
             !intrinsic || intrinsic->isRestrictedSpecific) { // C1515
           messages_.Say(
               "Intrinsic procedure '%s' is not an unrestricted specific "
if (const Scope *entryScope{details.entryScope()}) {
     if (error) {
       if (auto *msg{messages_.Say(symbol.name(), *error)}) {
         if (subprogram) {
           msg->Attach(subprogram->name(), "Containing subprogram"_en_US);
         }
       }
     }
   }
-  if (const MaybeExpr & stmtFunction{details.stmtFunction()}) {
+  if (const MaybeExpr &stmtFunction{details.stmtFunction()}) {
     if (auto msg{evaluate::CheckStatementFunction(
             symbol, *stmtFunction, context_.foldingContext())}) {
       SayWithDeclaration(symbol, std::move(*msg));
     } else if (details.result().flags().test(Symbol::Flag::Implicit)) {
       // 15.6.4 p2 weird requirement
-      if (const Symbol *
-          host{symbol.owner().parent().FindSymbol(symbol.name())}) {
+      if (const Symbol *host{
+              symbol.owner().parent().FindSymbol(symbol.name())}) {
         evaluate::AttachDeclaration(
             messages_.Say(symbol.name(),
                 "An implicitly typed statement function should not appear when the same symbol is available in its host scope"_port_en_US),
             *host);
       }
     }
     if (GetProgramUnitOrBlockConstructContaining(symbol).kind() ==
         Scope::Kind::BlockConstruct) { // C1107
if ((!details.cudaLaunchBounds().empty() ||
           !details.cudaClusterDims().empty()) &&
       !(cudaAttrs &&
           (*cudaAttrs == common::CUDASubprogramAttrs::Global ||
               *cudaAttrs == common::CUDASubprogramAttrs::Grid_Global))) {
     messages_.Say(symbol.name(),
         "A subroutine may not have LAUNCH_BOUNDS() or CLUSTER_DIMS() unless it has ATTRIBUTES(GLOBAL) or ATTRIBUTES(GRID_GLOBAL)"_err_en_US);
   }
   if (!IsStmtFunction(symbol)) {
-    if (const Scope * outerDevice{FindCUDADeviceContext(&symbol.owner())};
+    if (const Scope *outerDevice{FindCUDADeviceContext(&symbol.owner())};
         outerDevice && outerDevice->symbol()) {
       if (auto *msg{messages_.Say(symbol.name(),
               "'%s' may not be an internal procedure of CUDA device subprogram '%s'"_err_en_US,
               symbol.name(), outerDevice->symbol()->name())}) {
         msg->Attach(outerDevice->symbol()->name(),
             "Containing CUDA device subprogram"_en_US);
       }
     }
   }
 }
 
 void CheckHelper::CheckExternal(const Symbol &symbol) {
   if (IsExternal(symbol)) {
     std::string interfaceName{symbol.name().ToString()};
     if (const auto *bind{symbol.GetBindName()}) {
       interfaceName = *bind;
     }
-    if (const Symbol * global{FindGlobal(symbol)};
-        global && global != &symbol) {
+    if (const Symbol *global{FindGlobal(symbol)}; global && global != &symbol) {
       std::string definitionName{global->name().ToString()};
       if (const auto *bind{global->GetBindName()}) {
         definitionName = *bind;
       }
       if (interfaceName == definitionName) {
         parser::Message *msg{nullptr};
         if (!IsProcedure(*global)) {
           if (symbol.flags().test(Symbol::Flag::Function) ||
void CheckHelper::CheckBindC(const Symbol &symbol) {
   bool isExplicitBindC{symbol.attrs().test(Attr::BIND_C)};
   if (isExplicitBindC) {
     CheckConflicting(symbol, Attr::BIND_C, Attr::PARAMETER);
     CheckConflicting(symbol, Attr::BIND_C, Attr::ELEMENTAL);
   } else {
     // symbol must be interoperable (e.g., dummy argument of interoperable
     // procedure interface) but is not itself BIND(C).
   }
-  if (const std::string * bindName{symbol.GetBindName()};
+  if (const std::string *bindName{symbol.GetBindName()};
       bindName) { // has a binding name
     if (!bindName->empty()) {
       bool ok{bindName->front() == '_' || parser::IsLetter(bindName->front())};
       for (char ch : *bindName) {
         ok &= ch == '_' || parser::IsLetter(ch) || parser::IsDecimalDigit(ch);
       }
       if (!ok) {
         messages_.Say(symbol.name(),
void CheckHelper::CheckAlreadySeenDefinedIo(const DerivedTypeSpec &derivedType,
   // generics. It's okay to have two or more distinct defined I/O procedures for
   // the same type if they're coming from distinct non-type-bound interfaces.
   // (The non-type-bound interfaces would have been merged into a single generic
   //  -- with errors where indistinguishable --  when both were visible from the
   // same scope.)
   if (generic.owner().IsDerivedType()) {
     return;
   }
-  if (const Scope * dtScope{derivedType.scope()}) {
+  if (const Scope *dtScope{derivedType.scope()}) {
     if (auto iter{dtScope->find(generic.name())}; iter != dtScope->end()) {
       for (auto specRef : iter->second->get<GenericDetails>().specificProcs()) {
         const Symbol &specific{specRef->get<ProcBindingDetails>().symbol()};
         if (specific == proc) { // unambiguous, accept
           continue;
         }
         if (const auto *specDT{GetDtvArgDerivedType(specific)};
             specDT && evaluate::AreSameDerivedType(derivedType, *specDT)) {

 void CheckHelper::CheckModuleProcedureDef(const Symbol &symbol) {
   auto procClass{ClassifyProcedure(symbol)};
   if (const auto *subprogram{symbol.detailsIf<SubprogramDetails>()};
       subprogram &&
       (procClass == ProcedureDefinitionClass::Module &&
           symbol.attrs().test(Attr::MODULE)) &&
       !subprogram->bindName() && !subprogram->isInterface()) {
     const Symbol *module{nullptr};
-    if (const Scope * moduleScope{FindModuleContaining(symbol.owner())};
+    if (const Scope *moduleScope{FindModuleContaining(symbol.owner())};
         moduleScope && moduleScope->symbol()) {
       if (const auto *details{
               moduleScope->symbol()->detailsIf<ModuleDetails>()}) {
         if (details->parent()) {
           moduleScope = details->parent();
         }
         module = moduleScope->symbol();
       }

flang/lib/Semantics/check-do-forall.cpp

static void SayWithDo(SemanticsContext &context, parser::CharBlock stmtLocation,
   context.Say(stmtLocation, message).Attach(doLocation, GetEnclosingDoMsg());
 }
 
 // 11.1.7.5 - enforce semantics constraints on a DO CONCURRENT loop body
 class DoConcurrentBodyEnforce {
 public:
   DoConcurrentBodyEnforce(
       SemanticsContext &context, parser::CharBlock doConcurrentSourcePosition)
-      : context_{context}, doConcurrentSourcePosition_{
-                               doConcurrentSourcePosition} {}
+      : context_{context},
+        doConcurrentSourcePosition_{doConcurrentSourcePosition} {}
   std::set<parser::Label> labels() { return labels_; }
   template <typename T> bool Pre(const T &x) {
     if (const auto *expr{GetExpr(context_, x)}) {
       if (auto bad{FindImpureCall(context_.foldingContext(), *expr)}) {
         context_.Say(currentStatementSourcePosition_,
             "Impure procedure '%s' may not be referenced in DO CONCURRENT"_err_en_US,
             *bad);
       }
static bool MightDeallocatePolymorphic(const Symbol &original,
       const std::function<bool(const Symbol &)> &WillDeallocate) {
     const Symbol &symbol{ResolveAssociations(original)};
     // Check the entity itself, no coarray exception here
     if (IsPolymorphicAllocatable(symbol)) {
       return true;
     }
     // Check the components
     if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
-      if (const DeclTypeSpec * entityType{details->type()}) {
-        if (const DerivedTypeSpec * derivedType{entityType->AsDerived()}) {
+      if (const DeclTypeSpec *entityType{details->type()}) {
+        if (const DerivedTypeSpec *derivedType{entityType->AsDerived()}) {
           UltimateComponentIterator ultimates{*derivedType};
           for (const auto &ultimate : ultimates) {
             if (WillDeallocatePolymorphic(ultimate, WillDeallocate)) {
               return true;
             }
           }
         }
       }
void Post(const parser::BlockConstruct &blockConstruct) {
     if (DoesScopeContain(&doScope, blockScope)) {
       const char *reason{"block exit"};
       for (auto &pair : blockScope) {
         const Symbol &entity{*pair.second};
         if (IsAllocatable(entity) && !IsSaved(entity) &&
             MightDeallocatePolymorphic(entity, DeallocateAll)) {
           SayDeallocateOfPolymorph(endBlockStmt.source, entity, reason);
         }
-        if (const Symbol * impure{HasImpureFinal(entity)}) {
+        if (const Symbol *impure{HasImpureFinal(entity)}) {
           SayDeallocateWithImpureFinal(entity, reason, *impure);
         }
       }
     }
   }
 
   // Deallocation caused by assignment
   // Note that this case does not cause deallocation of coarray components
   void Post(const parser::AssignmentStmt &stmt) {
     const auto &variable{std::get<parser::Variable>(stmt.t)};
-    if (const Symbol * entity{GetLastName(variable).symbol}) {
+    if (const Symbol *entity{GetLastName(variable).symbol}) {
       const char *reason{"assignment"};
       if (MightDeallocatePolymorphic(*entity, DeallocateNonCoarray)) {
         SayDeallocateOfPolymorph(variable.GetSource(), *entity, reason);
       }
-      if (const Symbol * impure{HasImpureFinal(*entity)}) {
+      if (const Symbol *impure{HasImpureFinal(*entity)}) {
         SayDeallocateWithImpureFinal(*entity, reason, *impure);
       }
     }
     if (const auto *assignment{GetAssignment(stmt)}) {
       if (const auto *call{
               std::get_if<evaluate::ProcedureRef>(&assignment->u)}) {
         if (auto bad{FindImpureCall(context_.foldingContext(), *call)}) {
           context_.Say(currentStatementSourcePosition_,
for (const auto &allocateObject : allocateObjectList) {
       if (name.symbol) {
         const Symbol &entity{*name.symbol};
         const DeclTypeSpec *entityType{entity.GetType()};
         if ((entityType && entityType->IsPolymorphic()) || // POINTER case
             MightDeallocatePolymorphic(entity, DeallocateAll)) {
           SayDeallocateOfPolymorph(
               currentStatementSourcePosition_, entity, reason);
         }
-        if (const Symbol * impure{HasImpureFinal(entity)}) {
+        if (const Symbol *impure{HasImpureFinal(entity)}) {
           SayDeallocateWithImpureFinal(entity, reason, *impure);
         }
       }
     }
   }
 
   // C1137 -- No image control statements in a DO CONCURRENT
   void Post(const parser::ExecutableConstruct &construct) {
DoConcurrentVariableEnforce(
         doConcurrentSourcePosition_{doConcurrentSourcePosition},
         blockScope_{context.FindScope(doConcurrentSourcePosition_)} {}
 
   template <typename T> bool Pre(const T &) { return true; }
   template <typename T> void Post(const T &) {}
 
   // Check to see if the name is a variable from an enclosing scope
   void Post(const parser::Name &name) {
-    if (const Symbol * symbol{name.symbol}) {
+    if (const Symbol *symbol{name.symbol}) {
       if (IsVariableName(*symbol)) {
         const Scope &variableScope{symbol->owner()};
         if (DoesScopeContain(&variableScope, blockScope_)) {
           context_.SayWithDecl(*symbol, name.source,
               "Variable '%s' from an enclosing scope referenced in DO "
               "CONCURRENT with DEFAULT(NONE) must appear in a "
               "locality-spec"_err_en_US,
               symbol->name());
public:
   void Check(const parser::ForallStmt &stmt) {
     CheckConcurrentHeader(GetConcurrentHeader(stmt));
   }
   void Check(const parser::ForallConstruct &construct) {
     CheckConcurrentHeader(GetConcurrentHeader(construct));
   }
 
   void Check(const parser::ForallAssignmentStmt &stmt) {
-    if (const evaluate::Assignment *
-        assignment{common::visit(
+    if (const evaluate::Assignment *assignment{common::visit(
             common::visitors{[&](const auto &x) { return GetAssignment(x); }},
             stmt.u)}) {
       CheckForallIndexesUsed(*assignment);
       CheckForImpureCall(assignment->lhs);
       CheckForImpureCall(assignment->rhs);
       if (const auto *proc{
               std::get_if<evaluate::ProcedureRef>(&assignment->u)}) {
         CheckForImpureCall(*proc);
if (isReal) {
       }
     } else {
       SayBadDoControl(sourceLocation);
     }
   }
 
   void CheckDoVariable(const parser::ScalarName &scalarName) {
     const parser::CharBlock &sourceLocation{scalarName.thing.source};
-    if (const Symbol * symbol{scalarName.thing.symbol}) {
+    if (const Symbol *symbol{scalarName.thing.symbol}) {
       if (!IsVariableName(*symbol)) {
         context_.Say(
             sourceLocation, "DO control must be an INTEGER variable"_err_en_US);
       } else if (auto why{WhyNotDefinable(sourceLocation,
                      context_.FindScope(sourceLocation), DefinabilityFlags{},
                      *symbol)}) {
         context_
             .Say(sourceLocation,
if (const Symbol *symbol{scalarName.thing.symbol}) {
           }
         }
       } // No messages for INTEGER
     }
   }
 
   // Semantic checks for the limit and step expressions
   void CheckDoExpression(const parser::ScalarExpr &scalarExpression) {
-    if (const SomeExpr * expr{GetExpr(context_, scalarExpression)}) {
+    if (const SomeExpr *expr{GetExpr(context_, scalarExpression)}) {
       if (!ExprHasTypeCategory(*expr, TypeCategory::Integer)) {
         // No warnings or errors for type INTEGER
         const parser::CharBlock &loc{scalarExpression.thing.value().source};
         CheckDoControl(loc, ExprHasTypeCategory(*expr, TypeCategory::Real));
       }
     }
   }
 
UnorderedSymbolSet GatherLocals(
     const Scope &parentScope{
         context_.FindScope(currentStatementSourcePosition_).parent()};
     // Loop through the LocalitySpec::Local locality-specs
     for (const auto &ls : localitySpecs) {
       if (const auto *names{std::get_if<parser::LocalitySpec::Local>(&ls.u)}) {
         // Loop through the names in the Local locality-spec getting their
         // symbols
         for (const parser::Name &name : names->v) {
-          if (const Symbol * symbol{parentScope.FindSymbol(name.source)}) {
+          if (const Symbol *symbol{parentScope.FindSymbol(name.source)}) {
             symbols.insert(ResolveAssociations(*symbol));
           }
         }
       }
     }
     return symbols;
   }
 
void DoForallChecker::Leave(const parser::AssignmentStmt &stmt) {
   const auto &variable{std::get<parser::Variable>(stmt.t)};
   context_.CheckIndexVarRedefine(variable);
 }
 
 static void CheckIfArgIsDoVar(const evaluate::ActualArgument &arg,
     const parser::CharBlock location, SemanticsContext &context) {
   common::Intent intent{arg.dummyIntent()};
   if (intent == common::Intent::Out || intent == common::Intent::InOut) {
-    if (const SomeExpr * argExpr{arg.UnwrapExpr()}) {
-      if (const Symbol * var{evaluate::UnwrapWholeSymbolDataRef(*argExpr)}) {
+    if (const SomeExpr *argExpr{arg.UnwrapExpr()}) {
+      if (const Symbol *var{evaluate::UnwrapWholeSymbolDataRef(*argExpr)}) {
         if (intent == common::Intent::Out) {
           context.CheckIndexVarRedefine(location, *var);
         } else {
           context.WarnIndexVarRedefine(location, *var); // INTENT(INOUT)
         }
       }
     }
   }

 
 template ActualArgumentSet CollectActualArguments(const SomeExpr &);
 
 void DoForallChecker::Enter(const parser::Expr &parsedExpr) { ++exprDepth_; }
 
 void DoForallChecker::Leave(const parser::Expr &parsedExpr) {
   CHECK(exprDepth_ > 0);
   if (--exprDepth_ == 0) { // Only check top level expressions
-    if (const SomeExpr * expr{GetExpr(context_, parsedExpr)}) {
+    if (const SomeExpr *expr{GetExpr(context_, parsedExpr)}) {
       ActualArgumentSet argSet{CollectActualArguments(*expr)};
       for (const evaluate::ActualArgumentRef &argRef : argSet) {
         CheckIfArgIsDoVar(*argRef, parsedExpr.source, context_);
       }
     }
   }
 }
 

flang/lib/Semantics/check-io.h

private:
   // Presence flag values.
   ENUM_CLASS(Flag, IoControlList, InternalUnit, NumberUnit, StarUnit, CharFmt,
       LabelFmt, StarFmt, AssignFmt, FmtOrNml, KnownAccess, AccessDirect,
       AccessStream, AdvanceYes, AsynchronousYes, KnownStatus, StatusNew,
       StatusReplace, StatusScratch, DataList)
 
   template <typename R, typename T> std::optional<R> GetConstExpr(const T &x) {
     using DefaultCharConstantType = evaluate::Ascii;
-    if (const SomeExpr * expr{GetExpr(context_, x)}) {
+    if (const SomeExpr *expr{GetExpr(context_, x)}) {
       const auto foldExpr{
           evaluate::Fold(context_.foldingContext(), common::Clone(*expr))};
       if constexpr (std::is_same_v<R, std::string>) {
         return evaluate::GetScalarConstantValue<DefaultCharConstantType>(
             foldExpr);
       } else {
         static_assert(std::is_same_v<R, std::int64_t>, "unexpected type");
         return evaluate::ToInt64(foldExpr);

flang/lib/Semantics/check-io.cpp

 }
 
 void IoChecker::Enter(const parser::IoControlSpec::Size &var) {
   CheckForDefinableVariable(var, "SIZE");
   SetSpecifier(IoSpecKind::Size);
 }
 
 void IoChecker::Enter(const parser::IoUnit &spec) {
-  if (const parser::Variable * var{std::get_if<parser::Variable>(&spec.u)}) {
+  if (const parser::Variable *var{std::get_if<parser::Variable>(&spec.u)}) {
     // Only now after generic resolution can it be known whether a function
     // call appearing as UNIT=f() is an integer scalar external unit number
     // or a character pointer for internal I/O.
     const auto *expr{GetExpr(context_, *var)};
     std::optional<evaluate::DynamicType> dyType;
     if (expr) {
       dyType = expr->GetType();
     }

 void IoChecker::Leave(const parser::PrintStmt &) {
   CheckForPureSubprogram();
   Done();
 }
 
 static const parser::Name *FindNamelist(
     const std::list<parser::IoControlSpec> &controls) {
   for (const auto &control : controls) {
-    if (const parser::Name * namelist{std::get_if<parser::Name>(&control.u)}) {
+    if (const parser::Name *namelist{std::get_if<parser::Name>(&control.u)}) {
       if (namelist->symbol &&
           namelist->symbol->GetUltimate().has<NamelistDetails>()) {
         return namelist;
       }
     }
   }
   return nullptr;
 }
 
 static void CheckForDoVariable(
     const parser::ReadStmt &readStmt, SemanticsContext &context) {
   const std::list<parser::InputItem> &items{readStmt.items};
   for (const auto &item : items) {
-    if (const parser::Variable *
-        variable{std::get_if<parser::Variable>(&item.u)}) {
+    if (const parser::Variable *variable{
+            std::get_if<parser::Variable>(&item.u)}) {
       context.CheckIndexVarRedefine(*variable);
     }
   }
 }
 
 void IoChecker::Leave(const parser::ReadStmt &readStmt) {
   if (!flags_.test(Flag::InternalUnit)) {
     CheckForPureSubprogram();
   }
-  if (const parser::Name * namelist{FindNamelist(readStmt.controls)}) {
+  if (const parser::Name *namelist{FindNamelist(readStmt.controls)}) {
     if (namelist->symbol) {
       CheckNamelist(*namelist->symbol, common::DefinedIo::ReadFormatted,
           namelist->source);
     }
   }
   CheckForDoVariable(readStmt, context_);
   if (!flags_.test(Flag::IoControlList)) {
     Done();
void IoChecker::Leave(const parser::WaitStmt &) {
   CheckForPureSubprogram();
   Done();
 }
 
 void IoChecker::Leave(const parser::WriteStmt &writeStmt) {
   if (!flags_.test(Flag::InternalUnit)) {
     CheckForPureSubprogram();
   }
-  if (const parser::Name * namelist{FindNamelist(writeStmt.controls)}) {
+  if (const parser::Name *namelist{FindNamelist(writeStmt.controls)}) {
     if (namelist->symbol) {
       CheckNamelist(*namelist->symbol, common::DefinedIo::WriteFormatted,
           namelist->source);
     }
   }
   LeaveReadWrite();
   CheckForProhibitedSpecifier(IoSpecKind::Blank); // C1213
   CheckForProhibitedSpecifier(IoSpecKind::End); // C1213
if (auto expr{AnalyzeExpr(context_, *var)}) {
             .Attach(std::move(*whyNot));
       }
     }
   }
 }
 
 void IoChecker::CheckForPureSubprogram() const { // C1597
   CHECK(context_.location());
-  if (const Scope *
-      scope{context_.globalScope().FindScope(*context_.location())}) {
+  if (const Scope *scope{
+          context_.globalScope().FindScope(*context_.location())}) {
     if (FindPureProcedureContaining(*scope)) {
       context_.Say(
           "External I/O is not allowed in a pure subprogram"_err_en_US);
     }
   }
 }
 
 // Seeks out an allocatable or pointer ultimate component that is not
 // nested in a nonallocatable/nonpointer component with a specific
 // defined I/O procedure.
 static const Symbol *FindUnsafeIoDirectComponent(common::DefinedIo which,
     const DerivedTypeSpec &derived, const Scope &scope) {
   if (HasDefinedIo(which, derived, &scope)) {
     return nullptr;
   }
-  if (const Scope * dtScope{derived.scope()}) {
+  if (const Scope *dtScope{derived.scope()}) {
     for (const auto &pair : *dtScope) {
       const Symbol &symbol{*pair.second};
       if (IsAllocatableOrPointer(symbol)) {
         return &symbol;
       }
       if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
-        if (const DeclTypeSpec * type{details->type()}) {
+        if (const DeclTypeSpec *type{details->type()}) {
           if (type->category() == DeclTypeSpec::Category::TypeDerived) {
             const DerivedTypeSpec &componentDerived{type->derivedTypeSpec()};
-            if (const Symbol *
-                bad{FindUnsafeIoDirectComponent(
+            if (const Symbol *bad{FindUnsafeIoDirectComponent(
                     which, componentDerived, scope)}) {
               return bad;
             }
           }
         }
       }
     }
   }
   return nullptr;
 }
 
 // For a type that does not have a defined I/O subroutine, finds a direct
 // component that is a witness to an accessibility violation outside the module
 // in which the type was defined.
 static const Symbol *FindInaccessibleComponent(common::DefinedIo which,
     const DerivedTypeSpec &derived, const Scope &scope) {
-  if (const Scope * dtScope{derived.scope()}) {
-    if (const Scope * module{FindModuleContaining(*dtScope)}) {
+  if (const Scope *dtScope{derived.scope()}) {
+    if (const Scope *module{FindModuleContaining(*dtScope)}) {
       for (const auto &pair : *dtScope) {
         const Symbol &symbol{*pair.second};
         if (IsAllocatableOrPointer(symbol)) {
           continue; // already an error
         }
         if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
           const DerivedTypeSpec *componentDerived{nullptr};
-          if (const DeclTypeSpec * type{details->type()}) {
+          if (const DeclTypeSpec *type{details->type()}) {
             if (type->category() == DeclTypeSpec::Category::TypeDerived) {
               componentDerived = &type->derivedTypeSpec();
             }
           }
           if (componentDerived &&
               HasDefinedIo(which, *componentDerived, &scope)) {
             continue; // this component and its descendents are fine
           }
           if (symbol.attrs().test(Attr::PRIVATE) &&
               !symbol.test(Symbol::Flag::ParentComp)) {
             if (!DoesScopeContain(module, scope)) {
               return &symbol;
             }
           }
           if (componentDerived) {
-            if (const Symbol *
-                bad{FindInaccessibleComponent(
+            if (const Symbol *bad{FindInaccessibleComponent(
                     which, *componentDerived, scope)}) {
               return bad;
             }
           }
         }
       }
     }
   }
   return nullptr;
 }
 
 // Fortran 2018, 12.6.3 paragraphs 5 & 7
 parser::Message *IoChecker::CheckForBadIoType(const evaluate::DynamicType &type,
     common::DefinedIo which, parser::CharBlock where) const {
   if (type.IsUnlimitedPolymorphic()) {
     return &context_.Say(
         where, "I/O list item may not be unlimited polymorphic"_err_en_US);
   } else if (type.category() == TypeCategory::Derived) {
     const auto &derived{type.GetDerivedTypeSpec()};
     const Scope &scope{context_.FindScope(where)};
-    if (const Symbol *
-        bad{FindUnsafeIoDirectComponent(which, derived, scope)}) {
+    if (const Symbol *bad{FindUnsafeIoDirectComponent(which, derived, scope)}) {
       return &context_.SayWithDecl(*bad, where,
           "Derived type '%s' in I/O cannot have an allocatable or pointer direct component '%s' unless using defined I/O"_err_en_US,
           derived.name(), bad->name());
     }
     if (!HasDefinedIo(which, derived, &scope)) {
       if (type.IsPolymorphic()) {
         return &context_.Say(where,
             "Derived type '%s' in I/O may not be polymorphic unless using defined I/O"_err_en_US,
             derived.name());
       }
-      if (const Symbol *
-          bad{FindInaccessibleComponent(which, derived, scope)}) {
+      if (const Symbol *bad{FindInaccessibleComponent(which, derived, scope)}) {
         return &context_.Say(where,
             "I/O of the derived type '%s' may not be performed without defined I/O in a scope in which a direct component like '%s' is inaccessible"_err_en_US,
             derived.name(), bad->name());
       }
     }
   }
   return nullptr;
 }

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

for (const auto &clause : clauseList->v) {
                         const Fortran::parser::OmpAtomicClauseList>) {
         ompClause = std::get_if<Fortran::parser::OmpClause>(&clause.u);
         if (!ompClause)
           continue;
       } else if constexpr (std::is_same_v<D,
                                const Fortran::parser::OmpClauseList>) {
         ompClause = &clause;
       }
-      if (const Fortran::parser::OmpClause::Hint *
-          hintClause{
+      if (const Fortran::parser::OmpClause::Hint *hintClause{
               std::get_if<Fortran::parser::OmpClause::Hint>(&ompClause->u)}) {
         std::optional<std::int64_t> hintValue = GetIntValue(hintClause->v);
         if (hintValue && *hintValue >= 0) {
           /*`omp_sync_hint_nonspeculative` and `omp_lock_hint_speculative`*/
           if ((*hintValue & 0xC) == 0xC
               /*`omp_sync_hint_uncontended` and omp_sync_hint_contended*/
               || (*hintValue & 0x3) == 0x3)
             context_.Say(clause.source,
void OmpStructureChecker::Enter(const parser::OmpClause::Firstprivate &x) {
 
   CheckPrivateSymbolsInOuterCxt(
       currSymbols, dirClauseTriple, llvm::omp::Clause::OMPC_firstprivate);
 }
 
 void OmpStructureChecker::CheckIsLoopIvPartOfClause(
     llvmOmpClause clause, const parser::OmpObjectList &ompObjectList) {
   for (const auto &ompObject : ompObjectList.v) {
-    if (const parser::Name * name{parser::Unwrap<parser::Name>(ompObject)}) {
+    if (const parser::Name *name{parser::Unwrap<parser::Name>(ompObject)}) {
       if (name->symbol == GetContext().loopIV) {
         context_.Say(name->source,
             "DO iteration variable %s is not allowed in %s clause."_err_en_US,
             name->ToString(),
             parser::ToUpperCaseLetters(getClauseName(clause).str()));
       }
     }
   }

flang/lib/Semantics/check-select-rank.cpp

const auto &selectRankStmt{
       std::get<parser::Statement<parser::SelectRankStmt>>(
           selectRankConstruct.t)};
   const auto &selectRankStmtSel{
       std::get<parser::Selector>(selectRankStmt.statement.t)};
 
   // R1149 select-rank-stmt checks
   const Symbol *saveSelSymbol{nullptr};
   if (const auto selExpr{GetExprFromSelector(selectRankStmtSel)}) {
-    if (const Symbol * sel{evaluate::UnwrapWholeSymbolDataRef(*selExpr)}) {
+    if (const Symbol *sel{evaluate::UnwrapWholeSymbolDataRef(*selExpr)}) {
       if (!evaluate::IsAssumedRank(*sel)) { // C1150
         context_.Say(parser::FindSourceLocation(selectRankStmtSel),
             "Selector '%s' is not an assumed-rank array variable"_err_en_US,
             sel->name().ToString());
       } else {
         saveSelSymbol = sel;
       }
     } else {

flang/lib/Semantics/check-select-type.cpp

bool PassesDerivedTypeChecks(const semantics::DerivedTypeSpec &derived,
     }
     if (!IsExtensibleType(&derived)) { // C1161
       context_.Say(sourceLoc,
           "The type specification statement must not specify "
           "a type with a SEQUENCE attribute or a BIND attribute"_err_en_US);
       return false;
     }
     if (!selectorType_.IsUnlimitedPolymorphic()) { // C1162
-      if (const semantics::Scope * guardScope{derived.typeSymbol().scope()}) {
+      if (const semantics::Scope *guardScope{derived.typeSymbol().scope()}) {
         if (const auto *selDerivedTypeSpec{
                 evaluate::GetDerivedTypeSpec(selectorType_)}) {
           if (!derived.Match(*selDerivedTypeSpec) &&
               !guardScope->FindComponent(selDerivedTypeSpec->name())) {
             context_.Say(sourceLoc,
                 "Type specification '%s' must be an extension"
                 " of TYPE '%s'"_err_en_US,
                 derived.AsFortran(), selDerivedTypeSpec->AsFortran());

flang/lib/Semantics/compute-offsets.cpp

for (std::size_t i{object.subscripts.size() - 1};;) {
       }
       --i;
       offset *= ubound(i) - lbound(i) + 1;
     }
   }
   auto result{offset * GetSizeAndAlignment(object.symbol, false).size};
   if (object.substringStart) {
     int kind{context_.defaultKinds().GetDefaultKind(TypeCategory::Character)};
-    if (const DeclTypeSpec * type{object.symbol.GetType()}) {
-      if (const IntrinsicTypeSpec * intrinsic{type->AsIntrinsic()}) {
+    if (const DeclTypeSpec *type{object.symbol.GetType()}) {
+      if (const IntrinsicTypeSpec *intrinsic{type->AsIntrinsic()}) {
         kind = ToInt64(intrinsic->kind()).value_or(kind);
       }
     }
     result += kind * (*object.substringStart - 1);
   }
   return result;
 }
 

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

 
 // Looks for default derived type component initialization -- but
 // *not* allocatables.
 static const DerivedTypeSpec *HasDefaultInitialization(const Symbol &symbol) {
   if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
     if (object->init().has_value()) {
       return nullptr; // init is explicit, not default
     } else if (!object->isDummy() && object->type()) {
-      if (const DerivedTypeSpec * derived{object->type()->AsDerived()}) {
+      if (const DerivedTypeSpec *derived{object->type()->AsDerived()}) {
         DirectComponentIterator directs{*derived};
         if (std::find_if(
                 directs.begin(), directs.end(), [](const Symbol &component) {
                   return !IsAllocatable(component) &&
                       HasDeclarationInitializer(component);
                 })) {
           return derived;
         }
if (const auto *object{component.detailsIf<ObjectEntityDetails>()}) {
                 }
               }
             }
             if (initialized) {
               init.image.Add(componentOffset, component.size(), *object->init(),
                   foldingContext);
             }
           }
-        } else if (const DeclTypeSpec * type{component.GetType()}) {
-          if (const DerivedTypeSpec * componentDerived{type->AsDerived()}) {
+        } else if (const DeclTypeSpec *type{component.GetType()}) {
+          if (const DerivedTypeSpec *componentDerived{type->AsDerived()}) {
             PopulateWithComponentDefaults(init, componentOffset,
                 *componentDerived, foldingContext, component);
           }
         }
         if (initialized) {
           init.initializedRanges.emplace_back(
               componentOffset, component.size());
         }
for (const std::list<SymbolRef> &association : associations) {
     }
   }
   for (const auto &pair : scope) {
     const Symbol &symbol{*pair.second};
     if (!symbol.test(Symbol::Flag::InDataStmt) &&
         !HasDeclarationInitializer(symbol) && IsSaved(symbol) &&
         equivalenced.find(symbol) == equivalenced.end()) {
       // Static object, no local storage association, no explicit initialization
-      if (const DerivedTypeSpec * derived{HasDefaultInitialization(symbol)}) {
+      if (const DerivedTypeSpec *derived{HasDefaultInitialization(symbol)}) {
         auto newInitIter{inits.emplace(&symbol, symbol.size())};
         CHECK(newInitIter.second);
         auto &newInit{newInitIter.first->second};
         PopulateWithComponentDefaults(
             newInit, 0, *derived, foldingContext, symbol);
       }
     }
   }

flang/lib/Semantics/definable.cpp

static const Symbol &GetRelevantSymbol(const evaluate::DataRef &dataRef,
   if (isPointerDefinition) {
     if (const auto *component{std::get_if<evaluate::Component>(&dataRef.u)}) {
       if (IsPointer(component->GetLastSymbol()) ||
           (acceptAllocatable && IsAllocatable(component->GetLastSymbol()))) {
         return GetRelevantSymbol(component->base(), false, false);
       }
     }
   }
-  if (const Symbol * lastPointer{GetLastPointerSymbol(dataRef)}) {
+  if (const Symbol *lastPointer{GetLastPointerSymbol(dataRef)}) {
     return *lastPointer;
   } else {
     return dataRef.GetFirstSymbol();
   }
 }
 
 // Check the leftmost (or only) symbol from a data-ref or expression.
 static std::optional<parser::Message> WhyNotDefinableBase(parser::CharBlock at,
static std::optional<parser::Message> WhyNotDefinableBase(parser::CharBlock at,
   } else if (!isPointerDefinition && !IsVariableName(ultimate)) {
     return BlameSymbol(at, "'%s' is not a variable"_en_US, original);
   } else if (IsProtected(ultimate) && IsUseAssociated(original, scope)) {
     return BlameSymbol(at, "'%s' is protected in this scope"_en_US, original);
   } else if (IsIntentIn(ultimate)) {
     return BlameSymbol(
         at, "'%s' is an INTENT(IN) dummy argument"_en_US, original);
   }
-  if (const Scope * pure{FindPureProcedureContaining(scope)}) {
+  if (const Scope *pure{FindPureProcedureContaining(scope)}) {
     // Additional checking for pure subprograms.
     if (!isTargetDefinition) {
       if (auto msg{CheckDefinabilityInPureScope(
               at, original, ultimate, scope, *pure)}) {
         return msg;
       }
     }
-    if (const Symbol *
-        visible{FindExternallyVisibleObject(
+    if (const Symbol *visible{FindExternallyVisibleObject(
             ultimate, *pure, isPointerDefinition)}) {
       return BlameSymbol(at,
           "'%s' is externally visible via '%s' and not definable in a pure subprogram"_en_US,
           original, visible->name());
     }
   }
-  if (const Scope * deviceContext{FindCUDADeviceContext(&scope)}) {
+  if (const Scope *deviceContext{FindCUDADeviceContext(&scope)}) {
     bool isOwnedByDeviceCode{deviceContext->Contains(ultimate.owner())};
     if (isPointerDefinition && !acceptAllocatable) {
       return BlameSymbol(at,
           "'%s' is a pointer and may not be associated in a device subprogram"_err_en_US,
           original);
     } else if (auto cudaDataAttr{GetCUDADataAttr(&ultimate)}) {
       if (*cudaDataAttr == common::CUDADataAttr::Constant) {
         return BlameSymbol(at,
if (FindPureProcedureContaining(scope)) {
     if (auto dyType{evaluate::DynamicType::From(ultimate)}) {
       if (!flags.test(DefinabilityFlag::PolymorphicOkInPure)) {
         if (dyType->IsPolymorphic()) { // C1596
           return BlameSymbol(at,
               "'%s' is polymorphic in a pure subprogram"_because_en_US,
               original);
         }
       }
-      if (const Symbol * impure{HasImpureFinal(ultimate)}) {
+      if (const Symbol *impure{HasImpureFinal(ultimate)}) {
         return BlameSymbol(at,
             "'%s' has an impure FINAL procedure '%s'"_because_en_US, original,
             impure->name());
       }
-      if (const DerivedTypeSpec * derived{GetDerivedTypeSpec(dyType)}) {
+      if (const DerivedTypeSpec *derived{GetDerivedTypeSpec(dyType)}) {
         if (!flags.test(DefinabilityFlag::PolymorphicOkInPure)) {
           if (auto bad{FindPolymorphicAllocatableUltimateComponent(*derived)}) {
             return BlameSymbol(at,
                 "'%s' has polymorphic component '%s' in a pure subprogram"_because_en_US,
                 original, bad.BuildResultDesignatorName());
           }
         }
       }
if (evaluate::HasVectorSubscript(expr)) {
             while (spec) {
               bool anyElemental{false};
               const Symbol *anyRankMatch{nullptr};
               for (auto ref : FinalsForDerivedTypeInstantiation(*spec)) {
                 const Symbol &ultimate{ref->GetUltimate()};
                 anyElemental |= ultimate.attrs().test(Attr::ELEMENTAL);
                 if (const auto *subp{ultimate.detailsIf<SubprogramDetails>()}) {
                   if (!subp->dummyArgs().empty()) {
-                    if (const Symbol * arg{subp->dummyArgs()[0]}) {
+                    if (const Symbol *arg{subp->dummyArgs()[0]}) {
                       const auto *object{arg->detailsIf<ObjectEntityDetails>()};
                       if (arg->Rank() == rank ||
                           (object && object->IsAssumedRank())) {
                         anyRankMatch = &*ref;
                       }
                     }
                   }
                 }
if (auto dataRef{evaluate::ExtractDataRef(expr, true, true)}) {
     return WhyNotDefinable(at, scope, flags, *dataRef);
   } else if (evaluate::IsNullPointer(expr)) {
     return parser::Message{
         at, "'%s' is a null pointer"_because_en_US, expr.AsFortran()};
   } else if (flags.test(DefinabilityFlag::PointerDefinition)) {
     if (const auto *procDesignator{
             std::get_if<evaluate::ProcedureDesignator>(&expr.u)}) {
       // Defining a procedure pointer
-      if (const Symbol * procSym{procDesignator->GetSymbol()}) {
+      if (const Symbol *procSym{procDesignator->GetSymbol()}) {
         if (evaluate::ExtractCoarrayRef(expr)) { // C1027
           return BlameSymbol(at,
               "Procedure pointer '%s' may not be a coindexed object"_because_en_US,
               *procSym, expr.AsFortran());
         }
         if (const auto *component{procDesignator->GetComponent()}) {
           return WhyNotDefinable(at, scope, flags, *component);
         } else {

flang/lib/Semantics/expression.cpp

void ExpressionAnalyzer::CheckConstantSubscripts(ArrayRef &ref) {
   const Symbol &arraySymbol{ref.base().GetLastSymbol()};
   Shape lb{GetLBOUNDs(foldingContext_, NamedEntity{arraySymbol})};
   CHECK(lb.size() >= ref.subscript().size());
   Shape ub{GetUBOUNDs(foldingContext_, NamedEntity{arraySymbol})};
   CHECK(ub.size() >= ref.subscript().size());
   bool anyPossiblyEmptyDim{false};
   int dim{0};
   for (Subscript &ss : ref.subscript()) {
-    if (Triplet * triplet{std::get_if<Triplet>(&ss.u)}) {
+    if (Triplet *triplet{std::get_if<Triplet>(&ss.u)}) {
       auto expr{Fold(triplet->stride())};
       auto stride{ToInt64(expr)};
       triplet->set_stride(std::move(expr));
       std::optional<ConstantSubscript> lower, upper;
       if (auto expr{triplet->lower()}) {
         *expr = Fold(std::move(*expr));
         lower = ToInt64(*expr);
         triplet->set_lower(std::move(*expr));
if (symbol) {
           } else {
             AttachDeclaration(
                 Say(expr.source,
                     "A NULL pointer may not be used as the value for component '%s'"_err_en_US,
                     symbol->name()),
                 *symbol);
             continue;
           }
-        } else if (const Symbol * pointer{FindPointerComponent(*symbol)};
+        } else if (const Symbol *pointer{FindPointerComponent(*symbol)};
                    pointer && pureContext) { // C1594(4)
-          if (const Symbol *
-              visible{semantics::FindExternallyVisibleObject(
+          if (const Symbol *visible{semantics::FindExternallyVisibleObject(
                   *value, *pureContext)}) {
             Say(expr.source,
                 "The externally visible object '%s' may not be used in a pure procedure as the value for component '%s' which has the pointer component '%s'"_err_en_US,
                 visible->name(), symbol->name(), pointer->name());
           }
         }
         if (MaybeExpr converted{ConvertToType(*symbol, std::move(*value))}) {
           if (auto componentShape{GetShape(GetFoldingContext(), *symbol)}) {
if (const Symbol *sym{sc.component.symbol}) {
           // re-resolve the name to the specific binding
           CHECK(sym->has<semantics::ProcBindingDetails>());
           // Use the most recent override of a binding, respecting
           // the rule that inaccessible bindings may not be overridden
           // outside their module.  Fortran doesn't allow a PUBLIC
           // binding to be overridden by a PRIVATE one.
           CHECK(dyType && dyType->category() == TypeCategory::Derived &&
               !dyType->IsUnlimitedPolymorphic());
-          if (const Symbol *
-              latest{DEREF(dyType->GetDerivedTypeSpec().typeSymbol().scope())
-                         .FindComponent(sym->name())}) {
+          if (const Symbol *latest{
+                  DEREF(dyType->GetDerivedTypeSpec().typeSymbol().scope())
             if (sym->attrs().test(semantics::Attr::PRIVATE)) {
               const auto *bindingModule{FindModuleContaining(generic.owner())};
               const Symbol *s{latest};
               while (s && FindModuleContaining(s->owner()) != bindingModule) {
                 if (const auto *parent{s->owner().GetDerivedTypeParent()}) {
                   s = parent->FindComponent(sym->name());
                 } else {
                   s = nullptr;
void ExpressionAnalyzer::Analyze(const parser::CallStmt &callStmt) {
   auto chevrons{AnalyzeChevrons(callStmt)};
   if (!analyzer.fatalErrors() && chevrons) {
     if (std::optional<CalleeAndArguments> callee{
             GetCalleeAndArguments(std::get<parser::ProcedureDesignator>(call.t),
                 analyzer.GetActuals(), true /* subroutine */)}) {
       ProcedureDesignator *proc{std::get_if<ProcedureDesignator>(&callee->u)};
       CHECK(proc);
       bool isKernel{false};
-      if (const Symbol * procSym{proc->GetSymbol()}) {
+      if (const Symbol *procSym{proc->GetSymbol()}) {
         const Symbol &ultimate{procSym->GetUltimate()};
         if (const auto *subpDetails{
                 ultimate.detailsIf<semantics::SubprogramDetails>()}) {
           if (auto attrs{subpDetails->cudaSubprogramAttrs()}) {
             isKernel = *attrs == common::CUDASubprogramAttrs::Global ||
                 *attrs == common::CUDASubprogramAttrs::Grid_Global;
           }
         } else if (const auto *procDetails{
if (chars->functionResult &&
       Say(callSite,
           "Assumed-length character function must be defined with a length to be called"_err_en_US);
     }
     ok &= semantics::CheckArguments(*chars, arguments, context_,
         context_.FindScope(callSite), treatExternalAsImplicit,
         specificIntrinsic);
   }
   if (procSymbol && !IsPureProcedure(*procSymbol)) {
-    if (const semantics::Scope *
-        pure{semantics::FindPureProcedureContaining(
+    if (const semantics::Scope *pure{semantics::FindPureProcedureContaining(
             context_.FindScope(callSite))}) {
       Say(callSite,
           "Procedure '%s' referenced in pure subprogram '%s' must be pure too"_err_en_US,
           procSymbol->name(), DEREF(pure->symbol()).name());
     }
   }
   if (ok && !treatExternalAsImplicit && procSymbol &&
       !(chars && chars->HasExplicitInterface())) {
if (const Symbol *symbol{scope.FindSymbol(oprName)}) {
       proc =
           context_.ResolveGeneric(*symbol, actuals_, noAdjustment, true).first;
     }
     for (std::size_t i{0}; !proc && i < actuals_.size(); ++i) {
       const Symbol *generic{nullptr};
       if (const Symbol *binding{FindBoundOp(oprName, i, generic, true)}) {
         if (CheckAccessibleSymbol(scope, DEREF(generic))) {
           // ignore inaccessible type-bound ASSIGNMENT(=) generic
-        } else if (const Symbol *
-            resolution{GetBindingResolution(GetType(i), *binding)}) {
+        } else if (const Symbol *resolution{
+                       GetBindingResolution(GetType(i), *binding)}) {
           proc = resolution;
         } else {
           proc = binding;
           passedObjectIndex = i;
         }
       }
     }
   }

flang/lib/Semantics/mod-file.cpp

 void ModFileWriter::PutDerivedType(
     const Symbol &typeSymbol, const Scope *scope) {
   auto &details{typeSymbol.get<DerivedTypeDetails>()};
   if (details.isDECStructure()) {
     PutDECStructure(typeSymbol, scope);
     return;
   }
   PutAttrs(decls_ << "type", typeSymbol.attrs());
-  if (const DerivedTypeSpec * extends{typeSymbol.GetParentTypeSpec()}) {
+  if (const DerivedTypeSpec *extends{typeSymbol.GetParentTypeSpec()}) {
     decls_ << ",extends(" << extends->name() << ')';
   }
   decls_ << "::" << typeSymbol.name();
   if (!details.paramNames().empty()) {
     char sep{'('};
     for (const auto &name : details.paramNames()) {
       decls_ << sep << name;
       sep = ',';

 }
 
 // Attributes that may be in a subprogram prefix
 static const Attrs subprogramPrefixAttrs{Attr::ELEMENTAL, Attr::IMPURE,
     Attr::MODULE, Attr::NON_RECURSIVE, Attr::PURE, Attr::RECURSIVE};
 
 void ModFileWriter::PutSubprogram(const Symbol &symbol) {
   auto &details{symbol.get<SubprogramDetails>()};
-  if (const Symbol * interface{details.moduleInterface()}) {
+  if (const Symbol *interface{details.moduleInterface()}) {
     const Scope *module{FindModuleContaining(interface->owner())};
     if (module && module != &symbol.owner()) {
       // Interface is in ancestor module
     } else {
       PutSubprogram(*interface);
     }
   }
   auto attrs{symbol.attrs()};
if (const auto *useDetails{symbol.detailsIf<UseDetails>()}) {
       if (const auto *generic{ultimate.detailsIf<GenericDetails>()}) {
         // The generic may not be needed itself, but the specific procedure
         // &/or derived type that it shadows may be needed.
         const Symbol *spec{generic->specific()};
         const Symbol *dt{generic->derivedType()};
         needed = needed || (spec && useSet_.count(*spec) > 0) ||
             (dt && useSet_.count(*dt) > 0);
       } else if (const auto *subp{ultimate.detailsIf<SubprogramDetails>()}) {
-        const Symbol *interface { subp->moduleInterface() };
+        const Symbol *interface {
+          subp->moduleInterface()
+        };
         needed = needed || (interface && useSet_.count(*interface) > 0);
       }
       if (needed) {
         need_.push_back(symbol);
       }
     } else if (symbol.has<SubprogramDetails>()) {
       // An internal subprogram is needed if it is used as interface
       // for a dummy or return value procedure.
common::visit(common::visitors{
                       for (const ShapeSpec &spec : details.shape()) {
                         DoBound(spec.lbound());
                         DoBound(spec.ubound());
                       }
                       for (const ShapeSpec &spec : details.coshape()) {
                         DoBound(spec.lbound());
                         DoBound(spec.ubound());
                       }
-                      if (const Symbol * commonBlock{details.commonBlock()}) {
+                      if (const Symbol *commonBlock{details.commonBlock()}) {
                         DoSymbol(*commonBlock);
                       }
                     },
                     [this](const CommonBlockDetails &details) {
                       for (const auto &object : details.objects()) {
                         DoSymbol(*object);
                       }
                     },
void SubprogramSymbolCollector::DoType(const DeclTypeSpec *type) {
   switch (type->category()) {
   case DeclTypeSpec::Numeric:
   case DeclTypeSpec::Logical:
     break; // nothing to do
   case DeclTypeSpec::Character:
     DoParamValue(type->characterTypeSpec().length());
     break;
   default:
-    if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+    if (const DerivedTypeSpec *derived{type->AsDerived()}) {
       const auto &typeSymbol{derived->typeSymbol()};
-      if (const DerivedTypeSpec * extends{typeSymbol.GetParentTypeSpec()}) {
+      if (const DerivedTypeSpec *extends{typeSymbol.GetParentTypeSpec()}) {
         DoSymbol(extends->name(), extends->typeSymbol());
       }
       for (const auto &pair : derived->parameters()) {
         DoParamValue(pair.second);
       }
       for (const auto &pair : *typeSymbol.scope()) {
         const Symbol &comp{*pair.second};
         DoSymbol(comp);
       }
       DoSymbol(derived->name(), derived->typeSymbol());
     }
   }
 }
 
 void SubprogramSymbolCollector::DoBound(const Bound &bound) {
-  if (const MaybeSubscriptIntExpr & expr{bound.GetExplicit()}) {
+  if (const MaybeSubscriptIntExpr &expr{bound.GetExplicit()}) {
     DoExpr(*expr);
   }
 }
 void SubprogramSymbolCollector::DoParamValue(const ParamValue &paramValue) {
   if (const auto &expr{paramValue.GetExplicit()}) {
     DoExpr(*expr);
   }
 }

flang/lib/Semantics/pointer-assignment.cpp

 using evaluate::characteristics::TypeAndShape;
 using parser::MessageFixedText;
 using parser::MessageFormattedText;
 
 class PointerAssignmentChecker {
 public:
   PointerAssignmentChecker(SemanticsContext &context, const Scope &scope,
       parser::CharBlock source, const std::string &description)
-      : context_{context}, scope_{scope}, source_{source}, description_{
-                                                               description} {}
+      : context_{context}, scope_{scope}, source_{source},
+        description_{description} {}
   PointerAssignmentChecker(
       SemanticsContext &context, const Scope &scope, const Symbol &lhs)
       : context_{context}, scope_{scope}, source_{lhs.name()},
         description_{"pointer '"s + lhs.name().ToString() + '\''}, lhs_{&lhs} {
     set_lhsType(TypeAndShape::Characterize(lhs, foldingContext_));
     set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS));
     set_isVolatile(lhs.attrs().test(Attr::VOLATILE));
   }
bool PointerAssignmentChecker::Check(const SomeExpr &rhs) {
   if (IsNullPointer(rhs)) {
     return true;
   }
   if (lhs_ && IsProcedure(*lhs_)) {
     return true;
   }
   if (const auto *pureProc{FindPureProcedureContaining(scope_)}) {
     if (pointerComponentLHS_) { // C1594(4) is a hard error
-      if (const Symbol * object{FindExternallyVisibleObject(rhs, *pureProc)}) {
+      if (const Symbol *object{FindExternallyVisibleObject(rhs, *pureProc)}) {
         if (auto *msg{Say(
                 "Externally visible object '%s' may not be associated with pointer component '%s' in a pure procedure"_err_en_US,
                 object->name(), pointerComponentLHS_->name())}) {
           msg->Attach(object->name(), "Object declaration"_en_US)
               .Attach(
                   pointerComponentLHS_->name(), "Pointer declaration"_en_US);
         }
         return false;
       }
-    } else if (const Symbol * base{GetFirstSymbol(rhs)}) {
+    } else if (const Symbol *base{GetFirstSymbol(rhs)}) {
       if (const char *why{WhyBaseObjectIsSuspicious(
               base->GetUltimate(), scope_)}) { // C1594(3)
         evaluate::SayWithDeclaration(foldingContext_.messages(), *base,
             "A pure subprogram may not use '%s' as the target of pointer assignment because it is %s"_err_en_US,
             base->name(), why);
         return false;
       }
     }
if (std::optional<MessageFixedText> msg{evaluate::CheckProcCompatibility(
           isCall, procedure_, rhsProcedure, specific, whyNot)}) {
     Say(std::move(*msg), description_, rhsName, whyNot);
     return false;
   }
   return true;
 }
 
 bool PointerAssignmentChecker::Check(const evaluate::ProcedureDesignator &d) {
-  if (const Symbol * symbol{d.GetSymbol()}) {
+  if (const Symbol *symbol{d.GetSymbol()}) {
     if (const auto *subp{
             symbol->GetUltimate().detailsIf<SubprogramDetails>()}) {
       if (subp->stmtFunction()) {
         evaluate::SayWithDeclaration(foldingContext_.messages(), *symbol,
             "Statement function '%s' may not be the target of a pointer assignment"_err_en_US,
             symbol->name());
         return false;
       }

flang/lib/Semantics/resolve-directives.cpp

bool DirectiveAttributeVisitor<T>::HasDataSharingAttributeObject(
   return it != dataSharingAttributeObjects_.end();
 }
 
 template <typename T>
 const parser::Name *DirectiveAttributeVisitor<T>::GetLoopIndex(
     const parser::DoConstruct &x) {
   using Bounds = parser::LoopControl::Bounds;
   if (x.GetLoopControl()) {
-    if (const Bounds * b{std::get_if<Bounds>(&x.GetLoopControl()->u)}) {
+    if (const Bounds *b{std::get_if<Bounds>(&x.GetLoopControl()->u)}) {
       return &b->name.thing;
     } else {
       return nullptr;
     }
   } else {
     context_
         .Say(std::get<parser::Statement<parser::NonLabelDoStmt>>(x.t).source,
             "Loop control is not present in the DO LOOP"_err_en_US)

 
 // For OpenACC constructs, check all the data-refs within the constructs
 // and adjust the symbol for each Name if necessary
 void AccAttributeVisitor::Post(const parser::Name &name) {
   auto *symbol{name.symbol};
   if (symbol && !dirContext_.empty() && GetContext().withinConstruct) {
     if (!symbol->owner().IsDerivedType() && !symbol->has<ProcEntityDetails>() &&
         !IsObjectWithDSA(*symbol)) {
-      if (Symbol * found{currScope().FindSymbol(name.source)}) {
+      if (Symbol *found{currScope().FindSymbol(name.source)}) {
         if (symbol != found) {
           name.symbol = found; // adjust the symbol within region
         } else if (GetContext().defaultDSA == Symbol::Flag::AccNone) {
           // 2.5.14.
           context_.Say(name.source,
               "The DEFAULT(NONE) clause requires that '%s' must be listed in "
               "a data-mapping clause"_err_en_US,
               symbol->name());

 void OmpAttributeVisitor::Post(const parser::Name &name) {
   auto *symbol{name.symbol};
   if (symbol && !dirContext_.empty() && GetContext().withinConstruct) {
     if (!symbol->owner().IsDerivedType() && !IsProcedure(*symbol) &&
         !IsObjectWithDSA(*symbol) && !IsNamedConstant(*symbol)) {
       // TODO: create a separate function to go through the rules for
       //       predetermined, explicitly determined, and implicitly
       //       determined data-sharing attributes (2.15.1.1).
-      if (Symbol * found{currScope().FindSymbol(name.source)}) {
+      if (Symbol *found{currScope().FindSymbol(name.source)}) {
         if (symbol != found) {
           name.symbol = found; // adjust the symbol within region
         } else if (GetContext().defaultDSA == Symbol::Flag::OmpNone) {
           context_.Say(name.source,
               "The DEFAULT(NONE) clause requires that '%s' must be listed in "
               "a data-sharing attribute clause"_err_en_US,
               symbol->name());
         }

flang/lib/Semantics/resolve-labels.cpp

public:
 
   // Checks for missing or mismatching names on various constructs (e.g., IF)
   // and their intermediate or terminal statements that allow optional
   // construct names(e.g., ELSE).  When an optional construct name is present,
   // the construct as a whole must have a name that matches.
   template <typename FIRST, typename CONSTRUCT, typename STMT>
   void CheckOptionalName(const char *constructTag, const CONSTRUCT &a,
       const parser::Statement<STMT> &stmt) {
-    if (const parser::CharBlock * name{GetStmtName(stmt)}) {
+    if (const parser::CharBlock *name{GetStmtName(stmt)}) {
       const auto &firstStmt{std::get<parser::Statement<FIRST>>(a.t)};
-      if (const parser::CharBlock * firstName{GetStmtName(firstStmt)}) {
+      if (const parser::CharBlock *firstName{GetStmtName(firstStmt)}) {
         if (*firstName != *name) {
           context_.Say(*name, "%s name mismatch"_err_en_US, constructTag)
               .Attach(*firstName, "should be"_en_US);
         }
       } else {
         context_.Say(*name, "%s name not allowed"_err_en_US, constructTag)
             .Attach(firstStmt.source, "in unnamed %s"_en_US, constructTag);
       }
void Post(const parser::SeparateModuleSubprogram &separateModuleSubprogram) {
     CheckOptionalName<parser::MpSubprogramStmt>("MODULE PROCEDURE",
         separateModuleSubprogram,
         std::get<parser::Statement<parser::EndMpSubprogramStmt>>(
             separateModuleSubprogram.t));
   }
 
   // C1401
   void Post(const parser::MainProgram &mainProgram) {
-    if (const parser::CharBlock *
-        endName{GetStmtName(std::get<parser::Statement<parser::EndProgramStmt>>(
+    if (const parser::CharBlock *endName{
+            GetStmtName(std::get<parser::Statement<parser::EndProgramStmt>>(
                 mainProgram.t))}) {
       if (const auto &program{
               std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(
                   mainProgram.t)}) {
         if (*endName != program->statement.v.source) {
           context_.Say(*endName, "END PROGRAM name mismatch"_err_en_US)
               .Attach(program->statement.v.source, "should be"_en_US);
         }
       } else {
private:
 
   // Checks for missing or mismatching names on various constructs (e.g., BLOCK)
   // and their END statements.  Both names must be present if either one is.
   template <typename FIRST, typename END, typename CONSTRUCT>
   void CheckEndName(const char *constructTag, const CONSTRUCT &a) {
     const auto &constructStmt{std::get<parser::Statement<FIRST>>(a.t)};
     const auto &endStmt{std::get<parser::Statement<END>>(a.t)};
     const parser::CharBlock *endName{GetStmtName(endStmt)};
-    if (const parser::CharBlock * constructName{GetStmtName(constructStmt)}) {
+    if (const parser::CharBlock *constructName{GetStmtName(constructStmt)}) {
       if (endName) {
         if (*constructName != *endName) {
           context_
               .Say(*endName, "%s construct name mismatch"_err_en_US,
                   constructTag)
               .Attach(*constructName, "should be"_en_US);
         }
       } else {

flang/lib/Semantics/resolve-names-utils.cpp

 }
 
 // Is type an intrinsic type that satisfies predicate or a sequence type
 // whose components do.
 bool EquivalenceSets::IsSequenceType(const DeclTypeSpec *type,
     std::function<bool(const IntrinsicTypeSpec &)> predicate) {
   if (!type) {
     return false;
-  } else if (const IntrinsicTypeSpec * intrinsic{type->AsIntrinsic()}) {
+  } else if (const IntrinsicTypeSpec *intrinsic{type->AsIntrinsic()}) {
     return predicate(*intrinsic);
-  } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+  } else if (const DerivedTypeSpec *derived{type->AsDerived()}) {
     for (const auto &pair : *derived->typeSymbol().scope()) {
       const Symbol &component{*pair.second};
       if (IsAllocatableOrPointer(component) ||
           !IsSequenceType(component.GetType(), predicate)) {
         return false;
       }
     }
     return true;
common::visit(
                          for (ShapeSpec &spec : object.shape()) {
                            MapShapeSpec(spec);
                          }
                          for (ShapeSpec &spec : object.coshape()) {
                            MapShapeSpec(spec);
                          }
                        },
           [&](ProcEntityDetails &proc) {
-            if (const Symbol *
-                mappedSymbol{MapInterface(proc.procInterface())}) {
+            if (const Symbol *mappedSymbol{
+                    MapInterface(proc.procInterface())}) {
               proc.set_procInterface(*mappedSymbol);
-            } else if (const DeclTypeSpec * mappedType{MapType(proc.type())}) {
+            } else if (const DeclTypeSpec *mappedType{MapType(proc.type())}) {
               proc.set_type(*mappedType);
             }
             if (proc.init()) {
-              if (const Symbol * mapped{MapSymbol(*proc.init())}) {
+              if (const Symbol *mapped{MapSymbol(*proc.init())}) {
                 proc.set_init(*mapped);
               }
             }
           },
           [&](const HostAssocDetails &hostAssoc) {
-            if (const Symbol * mapped{MapSymbol(hostAssoc.symbol())}) {
+            if (const Symbol *mapped{MapSymbol(hostAssoc.symbol())}) {
               symbol.set_details(HostAssocDetails{*mapped});
             }
           },
           [](const auto &) {}},
       symbol.details());
 }
 
 const Symbol *SymbolMapper::MapSymbol(const Symbol &symbol) const {

flang/lib/Semantics/resolve-names.cpp

void AttrsVisitor::SetBindNameOn(Symbol &symbol) {
   }
   // Check if a symbol has two Bind names.
   std::string oldBindName;
   if (symbol.GetBindName()) {
     oldBindName = *symbol.GetBindName();
   }
   symbol.SetBindName(std::move(*label));
   if (!oldBindName.empty()) {
-    if (const std::string * newBindName{symbol.GetBindName()}) {
+    if (const std::string *newBindName{symbol.GetBindName()}) {
       if (oldBindName != *newBindName) {
         Say(symbol.name(), "The entity '%s' has multiple BIND names"_err_en_US);
       }
     }
   }
 }
 
 void AttrsVisitor::Post(const parser::LanguageBindingSpec &x) {
void DeclTypeSpecVisitor::Post(const parser::TypeGuardStmt &) {
   EndDeclTypeSpec();
 }
 
 void DeclTypeSpecVisitor::Post(const parser::TypeSpec &typeSpec) {
   // Record the resolved DeclTypeSpec in the parse tree for use by
   // expression semantics if the DeclTypeSpec is a valid TypeSpec.
   // The grammar ensures that it's an intrinsic or derived type spec,
   // not TYPE(*) or CLASS(*) or CLASS(T).
-  if (const DeclTypeSpec * spec{state_.declTypeSpec}) {
+  if (const DeclTypeSpec *spec{state_.declTypeSpec}) {
     switch (spec->category()) {
     case DeclTypeSpec::Numeric:
     case DeclTypeSpec::Logical:
     case DeclTypeSpec::Character:
       typeSpec.declTypeSpec = spec;
       break;
     case DeclTypeSpec::TypeDerived:
-      if (const DerivedTypeSpec * derived{spec->AsDerived()}) {
+      if (const DerivedTypeSpec *derived{spec->AsDerived()}) {
         CheckForAbstractType(derived->typeSymbol()); // C703
         typeSpec.declTypeSpec = spec;
       }
       break;
     default:
       CRASH_NO_CASE;
     }
   }
if (info->parsedType && info->resultSymbol) {
       info->parsedType = nullptr;
     }
   }
 }
 
 // Called from ConvertTo{Object/Proc}Entity to cope with any appearance
 // of the function result in a specification expression.
 void FuncResultStack::CompleteTypeIfFunctionResult(Symbol &symbol) {
-  if (FuncInfo * info{Top()}) {
+  if (FuncInfo *info{Top()}) {
     if (info->resultSymbol == &symbol) {
       CompleteFunctionResultType();
     }
   }
 }
 
 void FuncResultStack::Pop() {
   if (!stack_.empty() && &stack_.back().scope == &scopeHandler_.currScope()) {
void ScopeHandler::SetScope(Scope &scope) {
   ImplicitRulesVisitor::SetScope(InclusiveScope());
 }
 
 Symbol *ScopeHandler::FindSymbol(const parser::Name &name) {
   return FindSymbol(currScope(), name);
 }
 Symbol *ScopeHandler::FindSymbol(const Scope &scope, const parser::Name &name) {
   if (scope.IsDerivedType()) {
-    if (Symbol * symbol{scope.FindComponent(name.source)}) {
+    if (Symbol *symbol{scope.FindComponent(name.source)}) {
       if (symbol->has<TypeParamDetails>()) {
         return Resolve(name, symbol);
       }
     }
     return FindSymbol(scope.parent(), name);
   } else {
     // In EQUIVALENCE statements only resolve names in the local scope, see
     // 19.5.1.4, paragraph 2, item (10)
     return Resolve(name,
         inEquivalenceStmt_ ? FindInScope(scope, name)
                            : scope.FindSymbol(name.source));
   }
 }
 
 Symbol &ScopeHandler::MakeSymbol(
     Scope &scope, const SourceName &name, Attrs attrs) {
-  if (Symbol * symbol{FindInScope(scope, name)}) {
+  if (Symbol *symbol{FindInScope(scope, name)}) {
     CheckDuplicatedAttrs(name, *symbol, attrs);
     SetExplicitAttrs(*symbol, attrs);
     return *symbol;
   } else {
     const auto pair{scope.try_emplace(name, attrs, UnknownDetails{})};
     CHECK(pair.second); // name was not found, so must be able to add
     return *pair.first->second;
   }
Symbol *ScopeHandler::FindInTypeOrParents(
     const Scope &scope, const parser::Name &name) {
   return Resolve(name, scope.FindComponent(name.source));
 }
 Symbol *ScopeHandler::FindInTypeOrParents(const parser::Name &name) {
   return FindInTypeOrParents(currScope(), name);
 }
 Symbol *ScopeHandler::FindInScopeOrBlockConstructs(
     const Scope &scope, SourceName name) {
-  if (Symbol * symbol{FindInScope(scope, name)}) {
+  if (Symbol *symbol{FindInScope(scope, name)}) {
     return symbol;
   }
   for (const Scope &child : scope.children()) {
     if (child.kind() == Scope::Kind::BlockConstruct) {
-      if (Symbol * symbol{FindInScopeOrBlockConstructs(child, name)}) {
+      if (Symbol *symbol{FindInScopeOrBlockConstructs(child, name)}) {
         return symbol;
       }
     }
   }
   return nullptr;
 }
 
 void ScopeHandler::EraseSymbol(const parser::Name &name) {

 }
 
 void ScopeHandler::ApplyImplicitRules(
     Symbol &symbol, bool allowForwardReference) {
   funcResultStack_.CompleteTypeIfFunctionResult(symbol);
   if (context().HasError(symbol) || !NeedsType(symbol)) {
     return;
   }
-  if (const DeclTypeSpec * type{GetImplicitType(symbol)}) {
+  if (const DeclTypeSpec *type{GetImplicitType(symbol)}) {
     symbol.set(Symbol::Flag::Implicit);
     symbol.SetType(*type);
     return;
   }
   if (symbol.has<ProcEntityDetails>() && !symbol.attrs().test(Attr::EXTERNAL)) {
     std::optional<Symbol::Flag> functionOrSubroutineFlag;
     if (symbol.test(Symbol::Flag::Function)) {
       functionOrSubroutineFlag = Symbol::Flag::Function;
const DeclTypeSpec *ScopeHandler::GetImplicitType(
   const Scope *scope{&symbol.owner()};
   if (scope->IsGlobal()) {
     scope = &currScope();
   }
   scope = &GetInclusiveScope(*scope);
   const auto *type{implicitRulesMap_->at(scope).GetType(
       symbol.name(), respectImplicitNoneType)};
   if (type) {
-    if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+    if (const DerivedTypeSpec *derived{type->AsDerived()}) {
       // Resolve any forward-referenced derived type; a quick no-op else.
       auto &instantiatable{*const_cast<DerivedTypeSpec *>(derived)};
       instantiatable.Instantiate(currScope());
     }
   }
   return type;
 }
 

 // If a symbol has previously been USE-associated and did not appear in
 // an ONLY clause or renaming, erase it from the current scope.  This is
 // necessary when a name appears as the target of a later USE rename clause.
 void ModuleVisitor::EraseRenamedUse(const Symbol *useSymbol) {
   if (!useSymbol) {
     return;
   }
   const SourceName &name{useSymbol->name()};
-  if (const Symbol * symbol{FindInScope(name)}) {
+  if (const Symbol *symbol{FindInScope(name)}) {
     if (const auto *useDetails{symbol->detailsIf<UseDetails>()}) {
       const Symbol &moduleSymbol{useDetails->symbol()};
       if (moduleSymbol.name() == name &&
           moduleSymbol.owner() == useSymbol->owner() && !IsUseOnly(name) &&
           !IsUseRenamed(name)) {
         EraseSymbol(*symbol);
       }
     }
void ModuleVisitor::DoAddUse(SourceName location, SourceName localName,
 
   std::optional<parser::MessageFixedText> msg;
   if (localGeneric) {
     if (localSymbol.has<UseDetails>()) {
       // Create a local copy of a previously use-associated generic so that
       // it can be locally extended without corrupting the original.
       GenericDetails generic;
       generic.CopyFrom(*localGeneric);
-      if (Symbol * spec{localGeneric->specific()};
+      if (Symbol *spec{localGeneric->specific()};
           spec && !spec->attrs().test(Attr::PRIVATE)) {
         generic.set_specific(*spec);
-      } else if (Symbol * dt{generic.derivedType()};
+      } else if (Symbol *dt{generic.derivedType()};
                  dt && dt->attrs().test(Attr::PRIVATE)) {
         generic.clear_derivedType();
       }
       EraseSymbol(localSymbol);
       Symbol &newSymbol{MakeSymbol(
           localSymbol.name(), localSymbol.attrs(), std::move(generic))};
       newSymbol.flags() = localSymbol.flags();
       localGeneric = &newSymbol.get<GenericDetails>();
       localGeneric->AddUse(localSymbol);
     }
     if (useGeneric) {
       // Combine two use-associated generics
       localSymbol.attrs() =
           useSymbol.attrs() & ~Attrs{Attr::PUBLIC, Attr::PRIVATE};
       localSymbol.flags() = useSymbol.flags();
       AddGenericUse(*localGeneric, localName, useUltimate);
       localGeneric->CopyFrom(*useGeneric);
-      if (const Symbol * useSpec{useGeneric->specific()};
+      if (const Symbol *useSpec{useGeneric->specific()};
           useSpec && !useSpec->attrs().test(Attr::PRIVATE)) {
         if (localGeneric->derivedType()) {
           msg =
               "Cannot use-associate generic interface '%s' with specific procedure of the same name when another such interface and derived type are in scope"_err_en_US;
         } else if (!localGeneric->specific()) {
           localGeneric->set_specific(*const_cast<Symbol *>(useSpec));
         } else if (&localGeneric->specific()->GetUltimate() !=
             &useSpec->GetUltimate()) {
           msg =
               "Cannot use-associate generic interface '%s' with specific procedure of the same name when another such interface and procedure are in scope"_err_en_US;
         }
-      } else if (const Symbol * useDT{useGeneric->derivedType()};
+      } else if (const Symbol *useDT{useGeneric->derivedType()};
                  useDT && !useDT->attrs().test(Attr::PRIVATE)) {
         if (localGeneric->specific()) {
           msg =
               "Cannot use-associate generic interface '%s' with derived type of the same name when another such interface and procedure are in scope"_err_en_US;
         } else if (!localGeneric->derivedType()) {
           localGeneric->set_derivedType(*const_cast<Symbol *>(useDT));
         } else if (&localGeneric->derivedType()->GetUltimate() !=
             &useDT->GetUltimate()) {
bool SubprogramVisitor::HandleStmtFunction(const parser::StmtFunctionStmt &x) {
   // all declarations and implicit typing are complete.
   PopScope();
   return true;
 }
 
 bool SubprogramVisitor::Pre(const parser::Suffix &suffix) {
   if (suffix.resultName) {
     if (IsFunction(currScope())) {
-      if (FuncResultStack::FuncInfo * info{funcResultStack().Top()}) {
+      if (FuncResultStack::FuncInfo *info{funcResultStack().Top()}) {
         if (info->inFunctionStmt) {
           info->resultName = &suffix.resultName.value();
         } else {
           // will check the result name in Post(EntryStmt)
         }
       }
     } else {
       Message &msg{Say(*suffix.resultName,
           "RESULT(%s) may appear only in a function"_err_en_US)};
-      if (const Symbol * subprogram{InclusiveScope().symbol()}) {
+      if (const Symbol *subprogram{InclusiveScope().symbol()}) {
         msg.Attach(subprogram->name(), "Containing subprogram"_en_US);
       }
     }
   }
   // LanguageBindingSpec deferred to Post(EntryStmt) or, for FunctionStmt,
   // all the way to EndSubprogram().
   return false;
 }
void SubprogramVisitor::CreateEntry(
   Symbol::Flag subpFlag{subprogram.test(Symbol::Flag::Function)
           ? Symbol::Flag::Function
           : Symbol::Flag::Subroutine};
   Attrs attrs;
   const auto &suffix{std::get<std::optional<parser::Suffix>>(stmt.t)};
   bool hasGlobalBindingName{outer.IsGlobal() && suffix && suffix->binding &&
       suffix->binding->v.has_value()};
   if (!hasGlobalBindingName) {
-    if (Symbol * extant{FindSymbol(outer, entryName)}) {
+    if (Symbol *extant{FindSymbol(outer, entryName)}) {
       if (!HandlePreviousCalls(entryName, *extant, subpFlag)) {
         if (outer.IsTopLevel()) {
           Say2(entryName,
               "'%s' is already defined as a global identifier"_err_en_US,
               *extant, "Previous definition of '%s'"_en_US);
         } else {
           SayAlreadyDeclared(entryName, *extant);
         }
         return;
       }
       attrs = extant->attrs();
     }
   }
   bool badResultName{false};
   std::optional<SourceName> distinctResultName;
   if (suffix && suffix->resultName &&
       suffix->resultName->source != entryName.source) {
     distinctResultName = suffix->resultName->source;
     const parser::Name &resultName{*suffix->resultName};
     if (resultName.source == subprogram.name()) { // C1574
       Say2(resultName.source,
           "RESULT(%s) may not have the same name as the function"_err_en_US,
           subprogram, "Containing function"_en_US);
       badResultName = true;
-    } else if (const Symbol * extant{FindSymbol(outer, resultName)}) { // C1574
+    } else if (const Symbol *extant{FindSymbol(outer, resultName)}) { // C1574
       if (const auto *details{extant->detailsIf<SubprogramDetails>()}) {
         if (details->entryScope() == &currScope()) {
           Say2(resultName.source,
               "RESULT(%s) may not have the same name as an ENTRY in the function"_err_en_US,
               extant->name(), "Conflicting ENTRY"_en_US);
           badResultName = true;
         }
       }
void SubprogramVisitor::PostEntryStmt(const parser::EntryStmt &stmt) {
   }
   SubprogramDetails &entryDetails{entrySymbol.get<SubprogramDetails>()};
   CHECK(entryDetails.entryScope() == &inclusiveScope);
   SetCUDADataAttr(name.source, entrySymbol, cudaDataAttr());
   entrySymbol.attrs() |= GetAttrs();
   SetBindNameOn(entrySymbol);
   for (const auto &dummyArg : std::get<std::list<parser::DummyArg>>(stmt.t)) {
     if (const auto *dummyName{std::get_if<parser::Name>(&dummyArg.u)}) {
-      if (Symbol * dummy{FindInScope(*dummyName)}) {
+      if (Symbol *dummy{FindInScope(*dummyName)}) {
         if (dummy->test(Symbol::Flag::EntryDummyArgument)) {
           const auto *subp{dummy->detailsIf<SubprogramDetails>()};
           if (subp && subp->isInterface()) { // ok
           } else if (!dummy->has<EntityDetails>() &&
               !dummy->has<ObjectEntityDetails>() &&
               !dummy->has<ProcEntityDetails>()) {
             SayWithDecl(*dummyName, *dummy,
                 "ENTRY dummy argument '%s' was previously declared as an item that may not be used as a dummy argument"_err_en_US);
if (symbol && symbol->has<SubprogramNameDetails>()) {
     }
     symbol = parent ? FindSymbol(*parent, name) : nullptr;
   }
   if (symbol) {
     if (auto *generic{symbol->detailsIf<GenericDetails>()}) {
       symbol = generic->specific();
     }
   }
-  if (const Symbol * defnIface{FindSeparateModuleSubprogramInterface(symbol)}) {
+  if (const Symbol *defnIface{FindSeparateModuleSubprogramInterface(symbol)}) {
     // Error recovery in case of multiple definitions
     symbol = const_cast<Symbol *>(defnIface);
   }
   if (!IsSeparateModuleProcedureInterface(symbol)) {
     Say(name, "'%s' was not declared a separate module procedure"_err_en_US);
     symbol = nullptr;
   }
   return symbol;
if (hasModulePrefix && !currScope().IsModule() &&
     return false;
   }
   Symbol *moduleInterface{nullptr};
   if (hasModulePrefix && !inInterfaceBlock()) {
     moduleInterface = FindSeparateModuleProcedureInterface(name);
     if (moduleInterface && &moduleInterface->owner() == &currScope()) {
       // Subprogram is MODULE FUNCTION or MODULE SUBROUTINE with an interface
       // previously defined in the same scope.
-      if (GenericDetails *
-          generic{DEREF(FindSymbol(name)).detailsIf<GenericDetails>()}) {
+      if (GenericDetails *generic{
+              DEREF(FindSymbol(name)).detailsIf<GenericDetails>()}) {
         generic->clear_specific();
       } else {
         EraseSymbol(name);
       }
     }
   }
   Symbol &newSymbol{
       PushSubprogramScope(name, subpFlag, bindingSpec, hasModulePrefix)};
if (isGeneric()) {
       if (auto *details{genericSymbol.detailsIf<GenericDetails>()}) {
         details->AddSpecificProc(*symbol, name.source);
       } else {
         CHECK(context().HasError(genericSymbol));
       }
     }
     set_inheritFromParent(false);
   }
-  if (Symbol * found{FindSymbol(name)};
+  if (Symbol *found{FindSymbol(name)};
       found && found->has<HostAssocDetails>()) {
     found->set(subpFlag); // PushScope() created symbol
   }
   return *symbol;
 }
 
 void SubprogramVisitor::PushBlockDataScope(const parser::Name &name) {
   if (auto *prev{FindSymbol(name)}) {
void DeclarationVisitor::Post(const parser::VectorTypeSpec &x) {
   DerivedTypeSpec vectorDerivedType{typeName.data(), typeSymbol};
   vectorDerivedType.set_category(vectorCategory);
   if (typeParams.size()) {
     vectorDerivedType.AddRawParamValue(nullptr, std::move(typeParams[0]));
     vectorDerivedType.AddRawParamValue(nullptr, std::move(typeParams[1]));
     vectorDerivedType.CookParameters(GetFoldingContext());
   }
 
-  if (const DeclTypeSpec *
-      extant{ppcBuiltinTypesScope->FindInstantiatedDerivedType(
+  if (const DeclTypeSpec *extant{
+          ppcBuiltinTypesScope->FindInstantiatedDerivedType(
               vectorDerivedType, DeclTypeSpec::Category::TypeDerived)}) {
     // This derived type and parameter expressions (if any) are already present
     // in the __ppc_intrinsics scope.
     SetDeclTypeSpec(*extant);
   } else {
     DeclTypeSpec &type{ppcBuiltinTypesScope->MakeDerivedType(
         DeclTypeSpec::Category::TypeDerived, std::move(vectorDerivedType))};
     DerivedTypeSpec &derived{type.derivedTypeSpec()};
     auto restorer{
         GetFoldingContext().messages().SetLocation(currStmtSource().value())};
     derived.Instantiate(*ppcBuiltinTypesScope);
     SetDeclTypeSpec(type);
   }
 }
 
 bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Type &) {
   CHECK(GetDeclTypeSpecCategory() == DeclTypeSpec::Category::TypeDerived);
   return true;
 }
 
 void DeclarationVisitor::Post(const parser::DeclarationTypeSpec::Type &type) {
   const parser::Name &derivedName{std::get<parser::Name>(type.derived.t)};
-  if (const Symbol * derivedSymbol{derivedName.symbol}) {
+  if (const Symbol *derivedSymbol{derivedName.symbol}) {
     CheckForAbstractType(*derivedSymbol); // C706
   }
 }
 
 bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Class &) {
   SetDeclTypeSpecCategory(DeclTypeSpec::Category::ClassDerived);
   return true;
 }
if (dtDetails.isForwardReferenced()) {
     SetDeclTypeSpec(type);
     return;
   }
   // Normalize parameters to produce a better search key.
   spec->CookParameters(GetFoldingContext());
   if (!spec->MightBeParameterized()) {
     spec->EvaluateParameters(context());
   }
-  if (const DeclTypeSpec *
-      extant{currScope().FindInstantiatedDerivedType(*spec, category)}) {
+  if (const DeclTypeSpec *extant{
+          currScope().FindInstantiatedDerivedType(*spec, category)}) {
     // This derived type and parameter expressions (if any) are already present
     // in this scope.
     SetDeclTypeSpec(*extant);
   } else {
     DeclTypeSpec &type{currScope().MakeDerivedType(category, std::move(*spec))};
     DerivedTypeSpec &derived{type.derivedTypeSpec()};
     if (derived.MightBeParameterized() &&
         currScope().IsParameterizedDerivedType()) {
void DeclarationVisitor::Post(const parser::DerivedTypeSpec &x) {
   x.derivedTypeSpec = &GetDeclTypeSpec()->derivedTypeSpec();
 }
 
 void DeclarationVisitor::Post(const parser::DeclarationTypeSpec::Record &rec) {
   const auto &typeName{rec.v};
   if (auto spec{ResolveDerivedType(typeName)}) {
     spec->CookParameters(GetFoldingContext());
     spec->EvaluateParameters(context());
-    if (const DeclTypeSpec *
-        extant{currScope().FindInstantiatedDerivedType(
+    if (const DeclTypeSpec *extant{currScope().FindInstantiatedDerivedType(
             *spec, DeclTypeSpec::TypeDerived)}) {
       SetDeclTypeSpec(*extant);
     } else {
       Say(typeName.source, "%s is not a known STRUCTURE"_err_en_US,
           typeName.source);
     }
   }
 }
void DeclarationVisitor::Post(const parser::DerivedTypeStmt &x) {
   EndAttrs();
 }
 
 void DeclarationVisitor::Post(const parser::TypeParamDefStmt &x) {
   auto *type{GetDeclTypeSpec()};
   auto attr{std::get<common::TypeParamAttr>(x.t)};
   for (auto &decl : std::get<std::list<parser::TypeParamDecl>>(x.t)) {
     auto &name{std::get<parser::Name>(decl.t)};
-    if (Symbol * symbol{MakeTypeSymbol(name, TypeParamDetails{attr})}) {
+    if (Symbol *symbol{MakeTypeSymbol(name, TypeParamDetails{attr})}) {
       SetType(name, *type);
       if (auto &init{
               std::get<std::optional<parser::ScalarIntConstantExpr>>(decl.t)}) {
         if (auto maybeExpr{EvaluateNonPointerInitializer(
                 *symbol, *init, init->thing.thing.thing.value().source)}) {
           if (auto *intExpr{std::get_if<SomeIntExpr>(&maybeExpr->u)}) {
             symbol->get<TypeParamDetails>().set_init(std::move(*intExpr));
           }

 void DeclarationVisitor::Post(const parser::ProcDecl &x) {
   const auto &name{std::get<parser::Name>(x.t)};
   const Symbol *procInterface{nullptr};
   if (interfaceName_) {
     procInterface = interfaceName_->symbol;
   }
   auto attrs{HandleSaveName(name.source, GetAttrs())};
   DerivedTypeDetails *dtDetails{nullptr};
-  if (Symbol * symbol{currScope().symbol()}) {
+  if (Symbol *symbol{currScope().symbol()}) {
     dtDetails = symbol->detailsIf<DerivedTypeDetails>();
   }
   if (!dtDetails) {
     attrs.set(Attr::EXTERNAL);
   }
   Symbol &symbol{DeclareProcEntity(name, attrs, procInterface)};
   SetCUDADataAttr(name.source, symbol, cudaDataAttr()); // for error
   symbol.ReplaceName(name.source);
void DeclarationVisitor::Post(
   }
 }
 
 void DeclarationVisitor::CheckBindings(
     const parser::TypeBoundProcedureStmt::WithoutInterface &tbps) {
   CHECK(currScope().IsDerivedType());
   for (auto &declaration : tbps.declarations) {
     auto &bindingName{std::get<parser::Name>(declaration.t)};
-    if (Symbol * binding{FindInScope(bindingName)}) {
+    if (Symbol *binding{FindInScope(bindingName)}) {
       if (auto *details{binding->detailsIf<ProcBindingDetails>()}) {
         const Symbol &ultimate{details->symbol().GetUltimate()};
         const Symbol &procedure{BypassGeneric(ultimate)};
         if (&procedure != &ultimate) {
           details->ReplaceSymbol(procedure);
         }
         if (!CanBeTypeBoundProc(procedure)) {
           if (details->symbol().name() != binding->name()) {
void DeclarationVisitor::CheckBindings(
   }
 }
 
 void DeclarationVisitor::Post(
     const parser::TypeBoundProcedureStmt::WithInterface &x) {
   if (!GetAttrs().test(Attr::DEFERRED)) { // C783
     Say("DEFERRED is required when an interface-name is provided"_err_en_US);
   }
-  if (Symbol * interface{NoteInterfaceName(x.interfaceName)}) {
+  if (Symbol *interface{NoteInterfaceName(x.interfaceName)}) {
     for (auto &bindingName : x.bindingNames) {
       if (auto *s{
               MakeTypeSymbol(bindingName, ProcBindingDetails{*interface})}) {
         SetPassNameOn(*s);
         if (!GetAttrs().test(Attr::DEFERRED)) {
           context().SetError(*s);
         }
       }
bool DeclarationVisitor::Pre(const parser::TypeBoundGenericStmt &x) {
   auto *genericSymbol{FindInScope(symbolName)};
   if (genericSymbol) {
     if (!genericSymbol->has<GenericDetails>()) {
       genericSymbol = nullptr; // MakeTypeSymbol will report the error below
     }
   } else {
     // look in ancestor types for a generic of the same name
     for (const auto &name : GetAllNames(context(), symbolName)) {
-      if (Symbol * inherited{currScope().FindComponent(SourceName{name})}) {
+      if (Symbol *inherited{currScope().FindComponent(SourceName{name})}) {
         if (inherited->has<GenericDetails>()) {
           CheckAccessibility(symbolName, isPrivate, *inherited); // C771
         } else {
           Say(symbolName,
               "Type bound generic procedure '%s' may not have the same name as a non-generic symbol inherited from an ancestor type"_err_en_US)
               .Attach(inherited->name(), "Inherited symbol"_en_US);
         }
         break;
void DeclarationVisitor::Post(const parser::BasedPointer &bp) {
   if (!type) {
     pointer->SetType(pointerType);
   } else if (*type != pointerType) {
     Say(pointerName.source, "Cray pointer '%s' must have type %s"_err_en_US,
         pointerName.source, pointerType.AsFortran());
   }
   const parser::ObjectName &pointeeName{std::get<1>(bp.t)};
   DeclareObjectEntity(pointeeName);
-  if (Symbol * pointee{pointeeName.symbol}) {
+  if (Symbol *pointee{pointeeName.symbol}) {
     if (!ConvertToObjectEntity(*pointee)) {
       return;
     }
     if (IsNamedConstant(*pointee)) {
       Say(pointeeName,
           "'%s' is a named constant and may not be a Cray pointee"_err_en_US);
       return;
     }
if (attrs.test(Attr::ALLOCATABLE)) {
       Say(name,
           "A named constant '%s' may not appear in a COMMON block"_err_en_US);
     } else if (IsDummy(*symbol)) {
       Say(name,
           "Dummy argument '%s' may not appear in a COMMON block"_err_en_US);
     } else if (symbol->IsFuncResult()) {
       Say(name,
           "Function result '%s' may not appear in a COMMON block"_err_en_US);
-    } else if (const DeclTypeSpec * type{symbol->GetType()}) {
+    } else if (const DeclTypeSpec *type{symbol->GetType()}) {
       if (type->category() == DeclTypeSpec::ClassStar) {
         Say(name,
             "Unlimited polymorphic pointer '%s' may not appear in a COMMON block"_err_en_US);
       } else if (const auto *derived{type->AsDerived()}) {
         auto &typeSymbol{derived->typeSymbol()};
         if (!typeSymbol.attrs().test(Attr::BIND_C) &&
             !typeSymbol.get<DerivedTypeDetails>().sequence()) {
           Say(name,
SayWithDecl(name, symbol,
         "Finalizable variable '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
   if (evaluate::IsCoarray(symbol)) { // C1128
     SayWithDecl(
         name, symbol, "Coarray '%s' not allowed in a locality-spec"_err_en_US);
     return false;
   }
-  if (const DeclTypeSpec * type{symbol.GetType()}) {
+  if (const DeclTypeSpec *type{symbol.GetType()}) {
     if (type->IsPolymorphic() && IsDummy(symbol) &&
         !IsPointer(symbol)) { // C1128
       SayWithDecl(name, symbol,
           "Nonpointer polymorphic argument '%s' not allowed in a "
           "locality-spec"_err_en_US);
       return false;
     }
   }

 
 std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveDerivedType(
     const parser::Name &name) {
   Scope &outer{NonDerivedTypeScope()};
   Symbol *symbol{FindSymbol(outer, name)};
   Symbol *ultimate{symbol ? &symbol->GetUltimate() : nullptr};
   auto *generic{ultimate ? ultimate->detailsIf<GenericDetails>() : nullptr};
   if (generic) {
-    if (Symbol * genDT{generic->derivedType()}) {
+    if (Symbol *genDT{generic->derivedType()}) {
       symbol = genDT;
       generic = nullptr;
     }
   }
   if (!symbol || symbol->has<UnknownDetails>() ||
       (generic && &ultimate->owner() == &outer)) {
     if (allowForwardReferenceToDerivedType()) {
       if (!symbol) {
Symbol *DeclarationVisitor::NoteInterfaceName(const parser::Name &name) {
   if (!NameIsKnownOrIntrinsic(name)) {
     Symbol &symbol{MakeSymbol(InclusiveScope(), name.source, Attrs{})};
     Resolve(name, symbol);
   }
   return name.symbol;
 }
 
 void DeclarationVisitor::CheckExplicitInterface(const parser::Name &name) {
-  if (const Symbol * symbol{name.symbol}) {
+  if (const Symbol *symbol{name.symbol}) {
     const Symbol &ultimate{symbol->GetUltimate()};
     if (!context().HasError(*symbol) && !context().HasError(ultimate) &&
         !ultimate.HasExplicitInterface()) {
       Say(name,
           "'%s' must be an abstract interface or a procedure with "
           "an explicit interface"_err_en_US,
           symbol->name());
     }
bool ConstructVisitor::Pre(const parser::DataStmtObject &x) {
   return false;
 }
 
 bool ConstructVisitor::Pre(const parser::DataStmtValue &x) {
   const auto &data{std::get<parser::DataStmtConstant>(x.t)};
   auto &mutableData{const_cast<parser::DataStmtConstant &>(data)};
   if (auto *elem{parser::Unwrap<parser::ArrayElement>(mutableData)}) {
     if (const auto *name{std::get_if<parser::Name>(&elem->base.u)}) {
-      if (const Symbol * symbol{FindSymbol(*name)}) {
+      if (const Symbol *symbol{FindSymbol(*name)}) {
         const Symbol &ultimate{symbol->GetUltimate()};
         if (ultimate.has<DerivedTypeDetails>()) {
           mutableData.u = elem->ConvertToStructureConstructor(
               DerivedTypeSpec{name->source, ultimate});
         }
       }
     }
   }
if (association.selector.expr) {
       auto exprType{association.selector.expr->GetType()};
       if (exprType && !exprType->IsPolymorphic()) { // C1159
         Say(association.selector.source,
             "Selector '%s' in SELECT TYPE statement must be "
             "polymorphic"_err_en_US);
       }
     }
   } else {
-    if (const Symbol *
-        whole{UnwrapWholeSymbolDataRef(association.selector.expr)}) {
+    if (const Symbol *whole{
+            UnwrapWholeSymbolDataRef(association.selector.expr)}) {
       ConvertToObjectEntity(const_cast<Symbol &>(*whole));
       if (!IsVariableName(*whole)) {
         Say(association.selector.source, // C901
             "Selector is not a variable"_err_en_US);
         association = {};
       }
-      if (const DeclTypeSpec * type{whole->GetType()}) {
+      if (const DeclTypeSpec *type{whole->GetType()}) {
         if (!type->IsPolymorphic()) { // C1159
           Say(association.selector.source,
               "Selector '%s' in SELECT TYPE statement must be "
               "polymorphic"_err_en_US);
         }
       }
     } else {
       Say(association.selector.source, // C1157

 void ConstructVisitor::Post(const parser::SelectRankConstruct &) {
   PopAssociation();
 }
 
 bool ConstructVisitor::CheckDef(const std::optional<parser::Name> &x) {
   if (x && !x->symbol) {
     // Construct names are not scoped by BLOCK in the standard, but many,
     // but not all, compilers do treat them as if they were so scoped.
-    if (Symbol * inner{FindInScope(currScope(), *x)}) {
+    if (Symbol *inner{FindInScope(currScope(), *x)}) {
       SayAlreadyDeclared(*x, *inner);
     } else {
-      if (Symbol *
-          other{FindInScopeOrBlockConstructs(InclusiveScope(), x->source)}) {
+      if (Symbol *other{
+              FindInScopeOrBlockConstructs(InclusiveScope(), x->source)}) {
         SayWithDecl(*x, *other,
             "The construct name '%s' should be distinct at the subprogram level"_port_en_US);
       }
       MakeSymbol(*x, MiscDetails{MiscDetails::Kind::ConstructName});
     }
   }
   return true;
 }
Symbol *ConstructVisitor::MakeAssocEntity() {
   auto &association{GetCurrentAssociation()};
   if (association.name) {
     symbol = &MakeSymbol(*association.name, UnknownDetails{});
     if (symbol->has<AssocEntityDetails>() && symbol->owner() == currScope()) {
       Say(*association.name, // C1102
           "The associate name '%s' is already used in this associate statement"_err_en_US);
       return nullptr;
     }
-  } else if (const Symbol *
-      whole{UnwrapWholeSymbolDataRef(association.selector.expr)}) {
+  } else if (const Symbol *whole{
+                 UnwrapWholeSymbolDataRef(association.selector.expr)}) {
     symbol = &MakeSymbol(whole->name());
   } else {
     return nullptr;
   }
   if (auto &expr{association.selector.expr}) {
     symbol->set_details(AssocEntityDetails{common::Clone(*expr)});
   } else {
     symbol->set_details(AssocEntityDetails{});
if (*pexpr) {
     }
   }
 }
 
 // If current selector is a variable, set some of its attributes on symbol.
 void ConstructVisitor::SetAttrsFromAssociation(Symbol &symbol) {
   Attrs attrs{evaluate::GetAttrs(GetCurrentAssociation().selector.expr)};
   symbol.attrs() |=
-      attrs & Attrs{Attr::TARGET, Attr::ASYNCHRONOUS, Attr::VOLATILE};
+      attrs &Attrs{Attr::TARGET, Attr::ASYNCHRONOUS, Attr::VOLATILE};
   if (attrs.test(Attr::POINTER)) {
     SetImplicitAttr(symbol, Attr::TARGET);
   }
 }
 
 ConstructVisitor::Selector ConstructVisitor::ResolveSelector(
     const parser::Selector &x) {
   return common::visit(common::visitors{
case Scope::Kind::BlockData: // C1415 (in part)
     Say("IMPORT is not allowed in a BLOCK DATA subprogram"_err_en_US);
     return false;
   default:;
   }
   if (auto error{scope.SetImportKind(x.kind)}) {
     Say(std::move(*error));
   }
   for (auto &name : x.names) {
-    if (Symbol * outer{FindSymbol(scope.parent(), name)}) {
+    if (Symbol *outer{FindSymbol(scope.parent(), name)}) {
       scope.add_importName(name.source);
-      if (Symbol * symbol{FindInScope(name)}) {
+      if (Symbol *symbol{FindInScope(name)}) {
         if (outer->GetUltimate() == symbol->GetUltimate()) {
           Say(name,
               "The same '%s' is already present in this scope"_port_en_US);
         } else {
           Say(name,
               "A distinct '%s' is already present in this scope"_err_en_US)
               .Attach(symbol->name(), "Previous declaration of '%s'"_en_US)
               .Attach(outer->name(), "Declaration of '%s' in host scope"_en_US);

 // If implicit types are allowed, ensure name is in the symbol table.
 // Otherwise, report an error if it hasn't been declared.
 const parser::Name *DeclarationVisitor::ResolveName(const parser::Name &name) {
   FindSymbol(name);
   if (CheckForHostAssociatedImplicit(name)) {
     NotePossibleBadForwardRef(name);
     return &name;
   }
-  if (Symbol * symbol{name.symbol}) {
+  if (Symbol *symbol{name.symbol}) {
     if (CheckUseError(name)) {
       return nullptr; // reported an error
     }
     NotePossibleBadForwardRef(name);
     symbol->set(Symbol::Flag::ImplicitOrError, false);
     if (IsUplevelReference(*symbol)) {
       MakeHostAssocSymbol(name, *symbol);
     } else if (IsDummy(*symbol) ||
if (!symbol.has<AssocEntityDetails>() && !ConvertToObjectEntity(symbol)) {
     SayWithDecl(*base, symbol,
         "'%s' is an invalid base for a component reference"_err_en_US);
     return nullptr;
   }
   auto *type{symbol.GetType()};
   if (!type) {
     return nullptr; // should have already reported error
   }
-  if (const IntrinsicTypeSpec * intrinsic{type->AsIntrinsic()}) {
+  if (const IntrinsicTypeSpec *intrinsic{type->AsIntrinsic()}) {
     auto category{intrinsic->category()};
     MiscDetails::Kind miscKind{MiscDetails::Kind::None};
     if (component.source == "kind") {
       miscKind = MiscDetails::Kind::KindParamInquiry;
     } else if (category == TypeCategory::Character) {
       if (component.source == "len") {
         miscKind = MiscDetails::Kind::LenParamInquiry;
       }
     } else if (category == TypeCategory::Complex) {
       if (component.source == "re") {
         miscKind = MiscDetails::Kind::ComplexPartRe;
       } else if (component.source == "im") {
         miscKind = MiscDetails::Kind::ComplexPartIm;
       }
     }
     if (miscKind != MiscDetails::Kind::None) {
       MakePlaceholder(component, miscKind);
       return &component;
     }
-  } else if (DerivedTypeSpec * derived{type->AsDerived()}) {
+  } else if (DerivedTypeSpec *derived{type->AsDerived()}) {
     derived->Instantiate(currScope()); // in case of forward referenced type
-    if (const Scope * scope{derived->scope()}) {
+    if (const Scope *scope{derived->scope()}) {
       if (Resolve(component, scope->FindComponent(component.source))) {
         if (auto msg{CheckAccessibleSymbol(currScope(), *component.symbol)}) {
           context().Say(component.source, *msg);
         }
         return &component;
       } else {
         SayDerivedType(component.source,
             "Component '%s' not found in derived type '%s'"_err_en_US, *scope);

 void ResolveNamesVisitor::HandleCall(
     Symbol::Flag procFlag, const parser::Call &call) {
   common::visit(
       common::visitors{
           [&](const parser::Name &x) { HandleProcedureName(procFlag, x); },
           [&](const parser::ProcComponentRef &x) {
             Walk(x);
             const parser::Name &name{x.v.thing.component};
-            if (Symbol * symbol{name.symbol}) {
+            if (Symbol *symbol{name.symbol}) {
               if (IsProcedure(*symbol)) {
                 SetProcFlag(name, *symbol, procFlag);
               }
             }
           },
       },
       std::get<parser::ProcedureDesignator>(call.t).u);
   Walk(std::get<std::list<parser::ActualArgSpec>>(call.t));

 // that might otherwise have been miscategorized as objects.
 void ResolveNamesVisitor::NoteExecutablePartCall(
     Symbol::Flag flag, const parser::Call &call, bool hasCUDAChevrons) {
   auto &designator{std::get<parser::ProcedureDesignator>(call.t)};
   if (const auto *name{std::get_if<parser::Name>(&designator.u)}) {
     // Subtlety: The symbol pointers in the parse tree are not set, because
     // they might end up resolving elsewhere (e.g., construct entities in
     // SELECT TYPE).
-    if (Symbol * symbol{currScope().FindSymbol(name->source)}) {
+    if (Symbol *symbol{currScope().FindSymbol(name->source)}) {
       Symbol::Flag other{flag == Symbol::Flag::Subroutine
               ? Symbol::Flag::Function
               : Symbol::Flag::Subroutine};
       if (!symbol->test(other)) {
         ConvertToProcEntity(*symbol);
         if (auto *details{symbol->detailsIf<ProcEntityDetails>()}) {
           symbol->set(flag);
           if (IsDummy(*symbol)) {

 
 bool ResolveNamesVisitor::Pre(const parser::PointerAssignmentStmt &x) {
   const auto &dataRef{std::get<parser::DataRef>(x.t)};
   const auto &bounds{std::get<parser::PointerAssignmentStmt::Bounds>(x.t)};
   const auto &expr{std::get<parser::Expr>(x.t)};
   ResolveDataRef(dataRef);
   Walk(bounds);
   // Resolve unrestricted specific intrinsic procedures as in "p => cos".
-  if (const parser::Name * name{parser::Unwrap<parser::Name>(expr)}) {
+  if (const parser::Name *name{parser::Unwrap<parser::Name>(expr)}) {
     if (NameIsKnownOrIntrinsic(*name)) {
       // If the name is known because it is an object entity from a host
       // procedure, create a host associated symbol.
-      if (Symbol * symbol{name->symbol}; symbol &&
+      if (Symbol *symbol{name->symbol}; symbol &&
           symbol->GetUltimate().has<ObjectEntityDetails>() &&
           IsUplevelReference(*symbol)) {
         MakeHostAssocSymbol(*name, *symbol);
       }
       return false;
     }
     // Can also reference a global external procedure here
     if (auto it{context().globalScope().find(name->source)};
if (const auto *tkr{
     }
     if (!inSpecificationPart_) {
       Say(x.source,
           "!DIR$ IGNORE_TKR directive must appear in the specification part"_err_en_US);
       return;
     }
     if (tkr->empty()) {
       Symbol *symbol{currScope().symbol()};
-      if (SubprogramDetails *
-          subp{symbol ? symbol->detailsIf<SubprogramDetails>() : nullptr}) {
+      if (SubprogramDetails *subp{
+              symbol ? symbol->detailsIf<SubprogramDetails>() : nullptr}) {
         subp->set_defaultIgnoreTKR(true);
       }
     } else {
       for (const parser::CompilerDirective::IgnoreTKR &item : *tkr) {
         common::IgnoreTKRSet set;
         if (const auto &maybeList{
                 std::get<std::optional<std::list<const char *>>>(item.t)}) {
           for (const char *p : *maybeList) {
void ResolveNamesVisitor::ResolveSpecificationParts(ProgramTree &node) {
   // If this is a function, convert result to an object. This is to prevent the
   // result from being converted later to a function symbol if it is called
   // inside the function.
   // If the result is function pointer, then ConvertToObjectEntity will not
   // convert the result to an object, and calling the symbol inside the function
   // will result in calls to the result pointer.
   // A function cannot be called recursively if RESULT was not used to define a
   // distinct result name (15.6.2.2 point 4.).
-  if (Symbol * symbol{scope.symbol()}) {
+  if (Symbol *symbol{scope.symbol()}) {
     if (auto *details{symbol->detailsIf<SubprogramDetails>()}) {
       if (details->isFunction()) {
         ConvertToObjectEntity(const_cast<Symbol &>(details->result()));
       }
     }
   }
   if (node.IsModule()) {
     ApplyDefaultAccess();
public:
 
   template <typename A> void Walk(const A &x) { parser::Walk(x, *this); }
 
   template <typename A> bool Pre(const A &) { return true; }
   template <typename A> void Post(const A &) {}
 
   void Post(const parser::DerivedTypeStmt &x) {
     const auto &name{std::get<parser::Name>(x.t)};
-    if (Symbol * symbol{name.symbol}) {
-      if (Scope * scope{symbol->scope()}) {
+    if (Symbol *symbol{name.symbol}) {
+      if (Scope *scope{symbol->scope()}) {
         if (scope->IsDerivedType()) {
           resolver_.PushScope(*scope);
           pushedScope_ = true;
         }
       }
     }
   }
   void Post(const parser::EndTypeStmt &) {
void ResolveNamesVisitor::FinishSpecificationParts(const ProgramTree &node) {
   }
 }
 
 // Duplicate and fold component object pointer default initializer designators
 // using the actual type parameter values of each particular instantiation.
 // Validation is done later in declaration checking.
 void ResolveNamesVisitor::FinishDerivedTypeInstantiation(Scope &scope) {
   CHECK(scope.IsDerivedType() && !scope.symbol());
-  if (DerivedTypeSpec * spec{scope.derivedTypeSpec()}) {
+  if (DerivedTypeSpec *spec{scope.derivedTypeSpec()}) {
     spec->Instantiate(currScope());
     const Symbol &origTypeSymbol{spec->typeSymbol()};
-    if (const Scope * origTypeScope{origTypeSymbol.scope()}) {
+    if (const Scope *origTypeScope{origTypeSymbol.scope()}) {
       CHECK(origTypeScope->IsDerivedType() &&
           origTypeScope->symbol() == &origTypeSymbol);
       auto &foldingContext{GetFoldingContext()};
       auto restorer{foldingContext.WithPDTInstance(*spec)};
       for (auto &pair : scope) {
         Symbol &comp{*pair.second};
         const Symbol &origComp{DEREF(FindInScope(*origTypeScope, comp.name()))};
         if (IsPointer(comp)) {
           if (auto *details{comp.detailsIf<ObjectEntityDetails>()}) {
             auto origDetails{origComp.get<ObjectEntityDetails>()};
-            if (const MaybeExpr & init{origDetails.init()}) {
+            if (const MaybeExpr &init{origDetails.init()}) {
               SomeExpr newInit{*init};
               MaybeExpr folded{FoldExpr(std::move(newInit))};
               details->set_init(std::move(folded));
             }
           }
         }
       }
     }

flang/lib/Semantics/rewrite-parse-tree.cpp

 void RewriteMutator::Post(parser::Name &name) {
   if (!name.symbol && errorOnUnresolvedName_) {
     messages_.Say(name.source, "Internal: no symbol found for '%s'"_err_en_US,
         name.source);
   }
 }
 
 static bool ReturnsDataPointer(const Symbol &symbol) {
-  if (const Symbol * funcRes{FindFunctionResult(symbol)}) {
+  if (const Symbol *funcRes{FindFunctionResult(symbol)}) {
     return IsPointer(*funcRes) && !IsProcedure(*funcRes);
   } else if (const auto *generic{symbol.detailsIf<GenericDetails>()}) {
     for (auto ref : generic->specificProcs()) {
       if (ReturnsDataPointer(*ref)) {
         return true;
       }
     }
   }
   return false;
 }
 
 // Find mis-parsed statement functions and move to stmtFuncsToConvert_ list.
 void RewriteMutator::Post(parser::SpecificationPart &x) {
   auto &list{std::get<std::list<parser::DeclarationConstruct>>(x.t)};
   for (auto it{list.begin()}; it != list.end();) {
     bool isAssignment{false};
     if (auto *stmt{std::get_if<stmtFuncType>(&it->u)}) {
-      if (const Symbol *
-          symbol{std::get<parser::Name>(stmt->statement.value().t).symbol}) {
+      if (const Symbol *symbol{
+              std::get<parser::Name>(stmt->statement.value().t).symbol}) {
         const Symbol &ultimate{symbol->GetUltimate()};
         isAssignment =
             ultimate.has<ObjectEntityDetails>() || ReturnsDataPointer(ultimate);
         if (isAssignment) {
           stmtFuncsToConvert_.emplace_back(std::move(*stmt));
         }
       }
     }

 // When a namelist group name appears (without NML=) in a READ or WRITE
 // statement in such a way that it can be misparsed as a format expression,
 // rewrite the I/O statement's parse tree node as if the namelist group
 // name had appeared with NML=.
 template <typename READ_OR_WRITE>
 void FixMisparsedUntaggedNamelistName(READ_OR_WRITE &x) {
   if (x.iounit && x.format &&
       std::holds_alternative<parser::Expr>(x.format->u)) {
-    if (const parser::Name * name{parser::Unwrap<parser::Name>(x.format)}) {
+    if (const parser::Name *name{parser::Unwrap<parser::Name>(x.format)}) {
       if (name->symbol && name->symbol->GetUltimate().has<NamelistDetails>()) {
         x.controls.emplace_front(parser::IoControlSpec{std::move(*name)});
         x.format.reset();
       }
     }
   }
 }
 

flang/lib/Semantics/runtime-type-info.cpp

private:
   evaluate::StructureConstructor GetValue(
       const std::optional<evaluate::Expr<T>> &expr,
       const SymbolVector *parameters) {
     if (auto constValue{evaluate::ToInt64(expr)}) {
       return PackageIntValue(explicitEnum_, *constValue);
     }
     if (expr) {
       if (parameters) {
-        if (const Symbol * lenParam{evaluate::ExtractBareLenParameter(*expr)}) {
+        if (const Symbol *lenParam{evaluate::ExtractBareLenParameter(*expr)}) {
           return PackageIntValue(
               lenParameterEnum_, FindLenParameterIndex(*parameters, *lenParam));
         }
       }
       // TODO: Replace a specification expression requiring actual operations
       // with a reference to a new anonymous LEN type parameter whose default
       // value captures the expression.  This replacement must take place when
       // the type is declared so that the new LEN type parameters appear in
static SomeExpr SaveDerivedPointerTarget(Scope &scope, SourceName name,
     evaluate::ConstantSubscripts &&shape) {
   if (x.empty()) {
     return SomeExpr{evaluate::NullPointer{}};
   } else {
     auto dyType{x.front().GetType()};
     const auto &derivedType{dyType.GetDerivedTypeSpec()};
     ObjectEntityDetails object;
     DeclTypeSpec typeSpec{DeclTypeSpec::TypeDerived, derivedType};
-    if (const DeclTypeSpec * spec{scope.FindType(typeSpec)}) {
+    if (const DeclTypeSpec *spec{scope.FindType(typeSpec)}) {
       object.set_type(*spec);
     } else {
       object.set_type(scope.MakeDerivedType(
           DeclTypeSpec::TypeDerived, common::Clone(derivedType)));
     }
     if (!shape.empty()) {
       ArraySpec arraySpec;
       for (auto n : shape) {
for (SymbolRef ref : *parameters) {
       }
     }
     return suffix;
   }
   return std::nullopt;
 }
 
 const Symbol *RuntimeTableBuilder::DescribeType(Scope &dtScope) {
-  if (const Symbol * info{dtScope.runtimeDerivedTypeDescription()}) {
+  if (const Symbol *info{dtScope.runtimeDerivedTypeDescription()}) {
     return info;
   }
   const DerivedTypeSpec *derivedTypeSpec{dtScope.derivedTypeSpec()};
   if (!derivedTypeSpec && !dtScope.IsDerivedTypeWithKindParameter() &&
       dtScope.symbol()) {
     // This derived type was declared (obviously, there's a Scope) but never
     // used in this compilation (no instantiated DerivedTypeSpec points here).
     // Create a DerivedTypeSpec now for it so that ComponentIterator
     // will work. This covers the case of a derived type that's declared in
     // a module but used only by clients and submodules, enabling the
     // run-time "no initialization needed here" flag to work.
     DerivedTypeSpec derived{dtScope.symbol()->name(), *dtScope.symbol()};
-    if (const SymbolVector *
-        lenParameters{GetTypeParameters(*dtScope.symbol())}) {
+    if (const SymbolVector *lenParameters{
+            GetTypeParameters(*dtScope.symbol())}) {
       // Create dummy deferred values for the length parameters so that the
       // DerivedTypeSpec is complete and can be used in helpers.
       for (SymbolRef lenParam : *lenParameters) {
         (void)lenParam;
         derived.AddRawParamValue(
             nullptr, ParamValue::Deferred(common::TypeParamAttr::Len));
       }
       derived.CookParameters(context_.foldingContext());
if (dyType.IsUnlimitedPolymorphic() ||
       dyType.category() == TypeCategory::Derived) {
     AddValue(values, componentSchema_, "kind"s, IntExpr<1>(0));
   } else {
     AddValue(values, componentSchema_, "kind"s, IntExpr<1>(dyType.kind()));
   }
   AddValue(values, componentSchema_, "offset"s, IntExpr<8>(symbol.offset()));
   // CHARACTER length
   auto len{typeAndShape->LEN()};
-  if (const semantics::DerivedTypeSpec *
-      pdtInstance{dtScope.derivedTypeSpec()}) {
+  if (const semantics::DerivedTypeSpec *pdtInstance{
+          dtScope.derivedTypeSpec()}) {
     auto restorer{foldingContext.WithPDTInstance(*pdtInstance)};
     len = Fold(foldingContext, std::move(len));
   }
   if (dyType.category() == TypeCategory::Character && len) {
     // Ignore IDIM(x) (represented as MAX(0, x))
     if (const auto *clamped{evaluate::UnwrapExpr<
             evaluate::Extremum<evaluate::SubscriptInteger>>(*len)}) {
       if (clamped->ordering == evaluate::Ordering::Greater &&
if (dyType.category() == TypeCategory::Derived &&
     Scope *derivedScope{const_cast<Scope *>(
         spec.scope() ? spec.scope() : spec.typeSymbol().scope())};
     const Symbol *derivedDescription{DescribeType(DEREF(derivedScope))};
     AddValue(values, componentSchema_, "derived"s,
         evaluate::AsGenericExpr(evaluate::Expr<evaluate::SomeDerived>{
             evaluate::Designator<evaluate::SomeDerived>{
                 DEREF(derivedDescription)}}));
     // Package values of LEN parameters, if any
-    if (const SymbolVector * specParams{GetTypeParameters(spec.typeSymbol())}) {
+    if (const SymbolVector *specParams{GetTypeParameters(spec.typeSymbol())}) {
       for (SymbolRef ref : *specParams) {
         const auto &tpd{ref->get<TypeParamDetails>()};
         if (tpd.attr() == common::TypeParamAttr::Len) {
-          if (const ParamValue * paramValue{spec.FindParameter(ref->name())}) {
+          if (const ParamValue *paramValue{spec.FindParameter(ref->name())}) {
             lenParams.emplace_back(GetValue(*paramValue, parameters));
           } else {
             lenParams.emplace_back(GetValue(tpd.init(), parameters));
           }
         }
       }
     }
   } else {
SymbolVector CollectBindings(const Scope &dtScope) {
   // Collect local bindings
   for (auto pair : dtScope) {
     Symbol &symbol{const_cast<Symbol &>(*pair.second)};
     if (auto *binding{symbol.detailsIf<ProcBindingDetails>()}) {
       localBindings.emplace(symbol.name(), &symbol);
       binding->set_numPrivatesNotOverridden(0);
     }
   }
-  if (const Scope * parentScope{dtScope.GetDerivedTypeParent()}) {
+  if (const Scope *parentScope{dtScope.GetDerivedTypeParent()}) {
     result = CollectBindings(*parentScope);
     // Apply overrides from the local bindings of the extended type
     for (auto iter{result.begin()}; iter != result.end(); ++iter) {
       const Symbol &symbol{**iter};
       auto overriderIter{localBindings.find(symbol.name())};
       if (overriderIter != localBindings.end()) {
         Symbol &overrider{*overriderIter->second};
         if (symbol.attrs().test(Attr::PRIVATE) &&
RuntimeTableBuilder::DescribeBindings(const Scope &dtScope, Scope &scope) {
   }
   return result;
 }
 
 std::map<int, evaluate::StructureConstructor>
 RuntimeTableBuilder::DescribeSpecialGenerics(const Scope &dtScope,
     const Scope &thisScope, const DerivedTypeSpec *derivedTypeSpec) const {
   std::map<int, evaluate::StructureConstructor> specials;
-  if (const Scope * parentScope{dtScope.GetDerivedTypeParent()}) {
+  if (const Scope *parentScope{dtScope.GetDerivedTypeParent()}) {
     specials =
         DescribeSpecialGenerics(*parentScope, thisScope, derivedTypeSpec);
   }
   for (auto pair : dtScope) {
     const Symbol &symbol{*pair.second};
     if (const auto *generic{symbol.detailsIf<GenericDetails>()}) {
       DescribeSpecialGeneric(*generic, specials, thisScope, derivedTypeSpec);
     }
RuntimeDerivedTypeTables BuildRuntimeDerivedTypeTables(
   }
   return result;
 }
 
 // Find the type of a defined I/O procedure's interface's initial "dtv"
 // dummy argument.  Returns a non-null DeclTypeSpec pointer only if that
 // dtv argument exists and is a derived type.
 static const DeclTypeSpec *GetDefinedIoSpecificArgType(const Symbol &specific) {
-  const Symbol *interface{&specific.GetUltimate()};
+  const Symbol *interface {
+    &specific.GetUltimate()
+  };
   if (const auto *procEntity{specific.detailsIf<ProcEntityDetails>()}) {
     interface = procEntity->procInterface();
   }
   if (interface) {
-    if (const SubprogramDetails *
-            subprogram{interface->detailsIf<SubprogramDetails>()};
+    if (const SubprogramDetails *subprogram{
+            interface->detailsIf<SubprogramDetails>()};
         subprogram && !subprogram->dummyArgs().empty()) {
-      if (const Symbol * dtvArg{subprogram->dummyArgs().at(0)}) {
-        if (const DeclTypeSpec * declType{dtvArg->GetType()}) {
+      if (const Symbol *dtvArg{subprogram->dummyArgs().at(0)}) {
+        if (const DeclTypeSpec *declType{dtvArg->GetType()}) {
           return declType->AsDerived() ? declType : nullptr;
         }
       }
     }
   }
   return nullptr;
 }
 
 // Locate a particular scope's generic interface for a specific kind of
 // defined I/O.
 static const Symbol *FindGenericDefinedIo(
     const Scope &scope, common::DefinedIo which) {
-  if (const Symbol * symbol{scope.FindSymbol(GenericKind::AsFortran(which))}) {
+  if (const Symbol *symbol{scope.FindSymbol(GenericKind::AsFortran(which))}) {
     const Symbol &generic{symbol->GetUltimate()};
     const auto &genericDetails{generic.get<GenericDetails>()};
     CHECK(std::holds_alternative<common::DefinedIo>(genericDetails.kind().u));
     CHECK(std::get<common::DefinedIo>(genericDetails.kind().u) == which);
     return &generic;
   } else {
     return nullptr;
   }
if (!scope.IsTopLevel() &&
     result = CollectNonTbpDefinedIoGenericInterfaces(
         scope.parent(), useRuntimeTypeInfoEntries);
   }
   if (scope.kind() != Scope::Kind::DerivedType) {
     for (common::DefinedIo which :
         {common::DefinedIo::ReadFormatted, common::DefinedIo::ReadUnformatted,
             common::DefinedIo::WriteFormatted,
             common::DefinedIo::WriteUnformatted}) {
-      if (const Symbol * generic{FindGenericDefinedIo(scope, which)}) {
+      if (const Symbol *generic{FindGenericDefinedIo(scope, which)}) {
         for (auto specific : generic->get<GenericDetails>().specificProcs()) {
-          if (const DeclTypeSpec *
-              declType{GetDefinedIoSpecificArgType(*specific)}) {
+          if (const DeclTypeSpec *declType{
+                  GetDefinedIoSpecificArgType(*specific)}) {
             const DerivedTypeSpec &derived{DEREF(declType->AsDerived())};
-            if (const Symbol *
-                dtDesc{derived.scope()
+            if (const Symbol *dtDesc{derived.scope()
                         ? derived.scope()->runtimeDerivedTypeDescription()
                         : nullptr}) {
               if (useRuntimeTypeInfoEntries &&
                   &derived.scope()->parent() == &generic->owner()) {
                 // This non-TBP defined I/O generic was defined in the
                 // same scope as the derived type, and it will be
                 // included in the derived type's special bindings
                 // by IncorporateDefinedIoGenericInterfaces().

 // which those special bindings are not to be used.  Its result is intended
 // to be put into the "ignoreNonTbpEntries" flag of
 // runtime::NonTbpDefinedIoTable and passed (negated) as the
 // "useRuntimeTypeInfoEntries" argument of
 // CollectNonTbpDefinedIoGenericInterfaces() above.
 
 static const Symbol *FindSpecificDefinedIo(const Scope &scope,
     const evaluate::DynamicType &derived, common::DefinedIo which) {
-  if (const Symbol * generic{FindGenericDefinedIo(scope, which)}) {
+  if (const Symbol *generic{FindGenericDefinedIo(scope, which)}) {
     for (auto ref : generic->get<GenericDetails>().specificProcs()) {
       const Symbol &specific{*ref};
-      if (const DeclTypeSpec *
-          thisType{GetDefinedIoSpecificArgType(specific)}) {
+      if (const DeclTypeSpec *thisType{GetDefinedIoSpecificArgType(specific)}) {
         if (evaluate::DynamicType{DEREF(thisType->AsDerived()), true}
                 .IsTkCompatibleWith(derived)) {
           return &specific.GetUltimate();
         }
       }
     }
   }
   return nullptr;
 }
 
 bool ShouldIgnoreRuntimeTypeInfoNonTbpGenericInterfaces(
     const Scope &scope, const DerivedTypeSpec *derived) {
   if (!derived) {
     return false;
   }
   const Symbol &typeSymbol{derived->typeSymbol()};
   const Scope &typeScope{typeSymbol.GetUltimate().owner()};
   evaluate::DynamicType dyType{*derived};
   for (common::DefinedIo which :
       {common::DefinedIo::ReadFormatted, common::DefinedIo::ReadUnformatted,
           common::DefinedIo::WriteFormatted,
           common::DefinedIo::WriteUnformatted}) {
-    if (const Symbol *
-        specific{FindSpecificDefinedIo(typeScope, dyType, which)}) {
+    if (const Symbol *specific{
+            FindSpecificDefinedIo(typeScope, dyType, which)}) {
       // There's a non-TBP defined I/O procedure in the scope of the type's
       // definition that applies to this type.  It will appear in the type's
       // runtime information.  Determine whether it still applies in the
       // scope of interest.
       if (FindSpecificDefinedIo(scope, dyType, which) != specific) {
         return true;
       }
     }

flang/lib/Semantics/scope.cpp

Symbol *Scope::FindSymbol(const SourceName &name) const {
   }
 }
 
 Symbol *Scope::FindComponent(SourceName name) const {
   CHECK(IsDerivedType());
   auto found{find(name)};
   if (found != end()) {
     return &*found->second;
-  } else if (const Scope * parent{GetDerivedTypeParent()}) {
+  } else if (const Scope *parent{GetDerivedTypeParent()}) {
     return parent->FindComponent(name);
   } else {
     return nullptr;
   }
 }
 
 bool Scope::Contains(const Scope &that) const {
   for (const Scope *scope{&that};; scope = &scope->parent()) {
if (dyType->IsAssumedType()) {
       return &MakeClassStarType();
     } else {
       switch (dyType->category()) {
       case TypeCategory::Integer:
       case TypeCategory::Real:
       case TypeCategory::Complex:
         return &MakeNumericType(dyType->category(), KindExpr{dyType->kind()});
       case TypeCategory::Character:
-        if (const ParamValue * lenParam{dyType->charLengthParamValue()}) {
+        if (const ParamValue *lenParam{dyType->charLengthParamValue()}) {
           return &MakeCharacterType(
               ParamValue{*lenParam}, KindExpr{dyType->kind()});
         } else {
           auto lenExpr{dyType->GetCharLength()};
           if (!lenExpr) {
             lenExpr =
                 std::get<evaluate::Expr<evaluate::SomeCharacter>>(expr.u).LEN();
           }
for (auto *scope{this}; !scope->IsTopLevel(); scope = &scope->parent()) {
     } else if (scope->cookedSource_ == cooked) {
       scope->sourceRange_.ExtendToCover(source);
     } else {
       // There's a bug that will be hard to fix; crash informatively
       const parser::AllSources &allSources{allCookedSources.allSources()};
       const auto describe{[&](parser::CharBlock src) {
         if (auto range{allCookedSources.GetProvenanceRange(src)}) {
           std::size_t offset;
-          if (const parser::SourceFile *
-              file{allSources.GetSourceFile(range->start(), &offset)}) {
+          if (const parser::SourceFile *file{
+                  allSources.GetSourceFile(range->start(), &offset)}) {
             return "'"s + file->path() + "' at " + std::to_string(offset) +
                 " for " + std::to_string(range->size());
           } else {
             return "(GetSourceFile failed)"s;
           }
         } else {
           return "(GetProvenanceRange failed)"s;
         }
static bool IsParam(const Symbol &symbol) {
     }
     return false;
   }
 };
 
 template <common::TypeParamAttr... ParamAttr>
 static bool IsParameterizedDerivedTypeHelper(const Scope &scope) {
   if (scope.IsDerivedType()) {
-    if (const Scope * parent{scope.GetDerivedTypeParent()}) {
+    if (const Scope *parent{scope.GetDerivedTypeParent()}) {
       if (IsParameterizedDerivedTypeHelper<ParamAttr...>(*parent)) {
         return true;
       }
     }
     for (const auto &nameAndSymbolPair : scope) {
       if (IsTypeParamHelper<ParamAttr...>::IsParam(*nameAndSymbolPair.second)) {
         return true;
       }
const DeclTypeSpec *Scope::FindInstantiatedDerivedType(
   } else if (IsGlobal()) {
     return nullptr;
   } else {
     return parent().FindInstantiatedDerivedType(spec, category);
   }
 }
 
 const Scope *Scope::GetDerivedTypeParent() const {
-  if (const Symbol * symbol{GetSymbol()}) {
-    if (const DerivedTypeSpec * parent{symbol->GetParentTypeSpec(this)}) {
+  if (const Symbol *symbol{GetSymbol()}) {
+    if (const DerivedTypeSpec *parent{symbol->GetParentTypeSpec(this)}) {
       return parent->scope();
     }
   }
   return nullptr;
 }
 
 const Scope &Scope::GetDerivedTypeBase() const {
   const Scope *child{this};

flang/lib/Semantics/semantics.cpp

 
 void SemanticsContext::CheckIndexVarRedefine(
     const parser::CharBlock &location, const Symbol &variable) {
   CheckIndexVarRedefine(
       location, variable, "Cannot redefine %s variable '%s'"_err_en_US);
 }
 
 void SemanticsContext::CheckIndexVarRedefine(const parser::Variable &variable) {
-  if (const Symbol * entity{GetLastName(variable).symbol}) {
+  if (const Symbol *entity{GetLastName(variable).symbol}) {
     CheckIndexVarRedefine(variable.GetSource(), *entity);
   }
 }
 
 void SemanticsContext::CheckIndexVarRedefine(const parser::Name &name) {
-  if (const Symbol * entity{name.symbol}) {
+  if (const Symbol *entity{name.symbol}) {
     CheckIndexVarRedefine(name.source, *entity);
   }
 }
 
 void SemanticsContext::ActivateIndexVar(
     const parser::Name &name, IndexVarKind kind) {
   CheckIndexVarRedefine(name);
-  if (const Symbol * indexVar{name.symbol}) {
+  if (const Symbol *indexVar{name.symbol}) {
     activeIndexVars_.emplace(
         ResolveAssociations(*indexVar), IndexVarInfo{name.source, kind});
   }
 }
 
 void SemanticsContext::DeactivateIndexVar(const parser::Name &name) {
-  if (Symbol * indexVar{name.symbol}) {
+  if (Symbol *indexVar{name.symbol}) {
     auto it{activeIndexVars_.find(ResolveAssociations(*indexVar))};
     if (it != activeIndexVars_.end() && it->second.location == name.source) {
       activeIndexVars_.erase(it);
     }
   }
 }
 
 SymbolVector SemanticsContext::GetIndexVars(IndexVarKind kind) {

flang/lib/Semantics/symbol.cpp

llvm::raw_ostream &operator<<(
   if (x.procInterface_) {
     os << ' ' << x.procInterface_->name();
   } else {
     DumpType(os, x.type());
   }
   DumpOptional(os, "bindName", x.bindName());
   DumpOptional(os, "passName", x.passName());
   if (x.init()) {
-    if (const Symbol * target{*x.init()}) {
+    if (const Symbol *target{*x.init()}) {
       os << " => " << target->name();
     } else {
       os << " => NULL()";
     }
   }
   if (x.isCUDAKernel()) {
     os << " isCUDAKernel";
   }
if (isDef) {
     }
     os << ' ' << symbol.GetDetailsName();
     DumpType(os, symbol.GetType());
   }
   return os;
 }
 
 const DerivedTypeSpec *Symbol::GetParentTypeSpec(const Scope *scope) const {
-  if (const Symbol * parentComponent{GetParentComponent(scope)}) {
+  if (const Symbol *parentComponent{GetParentComponent(scope)}) {
     const auto &object{parentComponent->get<ObjectEntityDetails>()};
     return &object.type()->derivedTypeSpec();
   } else {
     return nullptr;
   }
 }
 
 const Symbol *Symbol::GetParentComponent(const Scope *scope) const {
   if (const auto *dtDetails{detailsIf<DerivedTypeDetails>()}) {
-    if (const Scope * localScope{scope ? scope : scope_}) {
+    if (const Scope *localScope{scope ? scope : scope_}) {
       return dtDetails->GetParentComponent(DEREF(localScope));
     }
   }
   return nullptr;
 }
 
 void DerivedTypeDetails::add_component(const Symbol &symbol) {
   if (symbol.test(Symbol::Flag::ParentComp)) {
     CHECK(componentNames_.empty());
   }
   componentNames_.push_back(symbol.name());
 }
 
 const Symbol *DerivedTypeDetails::GetParentComponent(const Scope &scope) const {
   if (auto extends{GetParentComponentName()}) {
     if (auto iter{scope.find(*extends)}; iter != scope.cend()) {
-      if (const Symbol & symbol{*iter->second};
+      if (const Symbol &symbol{*iter->second};
           symbol.test(Symbol::Flag::ParentComp)) {
         return &symbol;
       }
     }
   }
   return nullptr;
 }
 
 const Symbol *DerivedTypeDetails::GetFinalForRank(int rank) const {
   for (const auto &pair : finals_) {
     const Symbol &symbol{*pair.second};
     if (const auto *details{symbol.detailsIf<SubprogramDetails>()}) {
       if (details->dummyArgs().size() == 1) {
-        if (const Symbol * arg{details->dummyArgs().at(0)}) {
+        if (const Symbol *arg{details->dummyArgs().at(0)}) {
           if (const auto *object{arg->detailsIf<ObjectEntityDetails>()}) {
             if (rank == object->shape().Rank() || object->IsAssumedRank() ||
                 IsElementalProcedure(symbol)) {
               return &symbol;
             }
           }
         }
       }

flang/lib/Semantics/tools.cpp

 
 bool IsHostAssociatedIntoSubprogram(const Symbol &symbol, const Scope &scope) {
   return DoesScopeContain(
       &GetProgramUnitOrBlockConstructContaining(FollowHostAssoc(symbol)),
       GetProgramUnitContaining(scope));
 }
 
 bool IsInStmtFunction(const Symbol &symbol) {
-  if (const Symbol * function{symbol.owner().symbol()}) {
+  if (const Symbol *function{symbol.owner().symbol()}) {
     return IsStmtFunction(*function);
   }
   return false;
 }
 
 bool IsStmtFunctionDummy(const Symbol &symbol) {
   return IsDummy(symbol) && IsInStmtFunction(symbol);
 }
if (procDetails->procInterface()) {
       // procedure component with a BIND(C) interface
       return IsBindCProcedure(*procDetails->procInterface());
     }
   }
   return symbol.attrs().test(Attr::BIND_C) && IsProcedure(symbol);
 }
 
 bool IsBindCProcedure(const Scope &scope) {
-  if (const Symbol * symbol{scope.GetSymbol()}) {
+  if (const Symbol *symbol{scope.GetSymbol()}) {
     return IsBindCProcedure(*symbol);
   } else {
     return false;
   }
 }
 
 static const Symbol *FindPointerComponent(
     const Scope &scope, std::set<const Scope *> &visited) {
for (const auto &pair : scope) {
     const Symbol &symbol{*pair.second};
     if (IsPointer(symbol)) {
       return &symbol;
     }
   }
   for (const auto &pair : scope) {
     const Symbol &symbol{*pair.second};
     if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
-      if (const DeclTypeSpec * type{details->type()}) {
-        if (const DerivedTypeSpec * derived{type->AsDerived()}) {
-          if (const Scope * nested{derived->scope()}) {
-            if (const Symbol *
-                pointer{FindPointerComponent(*nested, visited)}) {
+      if (const DeclTypeSpec *type{details->type()}) {
+        if (const DerivedTypeSpec *derived{type->AsDerived()}) {
+          if (const Scope *nested{derived->scope()}) {
+            if (const Symbol *pointer{FindPointerComponent(*nested, visited)}) {
               return pointer;
             }
           }
         }
       }
     }
   }
   return nullptr;
 }
 
 const Symbol *FindPointerComponent(const Scope &scope) {
   std::set<const Scope *> visited;
   return FindPointerComponent(scope, visited);
 }
 
 const Symbol *FindPointerComponent(const DerivedTypeSpec &derived) {
-  if (const Scope * scope{derived.scope()}) {
+  if (const Scope *scope{derived.scope()}) {
     return FindPointerComponent(*scope);
   } else {
     return nullptr;
   }
 }
 
 const Symbol *FindPointerComponent(const DeclTypeSpec &type) {
-  if (const DerivedTypeSpec * derived{type.AsDerived()}) {
+  if (const DerivedTypeSpec *derived{type.AsDerived()}) {
     return FindPointerComponent(*derived);
   } else {
     return nullptr;
   }
 }
 
 const Symbol *FindPointerComponent(const DeclTypeSpec *type) {
   return type ? FindPointerComponent(*type) : nullptr;
if (!isPointerDefinition && IsPointer(ultimate) &&
         IsPureProcedure(ultimate.owner()) && IsFunction(ultimate.owner())) {
       return &ultimate;
     }
   } else if (ultimate.owner().IsDerivedType()) {
     return nullptr;
   } else if (&GetProgramUnitContaining(ultimate) !=
       &GetProgramUnitContaining(scope)) {
     return &object;
-  } else if (const Symbol * block{FindCommonBlockContaining(ultimate)}) {
+  } else if (const Symbol *block{FindCommonBlockContaining(ultimate)}) {
     return block;
   }
   return nullptr;
 }
 
 const Symbol &BypassGeneric(const Symbol &symbol) {
   const Symbol &ultimate{symbol.GetUltimate()};
   if (const auto *generic{ultimate.detailsIf<GenericDetails>()}) {
-    if (const Symbol * specific{generic->specific()}) {
+    if (const Symbol *specific{generic->specific()}) {
       return *specific;
     }
   }
   return symbol;
 }
 
 bool ExprHasTypeCategory(
     const SomeExpr &expr, const common::TypeCategory &type) {
return common::visit(
           },
           [](const auto &) -> const Symbol * { return nullptr; },
       },
       symbol.details());
 }
 
 const Symbol *FindOverriddenBinding(const Symbol &symbol) {
   if (symbol.has<ProcBindingDetails>()) {
-    if (const DeclTypeSpec * parentType{FindParentTypeSpec(symbol.owner())}) {
-      if (const DerivedTypeSpec * parentDerived{parentType->AsDerived()}) {
-        if (const Scope * parentScope{parentDerived->typeSymbol().scope()}) {
-          if (const Symbol *
-              overridden{parentScope->FindComponent(symbol.name())}) {
+    if (const DeclTypeSpec *parentType{FindParentTypeSpec(symbol.owner())}) {
+      if (const DerivedTypeSpec *parentDerived{parentType->AsDerived()}) {
+        if (const Scope *parentScope{parentDerived->typeSymbol().scope()}) {
+          if (const Symbol *overridden{
+                  parentScope->FindComponent(symbol.name())}) {
             // 7.5.7.3 p1: only accessible bindings are overridden
             if (!overridden->attrs().test(Attr::PRIVATE) ||
                 (FindModuleContaining(overridden->owner()) ==
                     FindModuleContaining(symbol.owner()))) {
               return overridden;
             }
           }
         }
const Symbol *FindGlobal(const Symbol &original) {
   return nullptr;
 }
 
 const DeclTypeSpec *FindParentTypeSpec(const DerivedTypeSpec &derived) {
   return FindParentTypeSpec(derived.typeSymbol());
 }
 
 const DeclTypeSpec *FindParentTypeSpec(const DeclTypeSpec &decl) {
-  if (const DerivedTypeSpec * derived{decl.AsDerived()}) {
+  if (const DerivedTypeSpec *derived{decl.AsDerived()}) {
     return FindParentTypeSpec(*derived);
   } else {
     return nullptr;
   }
 }
 
 const DeclTypeSpec *FindParentTypeSpec(const Scope &scope) {
   if (scope.kind() == Scope::Kind::DerivedType) {
     if (const auto *symbol{scope.symbol()}) {
       return FindParentTypeSpec(*symbol);
     }
   }
   return nullptr;
 }
 
 const DeclTypeSpec *FindParentTypeSpec(const Symbol &symbol) {
-  if (const Scope * scope{symbol.scope()}) {
+  if (const Scope *scope{symbol.scope()}) {
     if (const auto *details{symbol.detailsIf<DerivedTypeDetails>()}) {
-      if (const Symbol * parent{details->GetParentComponent(*scope)}) {
+      if (const Symbol *parent{details->GetParentComponent(*scope)}) {
         return parent->GetType();
       }
     }
   }
   return nullptr;
 }
 
 const EquivalenceSet *FindEquivalenceSet(const Symbol &symbol) {
   const Symbol &ultimate{symbol.GetUltimate()};
   for (const EquivalenceSet &set : ultimate.owner().equivalenceSets()) {
     for (const EquivalenceObject &object : set) {
       if (object.symbol == ultimate) {
         return &set;
       }
     }
   }
   return nullptr;
 }
 
 bool IsOrContainsEventOrLockComponent(const Symbol &original) {
   const Symbol &symbol{ResolveAssociations(original)};
   if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
-    if (const DeclTypeSpec * type{details->type()}) {
-      if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+    if (const DeclTypeSpec *type{details->type()}) {
+      if (const DerivedTypeSpec *derived{type->AsDerived()}) {
         return IsEventTypeOrLockType(derived) ||
             FindEventOrLockPotentialComponent(*derived);
       }
     }
   }
   return false;
 }
 
SymbolVector FinalsForDerivedTypeInstantiation(const DerivedTypeSpec &spec) {
   const Symbol &typeSymbol{spec.typeSymbol()};
   if (const auto *derived{typeSymbol.detailsIf<DerivedTypeDetails>()}) {
     for (const auto &pair : derived->finals()) {
       const Symbol &subr{*pair.second};
       // Errors in FINAL subroutines are caught in CheckFinal
       // in check-declarations.cpp.
       if (const auto *subprog{subr.detailsIf<SubprogramDetails>()};
           subprog && subprog->dummyArgs().size() == 1) {
-        if (const Symbol * arg{subprog->dummyArgs()[0]}) {
-          if (const DeclTypeSpec * type{arg->GetType()}) {
+        if (const Symbol *arg{subprog->dummyArgs()[0]}) {
+          if (const DeclTypeSpec *type{arg->GetType()}) {
             if (type->category() == DeclTypeSpec::TypeDerived &&
                 evaluate::AreSameDerivedType(spec, type->derivedTypeSpec())) {
               result.emplace_back(subr);
             }
           }
         }
       }
     }
   }
   return result;
 }
 
 const Symbol *IsFinalizable(const Symbol &symbol,
     std::set<const DerivedTypeSpec *> *inProgress, bool withImpureFinalizer) {
   if (IsPointer(symbol) || evaluate::IsAssumedRank(symbol)) {
     return nullptr;
   }
   if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
     if (object->isDummy() && !IsIntentOut(symbol)) {
       return nullptr;
     }
     const DeclTypeSpec *type{object->type()};
-    if (const DerivedTypeSpec * typeSpec{type ? type->AsDerived() : nullptr}) {
+    if (const DerivedTypeSpec *typeSpec{type ? type->AsDerived() : nullptr}) {
       return IsFinalizable(
           *typeSpec, inProgress, withImpureFinalizer, symbol.Rank());
     }
   }
   return nullptr;
 }
 
 const Symbol *IsFinalizable(const DerivedTypeSpec &derived,
     std::set<const DerivedTypeSpec *> *inProgress, bool withImpureFinalizer,
     std::optional<int> rank) {
   const Symbol *elemental{nullptr};
   for (auto ref : FinalsForDerivedTypeInstantiation(derived)) {
     const Symbol *symbol{&ref->GetUltimate()};
     if (const auto *binding{symbol->detailsIf<ProcBindingDetails>()}) {
       symbol = &binding->symbol();
     }
     if (const auto *proc{symbol->detailsIf<ProcEntityDetails>()}) {
       symbol = proc->procInterface();
     }
     if (!symbol) {
     } else if (IsElementalProcedure(*symbol)) {
       elemental = symbol;
     } else {
       if (rank) {
-        if (const SubprogramDetails *
-            subp{symbol->detailsIf<SubprogramDetails>()}) {
+        if (const SubprogramDetails *subp{
+                symbol->detailsIf<SubprogramDetails>()}) {
           if (const auto &args{subp->dummyArgs()}; !args.empty() &&
               args.at(0) && !evaluate::IsAssumedRank(*args.at(0)) &&
               args.at(0)->Rank() != *rank) {
             continue; // not a finalizer for this rank
           }
         }
       }
       if (!withImpureFinalizer || !IsPureProcedure(*symbol)) {

 static const Symbol *HasImpureFinal(
     const DerivedTypeSpec &derived, std::optional<int> rank) {
   return IsFinalizable(derived, nullptr, /*withImpureFinalizer=*/true, rank);
 }
 
 const Symbol *HasImpureFinal(const Symbol &original) {
   const Symbol &symbol{ResolveAssociations(original)};
   if (symbol.has<ObjectEntityDetails>()) {
-    if (const DeclTypeSpec * symType{symbol.GetType()}) {
-      if (const DerivedTypeSpec * derived{symType->AsDerived()}) {
+    if (const DeclTypeSpec *symType{symbol.GetType()}) {
+      if (const DerivedTypeSpec *derived{symType->AsDerived()}) {
         // finalizable assumed-rank not allowed (C839)
         return evaluate::IsAssumedRank(symbol)
             ? nullptr
             : HasImpureFinal(*derived, symbol.Rank());
       }
     }
   }
   return nullptr;
 }
 
 bool IsAssumedLengthCharacter(const Symbol &symbol) {
-  if (const DeclTypeSpec * type{symbol.GetType()}) {
+  if (const DeclTypeSpec *type{symbol.GetType()}) {
     return type->category() == DeclTypeSpec::Character &&
         type->characterTypeSpec().length().isAssumed();
   } else {
     return false;
   }
 }
 
 bool IsInBlankCommon(const Symbol &symbol) {
for (const Symbol &symbol : evaluate::CollectSymbols(*expr)) {
         return true;
       }
     }
   }
   return false;
 }
 
 bool IsAssumedType(const Symbol &symbol) {
-  if (const DeclTypeSpec * type{symbol.GetType()}) {
+  if (const DeclTypeSpec *type{symbol.GetType()}) {
     return type->IsAssumedType();
   }
   return false;
 }
 
 bool IsPolymorphic(const Symbol &symbol) {
-  if (const DeclTypeSpec * type{symbol.GetType()}) {
+  if (const DeclTypeSpec *type{symbol.GetType()}) {
     return type->IsPolymorphic();
   }
   return false;
 }
 
 bool IsUnlimitedPolymorphic(const Symbol &symbol) {
-  if (const DeclTypeSpec * type{symbol.GetType()}) {
+  if (const DeclTypeSpec *type{symbol.GetType()}) {
     return type->IsUnlimitedPolymorphic();
   }
   return false;
 }
 
 bool IsPolymorphicAllocatable(const Symbol &symbol) {
   return IsAllocatable(symbol) && IsPolymorphic(symbol);
 }

 
 std::optional<parser::MessageFormattedText> CheckAccessibleSymbol(
     const Scope &scope, const Symbol &symbol) {
   if (symbol.attrs().test(Attr::PRIVATE)) {
     if (FindModuleFileContaining(scope)) {
       // Don't enforce component accessibility checks in module files;
       // there may be forward-substituted named constants of derived type
       // whose structure constructors reference private components.
-    } else if (const Scope *
-        moduleScope{FindModuleContaining(symbol.owner())}) {
+    } else if (const Scope *moduleScope{FindModuleContaining(symbol.owner())}) {
       if (!moduleScope->Contains(scope)) {
         return parser::MessageFormattedText{
             "PRIVATE name '%s' is only accessible within module '%s'"_err_en_US,
             symbol.name(), moduleScope->GetName().value()};
       }
     }
   }
   return std::nullopt;
 }
 
 std::list<SourceName> OrderParameterNames(const Symbol &typeSymbol) {
   std::list<SourceName> result;
-  if (const DerivedTypeSpec * spec{typeSymbol.GetParentTypeSpec()}) {
+  if (const DerivedTypeSpec *spec{typeSymbol.GetParentTypeSpec()}) {
     result = OrderParameterNames(spec->typeSymbol());
   }
   const auto &paramNames{typeSymbol.get<DerivedTypeDetails>().paramNames()};
   result.insert(result.end(), paramNames.begin(), paramNames.end());
   return result;
 }
 
 SymbolVector OrderParameterDeclarations(const Symbol &typeSymbol) {
   SymbolVector result;
-  if (const DerivedTypeSpec * spec{typeSymbol.GetParentTypeSpec()}) {
+  if (const DerivedTypeSpec *spec{typeSymbol.GetParentTypeSpec()}) {
     result = OrderParameterDeclarations(spec->typeSymbol());
   }
   const auto &paramDecls{typeSymbol.get<DerivedTypeDetails>().paramDecls()};
   result.insert(result.end(), paramDecls.begin(), paramDecls.end());
   return result;
 }
 
 const DeclTypeSpec &FindOrInstantiateDerivedType(
     Scope &scope, DerivedTypeSpec &&spec, DeclTypeSpec::Category category) {
   spec.EvaluateParameters(scope.context());
-  if (const DeclTypeSpec *
-      type{scope.FindInstantiatedDerivedType(spec, category)}) {
+  if (const DeclTypeSpec *type{
+          scope.FindInstantiatedDerivedType(spec, category)}) {
     return *type;
   }
   // Create a new instantiation of this parameterized derived type
   // for this particular distinct set of actual parameter values.
   DeclTypeSpec &type{scope.MakeDerivedType(category, std::move(spec))};
   type.derivedTypeSpec().Instantiate(scope);
   return type;
 }
 
 const Symbol *FindSeparateModuleSubprogramInterface(const Symbol *proc) {
   if (proc) {
     if (const auto *subprogram{proc->detailsIf<SubprogramDetails>()}) {
-      if (const Symbol * iface{subprogram->moduleInterface()}) {
+      if (const Symbol *iface{subprogram->moduleInterface()}) {
         return iface;
       }
     }
   }
   return nullptr;
 }
 
 ProcedureDefinitionClass ClassifyProcedure(const Symbol &symbol) { // 15.2.2
ProcedureDefinitionClass ClassifyProcedure(const Symbol &symbol) { // 15.2.2
   } else if (const auto *nameDetails{
                  ultimate.detailsIf<SubprogramNameDetails>()}) {
     switch (nameDetails->kind()) {
     case SubprogramKind::Module:
       return ProcedureDefinitionClass::Module;
     case SubprogramKind::Internal:
       return ProcedureDefinitionClass::Internal;
     }
-  } else if (const Symbol * subp{FindSubprogram(symbol)}) {
+  } else if (const Symbol *subp{FindSubprogram(symbol)}) {
     if (const auto *subpDetails{subp->detailsIf<SubprogramDetails>()}) {
       if (subpDetails->stmtFunction()) {
         return ProcedureDefinitionClass::StatementFunction;
       }
     }
     switch (ultimate.owner().kind()) {
     case Scope::Kind::Global:
     case Scope::Kind::IntrinsicModules:
ComponentIterator<componentKind>::const_iterator::Create(
   return it;
 }
 
 template <ComponentKind componentKind>
 const DerivedTypeSpec *
 ComponentIterator<componentKind>::const_iterator::PlanComponentTraversal(
     const Symbol &component) const {
   if (const auto *details{component.detailsIf<ObjectEntityDetails>()}) {
-    if (const DeclTypeSpec * type{details->type()}) {
+    if (const DeclTypeSpec *type{details->type()}) {
       if (const auto *derived{type->AsDerived()}) {
         bool traverse{false};
         if constexpr (componentKind == ComponentKind::Ordered) {
           // Order Component (only visit parents)
           traverse = component.test(Symbol::Flag::ParentComp);
         } else if constexpr (componentKind == ComponentKind::Direct) {
           traverse = !IsAllocatableOrPointer(component);
         } else if constexpr (componentKind == ComponentKind::Ultimate) {

 
 template <ComponentKind componentKind>
 void ComponentIterator<componentKind>::const_iterator::Increment() {
   while (!componentPath_.empty()) {
     ComponentPathNode &deepest{componentPath_.back()};
     if (deepest.component()) {
       if (!deepest.descended()) {
         deepest.set_descended(true);
-        if (const DerivedTypeSpec *
-            derived{PlanComponentTraversal(*deepest.component())}) {
+        if (const DerivedTypeSpec *derived{
+                PlanComponentTraversal(*deepest.component())}) {
           componentPath_.emplace_back(*derived);
           continue;
         }
       } else if (!deepest.visited()) {
         deepest.set_visited(true);
         return; // this is the next component to visit, after descending
       }
     }
if (const auto *type{object->type()}) {
       }
     }
   }
   return nullptr;
 }
 
 const Symbol *FindImmediateComponent(const DerivedTypeSpec &type,
     const std::function<bool(const Symbol &)> &predicate) {
-  if (const Scope * scope{type.scope()}) {
+  if (const Scope *scope{type.scope()}) {
     const Symbol *parent{nullptr};
     for (const auto &pair : *scope) {
       const Symbol *symbol{&*pair.second};
       if (predicate(*symbol)) {
         return symbol;
       }
       if (symbol->test(Symbol::Flag::ParentComp)) {
         parent = symbol;
if (parent) {
       }
     }
   }
   return nullptr;
 }
 
 const Symbol *IsFunctionResultWithSameNameAsFunction(const Symbol &symbol) {
   if (IsFunctionResult(symbol)) {
-    if (const Symbol * function{symbol.owner().symbol()}) {
+    if (const Symbol *function{symbol.owner().symbol()}) {
       if (symbol.name() == function->name()) {
         return function;
       }
     }
     // Check ENTRY result symbols too
     const Scope &outer{symbol.owner().parent()};
     auto iter{outer.find(symbol.name())};
     if (iter != outer.end()) {
if (const auto *type{GetDtvArgTypeSpec(proc)}) {
     return type->AsDerived();
   } else {
     return nullptr;
   }
 }
 
 bool HasDefinedIo(common::DefinedIo which, const DerivedTypeSpec &derived,
     const Scope *scope) {
-  if (const Scope * dtScope{derived.scope()}) {
+  if (const Scope *dtScope{derived.scope()}) {
     for (const auto &pair : *dtScope) {
       const Symbol &symbol{*pair.second};
       if (const auto *generic{symbol.detailsIf<GenericDetails>()}) {
         GenericKind kind{generic->kind()};
         if (const auto *io{std::get_if<common::DefinedIo>(&kind.u)}) {
           if (*io == which) {
             return true; // type-bound GENERIC exists
           }
         }
       }
     }
   }
   if (scope) {
     SourceName name{GenericKind::AsFortran(which)};
     evaluate::DynamicType dyDerived{derived};
     for (; scope && !scope->IsGlobal(); scope = &scope->parent()) {
       auto iter{scope->find(name)};
       if (iter != scope->end()) {
         const auto &generic{iter->second->GetUltimate().get<GenericDetails>()};
         for (auto ref : generic.specificProcs()) {
           const Symbol &procSym{ref->GetUltimate()};
-          if (const DeclTypeSpec * dtSpec{GetDtvArgTypeSpec(procSym)}) {
+          if (const DeclTypeSpec *dtSpec{GetDtvArgTypeSpec(procSym)}) {
             if (auto dyDummy{evaluate::DynamicType::From(*dtSpec)}) {
               if (dyDummy->IsTkCompatibleWith(dyDerived)) {
                 return true; // GENERIC or INTERFACE not in type
               }
             }
           }
         }
       }
     }
   }
   return false;
 }
 
 void WarnOnDeferredLengthCharacterScalar(SemanticsContext &context,
     const SomeExpr *expr, parser::CharBlock at, const char *what) {
   if (context.languageFeatures().ShouldWarn(
           common::UsageWarning::F202XAllocatableBreakingChange)) {
-    if (const Symbol *
-        symbol{evaluate::UnwrapWholeSymbolOrComponentDataRef(expr)}) {
+    if (const Symbol *symbol{
+            evaluate::UnwrapWholeSymbolOrComponentDataRef(expr)}) {
       const Symbol &ultimate{ResolveAssociations(*symbol)};
-      if (const DeclTypeSpec * type{ultimate.GetType()}; type &&
+      if (const DeclTypeSpec *type{ultimate.GetType()}; type &&
           type->category() == DeclTypeSpec::Category::Character &&
           type->characterTypeSpec().length().isDeferred() &&
           IsAllocatable(ultimate) && ultimate.Rank() == 0) {
         context.Say(at,
             "The deferred length allocatable character scalar variable '%s' may be reallocated to a different length under the new Fortran 202X standard semantics for %s"_port_en_US,
             symbol->name(), what);
       }
     }
   }
 }
 
 bool CouldBeDataPointerValuedFunction(const Symbol *original) {
   if (original) {
     const Symbol &ultimate{original->GetUltimate()};
-    if (const Symbol * result{FindFunctionResult(ultimate)}) {
+    if (const Symbol *result{FindFunctionResult(ultimate)}) {
       return IsPointer(*result) && !IsProcedure(*result);
     }
     if (const auto *generic{ultimate.detailsIf<GenericDetails>()}) {
       for (const SymbolRef &ref : generic->specificProcs()) {
         if (CouldBeDataPointerValuedFunction(&*ref)) {
           return true;
         }
       }
     }
   }
   return false;
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/type.cpp

void DerivedTypeSpec::EvaluateParameters(SemanticsContext &context) {
 
   // Fold the explicit type parameter value expressions first.  Do not
   // fold them within the scope of the derived type being instantiated;
   // these expressions cannot use its type parameters.  Convert the values
   // of the expressions to the declared types of the type parameters.
   auto parameterDecls{OrderParameterDeclarations(typeSymbol_)};
   for (const Symbol &symbol : parameterDecls) {
     const SourceName &name{symbol.name()};
-    if (ParamValue * paramValue{FindParameter(name)}) {
-      if (const MaybeIntExpr & expr{paramValue->GetExplicit()}) {
+    if (ParamValue *paramValue{FindParameter(name)}) {
+      if (const MaybeIntExpr &expr{paramValue->GetExplicit()}) {
         if (auto converted{evaluate::ConvertToType(symbol, SomeExpr{*expr})}) {
           SomeExpr folded{
               evaluate::Fold(foldingContext, std::move(*converted))};
           if (auto *intExpr{std::get_if<SomeIntExpr>(&folded.u)}) {
             paramValue->SetExplicit(std::move(*intExpr));
             continue;
           }
         }

 
 // Completes component derived type instantiation and initializer folding
 // for a non-parameterized derived type Scope.
 static void InstantiateNonPDTScope(Scope &typeScope, Scope &containingScope) {
   auto &context{containingScope.context()};
   auto &foldingContext{context.foldingContext()};
   for (auto &pair : typeScope) {
     Symbol &symbol{*pair.second};
-    if (DeclTypeSpec * type{symbol.GetType()}) {
-      if (DerivedTypeSpec * derived{type->AsDerived()}) {
+    if (DeclTypeSpec *type{symbol.GetType()}) {
+      if (DerivedTypeSpec *derived{type->AsDerived()}) {
         if (!(derived->IsForwardReferenced() &&
                 IsAllocatableOrPointer(symbol))) {
           derived->Instantiate(containingScope);
         }
       }
     }
     if (!IsPointer(symbol)) {
       if (auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
-        if (MaybeExpr & init{object->init()}) {
+        if (MaybeExpr &init{object->init()}) {
           auto restorer{foldingContext.messages().SetLocation(symbol.name())};
           init = evaluate::NonPointerInitializationExpr(
               symbol, std::move(*init), foldingContext);
         }
       }
     }
   }
   ComputeOffsets(context, typeScope);
void DerivedTypeSpec::Instantiate(Scope &containingScope) {
   for (const Symbol &symbol : OrderParameterDeclarations(typeSymbol_)) {
     const SourceName &name{symbol.name()};
     if (typeScope.find(symbol.name()) != typeScope.end()) {
       // This type parameter belongs to the derived type itself, not to
       // one of its ancestors.  Put the type parameter expression value,
       // when there is one, into the new scope as the initialization value
       // for the parameter.  And when there is no explicit value, add an
       // uninitialized type parameter to forestall use of any default.
-      if (ParamValue * paramValue{FindParameter(name)}) {
+      if (ParamValue *paramValue{FindParameter(name)}) {
         const TypeParamDetails &details{symbol.get<TypeParamDetails>()};
         paramValue->set_attr(details.attr());
         TypeParamDetails instanceDetails{details.attr()};
-        if (const DeclTypeSpec * type{details.type()}) {
+        if (const DeclTypeSpec *type{details.type()}) {
           instanceDetails.set_type(*type);
         }
         desc += sep;
         desc += name.ToString();
         desc += '=';
         sep = ',';
         if (MaybeIntExpr expr{paramValue->GetExplicit()}) {
           if (auto folded{evaluate::NonPointerInitializationExpr(symbol,
void InstantiateHelper::InstantiateComponent(const Symbol &oldSymbol) {
   if (!pair.second) {
     // Symbol was already present in the scope, which can only happen
     // in the case of type parameters.
     CHECK(oldSymbol.has<TypeParamDetails>());
     return;
   }
   newSymbol.flags() = oldSymbol.flags();
   if (auto *details{newSymbol.detailsIf<ObjectEntityDetails>()}) {
-    if (const DeclTypeSpec * newType{InstantiateType(newSymbol)}) {
+    if (const DeclTypeSpec *newType{InstantiateType(newSymbol)}) {
       details->ReplaceType(*newType);
     }
     for (ShapeSpec &dim : details->shape()) {
       if (dim.lbound().isExplicit()) {
         dim.lbound().SetExplicit(Fold(std::move(dim.lbound().GetExplicit())));
       }
       if (dim.ubound().isExplicit()) {
         dim.ubound().SetExplicit(Fold(std::move(dim.ubound().GetExplicit())));
if (const auto *parsedExpr{details->unanalyzedPDTComponentInit()}) {
       auto restorer{foldingContext().messages().SetLocation(newSymbol.name())};
       details->set_init(evaluate::Fold(
           foldingContext(), AnalyzeExpr(context(), *parsedExpr)));
       details->set_unanalyzedPDTComponentInit(nullptr);
       // Remove analysis results to prevent unparsing or other use of
       // instantiation-specific expressions.
       parser::Walk(*parsedExpr, resetter);
     }
-    if (MaybeExpr & init{details->init()}) {
+    if (MaybeExpr &init{details->init()}) {
       // Non-pointer components with default initializers are
       // processed now so that those default initializers can be used
       // in PARAMETER structure constructors.
       auto restorer{foldingContext().messages().SetLocation(newSymbol.name())};
       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)}) {
+    if (const DeclTypeSpec *returnType{InstantiateType(newSymbol)}) {
       if (!procDetails->procInterface()) {
         procDetails->ReplaceType(*returnType);
       }
     }
   }
 }
 
 const DeclTypeSpec *InstantiateHelper::InstantiateType(const Symbol &symbol) {
   const DeclTypeSpec *type{symbol.GetType()};
   if (!type) {
     return nullptr; // error has occurred
-  } else if (const DerivedTypeSpec * spec{type->AsDerived()}) {
+  } else if (const DerivedTypeSpec *spec{type->AsDerived()}) {
     return &FindOrInstantiateDerivedType(scope_,
         CreateDerivedTypeSpec(*spec, symbol.test(Symbol::Flag::ParentComp)),
         type->category());
   } else if (type->AsIntrinsic()) {
     return &InstantiateIntrinsicType(symbol.name(), *type);
   } else if (type->category() == DeclTypeSpec::ClassStar) {
     return type;
   } else {

 }
 DeclTypeSpec::DeclTypeSpec(Category category) : category_{category} {
   CHECK(category == TypeStar || category == ClassStar);
 }
 bool DeclTypeSpec::IsNumeric(TypeCategory tc) const {
   return category_ == Numeric && numericTypeSpec().category() == tc;
 }
 bool DeclTypeSpec::IsSequenceType() const {
-  if (const DerivedTypeSpec * derivedType{AsDerived()}) {
+  if (const DerivedTypeSpec *derivedType{AsDerived()}) {
     const auto *typeDetails{
         derivedType->typeSymbol().detailsIf<DerivedTypeDetails>()};
     return typeDetails && typeDetails->sequence();
   }
   return false;
 }
 
 const NumericTypeSpec &DeclTypeSpec::numericTypeSpec() const {

flang/runtime/allocatable.cpp

int RTNAME(AllocatableAllocate)(Descriptor &descriptor, bool hasStat,
   if (!descriptor.IsAllocatable()) {
     return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);
   }
   if (descriptor.IsAllocated()) {
     return ReturnError(terminator, StatBaseNotNull, errMsg, hasStat);
   }
   int stat{ReturnError(terminator, descriptor.Allocate(), errMsg, hasStat)};
   if (stat == StatOk) {
-    if (const DescriptorAddendum * addendum{descriptor.Addendum()}) {
+    if (const DescriptorAddendum *addendum{descriptor.Addendum()}) {
       if (const auto *derived{addendum->derivedType()}) {
         if (!derived->noInitializationNeeded()) {
           stat = Initialize(descriptor, *derived, terminator, hasStat, errMsg);
         }
       }
     }
   }
   return stat;

flang/runtime/assign.cpp

 // originally deallocated or because it required reallocation
 static int AllocateAssignmentLHS(
     Descriptor &to, const Descriptor &from, Terminator &terminator, int flags) {
   to.raw().type = from.raw().type;
   if (!(flags & ExplicitLengthCharacterLHS)) {
     to.raw().elem_len = from.ElementBytes();
   }
   const typeInfo::DerivedType *derived{nullptr};
-  if (const DescriptorAddendum * fromAddendum{from.Addendum()}) {
+  if (const DescriptorAddendum *fromAddendum{from.Addendum()}) {
     derived = fromAddendum->derivedType();
-    if (DescriptorAddendum * toAddendum{to.Addendum()}) {
+    if (DescriptorAddendum *toAddendum{to.Addendum()}) {
       toAddendum->set_derivedType(derived);
       std::size_t lenParms{derived ? derived->LenParameters() : 0};
       for (std::size_t j{0}; j < lenParms; ++j) {
         toAddendum->SetLenParameterValue(j, fromAddendum->LenParameterValue(j));
       }
     }
   }
   // subtle: leave bounds in place when "from" is scalar (10.2.1.3(3))
if (to.type() != from.type()) {
     terminator.Crash("Assign: mismatching types (to code %d != from code %d)",
         to.type().raw(), from.type().raw());
   }
   if (toElementBytes > fromElementBytes && !to.type().IsCharacter()) {
     terminator.Crash("Assign: mismatching non-character element sizes (to %zd "
                      "bytes != from %zd bytes)",
         toElementBytes, fromElementBytes);
   }
-  if (const typeInfo::DerivedType *
-      updatedToDerived{toAddendum ? toAddendum->derivedType() : nullptr}) {
+  if (const typeInfo::DerivedType *updatedToDerived{
+          toAddendum ? toAddendum->derivedType() : nullptr}) {
     // Derived type intrinsic assignment, which is componentwise and elementwise
     // for all components, including parent components (10.2.1.2-3).
     // The target is first finalized if still necessary (7.5.6.3(1))
     if (flags & NeedFinalization) {
       Finalize(to, *updatedToDerived, &terminator);
     }
     // Copy the data components (incl. the parent) first.
     const Descriptor &componentDesc{updatedToDerived->component()};
void RTNAME(Assign)(Descriptor &to, const Descriptor &from,
   Assign(to, from, terminator,
       MaybeReallocate | NeedFinalization | ComponentCanBeDefinedAssignment);
 }
 
 void RTNAME(AssignTemporary)(Descriptor &to, const Descriptor &from,
     const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   // Initialize the "to" if it is of derived type that needs initialization.
-  if (const DescriptorAddendum * addendum{to.Addendum()}) {
+  if (const DescriptorAddendum *addendum{to.Addendum()}) {
     if (const auto *derived{addendum->derivedType()}) {
       // Do not invoke the initialization, if the descriptor is unallocated.
       // AssignTemporary() is used for component-by-component assignments,
       // for example, for structure constructors. This means that the LHS
       // may be an allocatable component with unallocated status.
       // The initialization will just fail in this case. By skipping
       // the initialization we let Assign() automatically allocate
       // and initialize the component according to the RHS.
void RTNAME(AssignTemporary)(Descriptor &to, const Descriptor &from,
   Assign(to, from, terminator, PolymorphicLHS);
 }
 
 void RTNAME(CopyOutAssign)(Descriptor &to, const Descriptor &from,
     bool skipToInit, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   // Initialize the "to" if it is of derived type that needs initialization.
   if (!skipToInit) {
-    if (const DescriptorAddendum * addendum{to.Addendum()}) {
+    if (const DescriptorAddendum *addendum{to.Addendum()}) {
       if (const auto *derived{addendum->derivedType()}) {
         if (!derived->noInitializationNeeded()) {
           if (ReturnError(terminator, Initialize(to, *derived, terminator)) !=
               StatOk) {
             return;
           }
         }
       }

flang/runtime/derived-api.cpp

 #include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 
 extern "C" {
 
 void RTNAME(Initialize)(
     const Descriptor &descriptor, const char *sourceFile, int sourceLine) {
-  if (const DescriptorAddendum * addendum{descriptor.Addendum()}) {
+  if (const DescriptorAddendum *addendum{descriptor.Addendum()}) {
     if (const auto *derived{addendum->derivedType()}) {
       if (!derived->noInitializationNeeded()) {
         Terminator terminator{sourceFile, sourceLine};
         Initialize(descriptor, *derived, terminator);
       }
     }
   }
 }
 
 void RTNAME(Destroy)(const Descriptor &descriptor) {
-  if (const DescriptorAddendum * addendum{descriptor.Addendum()}) {
+  if (const DescriptorAddendum *addendum{descriptor.Addendum()}) {
     if (const auto *derived{addendum->derivedType()}) {
       if (!derived->noDestructionNeeded()) {
         // TODO: Pass source file & line information to the API
         // so that a good Terminator can be passed
         Destroy(descriptor, true, *derived, nullptr);
       }
     }
   }
 }
 
 bool RTNAME(ClassIs)(
     const Descriptor &descriptor, const typeInfo::DerivedType &derivedType) {
-  if (const DescriptorAddendum * addendum{descriptor.Addendum()}) {
+  if (const DescriptorAddendum *addendum{descriptor.Addendum()}) {
     if (const auto *derived{addendum->derivedType()}) {
       if (derived == &derivedType) {
         return true;
       }
       const typeInfo::DerivedType *parent{derived->GetParentType()};
       while (parent) {
         if (parent == &derivedType) {
           return true;

 }
 
 inline bool CompareDerivedType(
     const typeInfo::DerivedType *a, const typeInfo::DerivedType *b) {
   return a == b || CompareDerivedTypeNames(a->name(), b->name());
 }
 
 static const typeInfo::DerivedType *GetDerivedType(const Descriptor &desc) {
-  if (const DescriptorAddendum * addendum{desc.Addendum()}) {
+  if (const DescriptorAddendum *addendum{desc.Addendum()}) {
     if (const auto *derived{addendum->derivedType()}) {
       return derived;
     }
   }
   return nullptr;
 }
 
 bool RTNAME(SameTypeAs)(const Descriptor &a, const Descriptor &b) {
if (CompareDerivedType(parent, derivedTypeMold)) {
       return true;
     }
     parent = parent->GetParentType();
   }
   return false;
 }
 
 void RTNAME(DestroyWithoutFinalization)(const Descriptor &descriptor) {
-  if (const DescriptorAddendum * addendum{descriptor.Addendum()}) {
+  if (const DescriptorAddendum *addendum{descriptor.Addendum()}) {
     if (const auto *derived{addendum->derivedType()}) {
       if (!derived->noDestructionNeeded()) {
         Destroy(descriptor, /*finalize=*/false, *derived, nullptr);
       }
     }
   }
 }
 
 } // extern "C"
 } // namespace Fortran::runtime

flang/runtime/derived.cpp

if (comp.genre() == typeInfo::Component::Genre::Allocatable ||
       for (std::size_t j{0}; j < elements; ++j) {
         Descriptor &allocDesc{*instance.OffsetElement<Descriptor>(
             j * byteStride + comp.offset())};
         comp.EstablishDescriptor(allocDesc, instance, terminator);
         allocDesc.raw().attribute = CFI_attribute_allocatable;
         if (comp.genre() == typeInfo::Component::Genre::Automatic) {
           stat = ReturnError(terminator, allocDesc.Allocate(), errMsg, hasStat);
           if (stat == StatOk) {
-            if (const DescriptorAddendum * addendum{allocDesc.Addendum()}) {
+            if (const DescriptorAddendum *addendum{allocDesc.Addendum()}) {
               if (const auto *derived{addendum->derivedType()}) {
                 if (!derived->noInitializationNeeded()) {
                   stat = Initialize(
                       allocDesc, *derived, terminator, hasStat, errMsg);
                 }
               }
             }
           }
void Finalize(const Descriptor &descriptor,
   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 (const typeInfo::DerivedType *compType{comp.derivedType()}) {
         if (!compType->noFinalizationNeeded()) {
           for (std::size_t j{0}; j < elements; ++j) {
             const Descriptor &compDesc{*descriptor.OffsetElement<Descriptor>(
                 j * byteStride + comp.offset())};
             if (compDesc.IsAllocated()) {
               Finalize(compDesc, *compType, terminator);
             }
           }
if (comp.genre() == typeInfo::Component::Genre::Allocatable ||
         d->Deallocate();
         descriptor.IncrementSubscripts(at);
       }
     }
   }
 }
 
 bool HasDynamicComponent(const Descriptor &descriptor) {
-  if (const DescriptorAddendum * addendum{descriptor.Addendum()}) {
+  if (const DescriptorAddendum *addendum{descriptor.Addendum()}) {
     if (const auto *derived = addendum->derivedType()) {
       const Descriptor &componentDesc{derived->component()};
       std::size_t myComponents{componentDesc.Elements()};
       for (std::size_t k{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) {

flang/runtime/descriptor-io.h

if (const auto *definedIo{table->Find(*type,
                 DefinedFormattedIo(io, descriptor, *type, special)}) {
           return *wasDefined;
         }
       } else {
         return DefaultComponentwiseIO<DIR>(io, descriptor, *type, table);
       }
     }
   }
-  if (const typeInfo::SpecialBinding *
-      special{type->FindSpecialBinding(DIR == Direction::Input
+  if (const typeInfo::SpecialBinding *special{
+          type->FindSpecialBinding(DIR == Direction::Input
                   ? typeInfo::SpecialBinding::Which::ReadFormatted
                   : typeInfo::SpecialBinding::Which::WriteFormatted)}) {
     if (!table || !table->ignoreNonTbpEntries || special->isTypeBound()) {
       if (std::optional<bool> wasDefined{
               DefinedFormattedIo(io, descriptor, *type, *special)}) {
         return *wasDefined; // defined I/O was applied
       }
     }
   }
   return DefaultComponentwiseIO<DIR>(io, descriptor, *type, table);
 }
 
 bool DefinedUnformattedIo(IoStatementState &, const Descriptor &,
     const typeInfo::DerivedType &, const typeInfo::SpecialBinding &);
 
 // Unformatted I/O
 template <Direction DIR>
 static bool UnformattedDescriptorIO(IoStatementState &io,
     const Descriptor &descriptor, const NonTbpDefinedIoTable *table = nullptr) {
   IoErrorHandler &handler{io.GetIoErrorHandler()};
   const DescriptorAddendum *addendum{descriptor.Addendum()};
-  if (const typeInfo::DerivedType *
-      type{addendum ? addendum->derivedType() : nullptr}) {
+  if (const typeInfo::DerivedType *type{
+          addendum ? addendum->derivedType() : nullptr}) {
     // derived type unformatted I/O
     if (table) {
       if (const auto *definedIo{table->Find(*type,
               DIR == Direction::Input ? common::DefinedIo::ReadUnformatted
                                       : common::DefinedIo::WriteUnformatted)}) {
         if (definedIo->subroutine) {
           typeInfo::SpecialBinding special{DIR == Direction::Input
                   ? typeInfo::SpecialBinding::Which::ReadUnformatted
                   : typeInfo::SpecialBinding::Which::WriteUnformatted,
               definedIo->subroutine, definedIo->isDtvArgPolymorphic, false,
               false};
           if (std::optional<bool> wasDefined{
                   DefinedUnformattedIo(io, descriptor, *type, special)}) {
             return *wasDefined;
           }
         } else {
           return DefaultComponentwiseIO<DIR>(io, descriptor, *type, table);
         }
       }
     }
-    if (const typeInfo::SpecialBinding *
-        special{type->FindSpecialBinding(DIR == Direction::Input
+    if (const typeInfo::SpecialBinding *special{
+            type->FindSpecialBinding(DIR == Direction::Input
                     ? typeInfo::SpecialBinding::Which::ReadUnformatted
                     : typeInfo::SpecialBinding::Which::WriteUnformatted)}) {
       if (!table || !table->ignoreNonTbpEntries || special->isTypeBound()) {
         // defined derived type unformatted I/O
         return DefinedUnformattedIo(io, descriptor, *type, *special);
       }
     }
     // Default derived type unformatted I/O
     // TODO: If no component at any level has defined READ or WRITE
     // (as appropriate), the elements are contiguous, and no byte swapping

flang/runtime/descriptor.cpp

void Descriptor::Dump(FILE *f) const {
   for (int j{0}; j < raw_.rank; ++j) {
     std::fprintf(f, "  dim[%d] lower_bound %jd\n", j,
         static_cast<std::intmax_t>(raw_.dim[j].lower_bound));
     std::fprintf(f, "         extent      %jd\n",
         static_cast<std::intmax_t>(raw_.dim[j].extent));
     std::fprintf(f, "         sm          %jd\n",
         static_cast<std::intmax_t>(raw_.dim[j].sm));
   }
-  if (const DescriptorAddendum * addendum{Addendum()}) {
+  if (const DescriptorAddendum *addendum{Addendum()}) {
     addendum->Dump(f);
   }
 }
 
 DescriptorAddendum &DescriptorAddendum::operator=(
     const DescriptorAddendum &that) {
   derivedType_ = that.derivedType_;
   auto lenParms{that.LenParameters()};

flang/runtime/emit-encoded.h

 
 template <typename CONTEXT, typename CHAR>
 bool EmitEncoded(CONTEXT &to, const CHAR *data, std::size_t chars) {
   ConnectionState &connection{to.GetConnectionState()};
   if (connection.access == Access::Stream &&
       connection.internalIoCharKind == 0) {
     // Stream output: treat newlines as record advancements so that the left tab
     // limit is correctly managed
-    while (const CHAR * nl{FindCharacter(data, CHAR{'\n'}, chars)}) {
+    while (const CHAR *nl{FindCharacter(data, CHAR{'\n'}, chars)}) {
       auto pos{static_cast<std::size_t>(nl - data)};
       if (!EmitEncoded(to, data, pos)) {
         return false;
       }
       data += pos + 1;
       chars -= pos + 1;
       to.AdvanceRecord();
     }

flang/runtime/io-api.cpp

if (iostat != IostatOk) {
     cookie->GetIoErrorHandler().SetPendingError(iostat);
   }
   return cookie;
 }
 
 static ExternalFileUnit *GetOrCreateUnit(int unitNumber, Direction direction,
     std::optional<bool> isUnformatted, const Terminator &terminator,
     Cookie &errorCookie) {
-  if (ExternalFileUnit *
-      unit{ExternalFileUnit::LookUpOrCreateAnonymous(
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUpOrCreateAnonymous(
           unitNumber, direction, isUnformatted, terminator)}) {
     errorCookie = nullptr;
     return unit;
   } else {
     errorCookie = NoopUnit(terminator, unitNumber, IostatBadUnitNumber);
     return nullptr;
   }
 }
Cookie BeginExternalListIO(
   }
   if (!unit->isUnformatted.has_value()) {
     unit->isUnformatted = false;
   }
   Iostat iostat{IostatOk};
   if (*unit->isUnformatted) {
     iostat = IostatFormattedIoOnUnformattedUnit;
   }
-  if (ChildIo * child{unit->GetChildIo()}) {
+  if (ChildIo *child{unit->GetChildIo()}) {
     if (iostat == IostatOk) {
       iostat = child->CheckFormattingAndDirection(false, DIR);
     }
     if (iostat == IostatOk) {
       return &child->BeginIoStatement<ChildListIoStatementState<DIR>>(
           *child, sourceFile, sourceLine);
     } else {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
Cookie BeginExternalFormattedIO(const char *format, std::size_t formatLength,
   }
   Iostat iostat{IostatOk};
   if (!unit->isUnformatted.has_value()) {
     unit->isUnformatted = false;
   }
   if (*unit->isUnformatted) {
     iostat = IostatFormattedIoOnUnformattedUnit;
   }
-  if (ChildIo * child{unit->GetChildIo()}) {
+  if (ChildIo *child{unit->GetChildIo()}) {
     if (iostat == IostatOk) {
       iostat = child->CheckFormattingAndDirection(false, DIR);
     }
     if (iostat == IostatOk) {
       return &child->BeginIoStatement<ChildFormattedIoStatementState<DIR>>(
           *child, format, formatLength, formatDescriptor, sourceFile,
           sourceLine);
     } else {
Cookie BeginUnformattedIO(
   }
   Iostat iostat{IostatOk};
   if (!unit->isUnformatted.has_value()) {
     unit->isUnformatted = true;
   }
   if (!*unit->isUnformatted) {
     iostat = IostatUnformattedIoOnFormattedUnit;
   }
-  if (ChildIo * child{unit->GetChildIo()}) {
+  if (ChildIo *child{unit->GetChildIo()}) {
     if (iostat == IostatOk) {
       iostat = child->CheckFormattingAndDirection(true, DIR);
     }
     if (iostat == IostatOk) {
       return &child->BeginIoStatement<ChildUnformattedIoStatementState<DIR>>(
           *child, sourceFile, sourceLine);
     } else {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
Cookie IONAME(BeginUnformattedInput)(
   return BeginUnformattedIO<Direction::Input>(
       unitNumber, sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginOpenUnit)( // OPEN(without NEWUNIT=)
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   bool wasExtant{false};
-  if (ExternalFileUnit *
-      unit{ExternalFileUnit::LookUpOrCreate(
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUpOrCreate(
           unitNumber, terminator, wasExtant)}) {
-    if (ChildIo * child{unit->GetChildIo()}) {
+    if (ChildIo *child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
           sourceLine);
     } else {
       return &unit->BeginIoStatement<OpenStatementState>(terminator, *unit,
           wasExtant, false /*not NEWUNIT=*/, sourceFile, sourceLine);
     }
   } else {
Cookie IONAME(BeginOpenNewUnit)( // OPEN(NEWUNIT=j)
   return &unit.BeginIoStatement<OpenStatementState>(terminator, unit,
       false /*was an existing file*/, true /*NEWUNIT=*/, sourceFile,
       sourceLine);
 }
 
 Cookie IONAME(BeginWait)(ExternalUnit unitNumber, AsynchronousId id,
     const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUp(unitNumber)}) {
     if (unit->Wait(id)) {
       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
           *unit, ExternalMiscIoStatementState::Wait, sourceFile, sourceLine);
     } else {
       return &unit->BeginIoStatement<ErroneousIoStatementState>(
           terminator, IostatBadWaitId, unit, sourceFile, sourceLine);
     }
   } else {
     return NoopUnit(
         terminator, unitNumber, id == 0 ? IostatOk : IostatBadWaitUnit);
   }
 }
 Cookie IONAME(BeginWaitAll)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   return IONAME(BeginWait)(unitNumber, 0 /*no ID=*/, sourceFile, sourceLine);
 }
 
 Cookie IONAME(BeginClose)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
-    if (ChildIo * child{unit->GetChildIo()}) {
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUp(unitNumber)}) {
+    if (ChildIo *child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
           sourceLine);
     }
   }
-  if (ExternalFileUnit * unit{ExternalFileUnit::LookUpForClose(unitNumber)}) {
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUpForClose(unitNumber)}) {
     return &unit->BeginIoStatement<CloseStatementState>(
         terminator, *unit, sourceFile, sourceLine);
   } else {
     // CLOSE(UNIT=bad unit) is just a no-op
     return NoopUnit(terminator, unitNumber);
   }
 }
 
 Cookie IONAME(BeginFlush)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
-    if (ChildIo * child{unit->GetChildIo()}) {
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUp(unitNumber)}) {
+    if (ChildIo *child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<ExternalMiscIoStatementState>(
           *unit, ExternalMiscIoStatementState::Flush, sourceFile, sourceLine);
     } else {
       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
           *unit, ExternalMiscIoStatementState::Flush, sourceFile, sourceLine);
     }
   } else {
     // FLUSH(UNIT=bad unit) is an error; an unconnected unit is a no-op
     return NoopUnit(terminator, unitNumber,
         unitNumber >= 0 ? IostatOk : IostatBadFlushUnit);
   }
 }
 
 Cookie IONAME(BeginBackspace)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
-    if (ChildIo * child{unit->GetChildIo()}) {
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUp(unitNumber)}) {
+    if (ChildIo *child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
           sourceLine);
     } else {
       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
           *unit, ExternalMiscIoStatementState::Backspace, sourceFile,
           sourceLine);
     }
   } else {
     return NoopUnit(terminator, unitNumber, IostatBadBackspaceUnit);
   }
 }
 
 Cookie IONAME(BeginEndfile)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   Cookie errorCookie{nullptr};
-  if (ExternalFileUnit *
-      unit{GetOrCreateUnit(unitNumber, Direction::Output, std::nullopt,
-          terminator, errorCookie)}) {
-    if (ChildIo * child{unit->GetChildIo()}) {
+  if (ExternalFileUnit *unit{GetOrCreateUnit(unitNumber, Direction::Output,
+          std::nullopt, terminator, errorCookie)}) {
+    if (ChildIo *child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
           sourceLine);
     } else {
       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
           *unit, ExternalMiscIoStatementState::Endfile, sourceFile, sourceLine);
     }
   } else {
     return errorCookie;
   }
 }
 
 Cookie IONAME(BeginRewind)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   Cookie errorCookie{nullptr};
-  if (ExternalFileUnit *
-      unit{GetOrCreateUnit(unitNumber, Direction::Input, std::nullopt,
-          terminator, errorCookie)}) {
-    if (ChildIo * child{unit->GetChildIo()}) {
+  if (ExternalFileUnit *unit{GetOrCreateUnit(unitNumber, Direction::Input,
+          std::nullopt, terminator, errorCookie)}) {
+    if (ChildIo *child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<ErroneousIoStatementState>(
           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
           sourceLine);
     } else {
       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
           *unit, ExternalMiscIoStatementState::Rewind, sourceFile, sourceLine);
     }
   } else {
     return errorCookie;
   }
 }
 
 Cookie IONAME(BeginInquireUnit)(
     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
-  if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
-    if (ChildIo * child{unit->GetChildIo()}) {
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUp(unitNumber)}) {
+    if (ChildIo *child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<InquireUnitState>(
           *unit, sourceFile, sourceLine);
     } else {
       return &unit->BeginIoStatement<InquireUnitState>(
           terminator, *unit, sourceFile, sourceLine);
     }
   } else {
     // INQUIRE(UNIT=unrecognized unit)
     return &New<InquireNoUnitState>{terminator}(
         sourceFile, sourceLine, unitNumber)
                 .release()
                 ->ioStatementState();
   }
 }
 
 Cookie IONAME(BeginInquireFile)(const char *path, std::size_t pathLength,
     const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   auto trimmed{SaveDefaultCharacter(
       path, TrimTrailingSpaces(path, pathLength), terminator)};
-  if (ExternalFileUnit *
-      unit{ExternalFileUnit::LookUp(
+  if (ExternalFileUnit *unit{ExternalFileUnit::LookUp(
           trimmed.get(), std::strlen(trimmed.get()))}) {
     // INQUIRE(FILE=) to a connected unit
-    if (ChildIo * child{unit->GetChildIo()}) {
+    if (ChildIo *child{unit->GetChildIo()}) {
       return &child->BeginIoStatement<InquireUnitState>(
           *unit, sourceFile, sourceLine);
     } else {
       return &unit->BeginIoStatement<InquireUnitState>(
           terminator, *unit, sourceFile, sourceLine);
     }
   } else {
     return &New<InquireUnconnectedFileState>{terminator}(

flang/runtime/io-stmt.cpp

 }
 
 template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     Buffer buffer, std::size_t length, const CharType *format,
     std::size_t formatLength, const Descriptor *formatDescriptor,
     const char *sourceFile, int sourceLine)
     : InternalIoStatementState<DIR>{buffer, length, sourceFile, sourceLine},
-      ioStatementState_{*this}, format_{*this, format, formatLength,
-                                    formatDescriptor} {}
+      ioStatementState_{*this},
+      format_{*this, format, formatLength, formatDescriptor} {}
 
 template <Direction DIR, typename CHAR>
 InternalFormattedIoStatementState<DIR, CHAR>::InternalFormattedIoStatementState(
     const Descriptor &d, const CharType *format, std::size_t formatLength,
     const Descriptor *formatDescriptor, const char *sourceFile, int sourceLine)
     : InternalIoStatementState<DIR>{d, sourceFile, sourceLine},
-      ioStatementState_{*this}, format_{*this, format, formatLength,
-                                    formatDescriptor} {}
+      ioStatementState_{*this},
+      format_{*this, format, formatLength, formatDescriptor} {}
 
 template <Direction DIR, typename CHAR>
 void InternalFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
   if (!this->completedOperation()) {
     if constexpr (DIR == Direction::Output) {
       format_.Finish(*this); // ignore any remaining input positioning actions
     }
     IoStatementBase::CompleteOperation();
InternalListIoStatementState<DIR>::InternalListIoStatementState(
     : InternalIoStatementState<DIR>{d, sourceFile, sourceLine},
       ioStatementState_{*this} {}
 
 ExternalIoStatementBase::ExternalIoStatementBase(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
     : IoStatementBase{sourceFile, sourceLine}, unit_{unit} {}
 
 MutableModes &ExternalIoStatementBase::mutableModes() {
-  if (const ChildIo * child{unit_.GetChildIo()}) {
+  if (const ChildIo *child{unit_.GetChildIo()}) {
     return child->parent().mutableModes();
   }
   return unit_.modes;
 }
 
 ConnectionState &ExternalIoStatementBase::GetConnectionState() { return unit_; }
 
 int ExternalIoStatementBase::EndIoStatement() {
int NoUnitIoStatementState::EndIoStatement() {
   auto result{IoStatementBase::EndIoStatement()};
   FreeMemory(this);
   return result;
 }
 
 template <Direction DIR>
 ExternalIoStatementState<DIR>::ExternalIoStatementState(
     ExternalFileUnit &unit, const char *sourceFile, int sourceLine)
-    : ExternalIoStatementBase{unit, sourceFile, sourceLine}, mutableModes_{
-                                                                 unit.modes} {
+    : ExternalIoStatementBase{unit, sourceFile, sourceLine},
+      mutableModes_{unit.modes} {
   if constexpr (DIR == Direction::Output) {
     // If the last statement was a non-advancing IO input statement, the unit
     // furthestPositionInRecord was not advanced, but the positionInRecord may
     // have been advanced. Advance furthestPositionInRecord here to avoid
     // overwriting the part of the record that has been read with blanks.
     unit.furthestPositionInRecord =
         std::max(unit.furthestPositionInRecord, unit.positionInRecord);
   }
void ChildIoStatementState<DIR>::HandleRelativePosition(std::int64_t n) {
   return child_.parent().HandleRelativePosition(n);
 }
 
 template <Direction DIR, typename CHAR>
 ChildFormattedIoStatementState<DIR, CHAR>::ChildFormattedIoStatementState(
     ChildIo &child, const CHAR *format, std::size_t formatLength,
     const Descriptor *formatDescriptor, const char *sourceFile, int sourceLine)
     : ChildIoStatementState<DIR>{child, sourceFile, sourceLine},
-      mutableModes_{child.parent().mutableModes()}, format_{*this, format,
-                                                        formatLength,
-                                                        formatDescriptor} {}
+      mutableModes_{child.parent().mutableModes()},
+      format_{*this, format, formatLength, formatDescriptor} {}
 
 template <Direction DIR, typename CHAR>
 void ChildFormattedIoStatementState<DIR, CHAR>::CompleteOperation() {
   if (!this->completedOperation()) {
     format_.Finish(*this);
     ChildIoStatementState<DIR>::CompleteOperation();
   }
 }
bool InquireNoUnitState::Inquire(
   default:
     BadInquiryKeywordHashCrash(inquiry);
     return false;
   }
 }
 
 InquireUnconnectedFileState::InquireUnconnectedFileState(
     OwningPtr<char> &&path, const char *sourceFile, int sourceLine)
-    : NoUnitIoStatementState{*this, sourceFile, sourceLine}, path_{std::move(
-                                                                 path)} {}
+    : NoUnitIoStatementState{*this, sourceFile, sourceLine},
+      path_{std::move(path)} {}
 
 bool InquireUnconnectedFileState::Inquire(
     InquiryKeywordHash inquiry, char *result, std::size_t length) {
   const char *str{nullptr};
   switch (inquiry) {
   case HashInquiryKeyword("ACCESS"):
   case HashInquiryKeyword("ACTION"):
   case HashInquiryKeyword("ASYNCHRONOUS"):

flang/runtime/misc-intrinsic.cpp

static void TransferImpl(Descriptor &result, const Descriptor &source,
     std::optional<std::int64_t> resultExtent) {
   int rank{resultExtent.has_value() ? 1 : 0};
   std::size_t elementBytes{mold.ElementBytes()};
   result.Establish(mold.type(), elementBytes, nullptr, rank, nullptr,
       CFI_attribute_allocatable, mold.Addendum() != nullptr);
   if (resultExtent) {
     result.GetDimension(0).SetBounds(1, *resultExtent);
   }
-  if (const DescriptorAddendum * addendum{mold.Addendum()}) {
+  if (const DescriptorAddendum *addendum{mold.Addendum()}) {
     *result.Addendum() = *addendum;
   }
   if (int stat{result.Allocate()}) {
     Terminator{sourceFile, line}.Crash(
         "TRANSFER: could not allocate memory for result; STAT=%d", stat);
   }
   char *to{result.OffsetElement<char>()};
   std::size_t resultBytes{result.Elements() * result.ElementBytes()};

flang/runtime/namelist.cpp

 }
 
 static bool HandleComponent(IoStatementState &io, Descriptor &desc,
     const Descriptor &source, const char *name) {
   IoErrorHandler &handler{io.GetIoErrorHandler()};
   char compName[nameBufferSize];
   if (GetLowerCaseName(io, compName, sizeof compName)) {
     const DescriptorAddendum *addendum{source.Addendum()};
-    if (const typeInfo::DerivedType *
-        type{addendum ? addendum->derivedType() : nullptr}) {
-      if (const typeInfo::Component *
-          comp{type->FindDataComponent(compName, std::strlen(compName))}) {
+    if (const typeInfo::DerivedType *type{
+            addendum ? addendum->derivedType() : nullptr}) {
+      if (const typeInfo::Component *comp{
+              type->FindDataComponent(compName, std::strlen(compName))}) {
         bool createdDesc{false};
         if (comp->rank() > 0 && source.rank() > 0) {
           // If base and component are both arrays, the component name
           // must be followed by subscripts; process them now.
           std::size_t byteCount{0};
           if (std::optional<char32_t> next{io.GetNextNonBlank(byteCount)};
               next && *next == '(') {
             io.HandleRelativePosition(byteCount); // skip over '('

flang/runtime/numeric.cpp

template <typename BTy, typename ETy> BTy FPowI(BTy base, ETy exp) {
   if (isMinPower) {
     exp = std::numeric_limits<ETy>::max();
   } else if (isNegativePower) {
     exp = -exp;
   }
   BTy result{1};
   BTy origBase{base};
   while (true) {
-    if (exp & ETy{1}) {
+    if (exp &ETy{1}) {
       result *= base;
     }
     exp >>= 1;
     if (exp == ETy{0}) {
       break;
     }
     base *= base;
   }

flang/runtime/pointer.cpp

 int RTNAME(PointerAllocate)(Descriptor &pointer, bool hasStat,
     const Descriptor *errMsg, const char *sourceFile, int sourceLine) {
   Terminator terminator{sourceFile, sourceLine};
   if (!pointer.IsPointer()) {
     return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);
   }
   int stat{ReturnError(terminator, pointer.Allocate(), errMsg, hasStat)};
   if (stat == StatOk) {
-    if (const DescriptorAddendum * addendum{pointer.Addendum()}) {
+    if (const DescriptorAddendum *addendum{pointer.Addendum()}) {
       if (const auto *derived{addendum->derivedType()}) {
         if (!derived->noInitializationNeeded()) {
           stat = Initialize(pointer, *derived, terminator, hasStat, errMsg);
         }
       }
     }
   }
   return stat;

flang/runtime/type-info.cpp

case TypeCategory::Derived:
     break;
   }
   return 0;
 }
 
 std::size_t Component::GetElements(const Descriptor &instance) const {
   std::size_t elements{1};
   if (int rank{rank_}) {
-    if (const Value * boundValues{bounds()}) {
+    if (const Value *boundValues{bounds()}) {
       for (int j{0}; j < rank; ++j) {
         TypeParameterValue lb{
             boundValues[2 * j].GetValue(&instance).value_or(0)};
         TypeParameterValue ub{
             boundValues[2 * j + 1].GetValue(&instance).value_or(0)};
         if (ub >= lb) {
           elements *= ub - lb + 1;
         } else {
if (auto length{characterLen_.GetValue(&container)}) {
       lengthInChars = static_cast<std::size_t>(*length);
     } else {
       RUNTIME_CHECK(
           terminator, characterLen_.genre() == Value::Genre::Deferred);
     }
     descriptor.Establish(
         kind_, lengthInChars, nullptr, rank_, nullptr, attribute);
   } else if (cat == TypeCategory::Derived) {
-    if (const DerivedType * type{derivedType()}) {
+    if (const DerivedType *type{derivedType()}) {
       descriptor.Establish(*type, nullptr, rank_, nullptr, attribute);
     } else { // unlimited polymorphic
       descriptor.Establish(TypeCode{TypeCategory::Derived, 0}, 0, nullptr,
           rank_, nullptr, attribute, true);
     }
   } else {
     descriptor.Establish(cat, kind_, nullptr, rank_, nullptr, attribute);
   }

flang/runtime/unit-map.cpp

 
 void UnitMap::CloseAll(IoErrorHandler &handler) {
   // Extract units from the map so they can be closed
   // without holding lock_.
   OwningPtr<Chain> closeList;
   {
     CriticalSection critical{lock_};
     for (int j{0}; j < buckets_; ++j) {
-      while (Chain * p{bucket_[j].get()}) {
+      while (Chain *p{bucket_[j].get()}) {
         bucket_[j].swap(p->next); // pops p from head of bucket list
         closeList.swap(p->next); // pushes p to closeList
       }
     }
   }
-  while (Chain * p{closeList.get()}) {
+  while (Chain *p{closeList.get()}) {
     closeList.swap(p->next); // pops p from head of closeList
     p->unit.CloseUnit(CloseStatus::Keep, handler);
     p->unit.~ExternalFileUnit();
     FreeMemory(p);
   }
 }
 
 void UnitMap::FlushAll(IoErrorHandler &handler) {

flang/tools/fir-opt/fir-opt.cpp

int main(int argc, char **argv) {
   fir::registerOptCodeGenPasses();
   fir::registerOptTransformPasses();
   hlfir::registerHLFIRPasses();
 #ifdef FLANG_INCLUDE_TESTS
   fir::test::registerTestFIRAliasAnalysisPass();
 #endif
   DialectRegistry registry;
   fir::support::registerDialects(registry);
-  return failed(MlirOptMain(argc, argv, "FIR modular optimizer driver\n",
-      registry));
+  return failed(
+      MlirOptMain(argc, argv, "FIR modular optimizer driver\n", registry));
 }

flang/unittests/Optimizer/InternalNamesTest.cpp

 using llvm::SmallVector;
 using llvm::StringRef;
 
 struct DeconstructedName {
   DeconstructedName(llvm::StringRef name) : name{name} {}
   DeconstructedName(llvm::ArrayRef<std::string> modules,
       llvm::ArrayRef<std::string> procs, std::int64_t blockId,
       llvm::StringRef name, llvm::ArrayRef<std::int64_t> kinds)
-      : modules{modules.begin(), modules.end()}, procs{procs.begin(),
-                                                     procs.end()},
-        blockId{blockId}, name{name}, kinds{kinds.begin(), kinds.end()} {}
+      : modules{modules.begin(), modules.end()},
+        procs{procs.begin(), procs.end()}, blockId{blockId}, name{name},
+        kinds{kinds.begin(), kinds.end()} {}
 
   bool isObjEqual(const NameUniquer::DeconstructedName &actualObj) {
     return actualObj.modules == modules && actualObj.procs == procs &&
         actualObj.blockId == blockId && actualObj.name == name &&
         actualObj.kinds == kinds;
   }
 
   llvm::SmallVector<std::string> modules;

flang/unittests/Runtime/Transformational.cpp

using BesselFuncType = std::function<void(Descriptor &, int32_t, int32_t,
     CppTypeFor<TypeCategory::Real, KIND>, CppTypeFor<TypeCategory::Real, KIND>,
     CppTypeFor<TypeCategory::Real, KIND>, const char *, int)>;
 
 template <int KIND>
 using BesselX0FuncType =
     std::function<void(Descriptor &, int32_t, int32_t, const char *, int)>;
 
 template <int KIND>
-constexpr CppTypeFor<TypeCategory::Real, KIND>
-    besselEpsilon = CppTypeFor<TypeCategory::Real, KIND>(1e-4);
+constexpr CppTypeFor<TypeCategory::Real, KIND> besselEpsilon =
+    CppTypeFor<TypeCategory::Real, KIND>(1e-4);
 
 template <int KIND>
 static void testBesselJn(BesselFuncType<KIND> rtFunc, int32_t n1, int32_t n2,
     CppTypeFor<TypeCategory::Real, KIND> x,
     const std::vector<CppTypeFor<TypeCategory::Real, KIND>> &expected) {
   StaticDescriptor<1> desc;
   Descriptor &result{desc.descriptor()};
   unsigned len = expected.size();