/build/source/flang/lib/Semantics/resolve-names.cpp

Bug Summary

File:	build/source/flang/lib/Semantics/resolve-names.cpp
Warning:	line 5081, column 32 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name resolve-names.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -isystem /build/source/llvm/../mlir/include -isystem tools/mlir/include -isystem tools/clang/include -isystem /build/source/llvm/../clang/include -I tools/flang/lib/Semantics -I /build/source/flang/lib/Semantics -I /build/source/flang/include -I tools/flang/include -I include -I /build/source/llvm/include -D FLANG_INCLUDE_TESTS=1 -D FLANG_LITTLE_ENDIAN=1 -D FLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1675289259 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -Wno-deprecated-copy -Wno-ctad-maybe-unsupported -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-02-02-055145-558594-1 -x c++ /build/source/flang/lib/Semantics/resolve-names.cpp

/build/source/flang/lib/Semantics/resolve-names.cpp

→

1//===-- lib/Semantics/resolve-names.cpp -----------------------------------===//
2// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
3// See https://llvm.org/LICENSE.txt for license information.
4// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
5//
6//===----------------------------------------------------------------------===//

8#include "resolve-names.h"
9#include "assignment.h"
10#include "definable.h"
11#include "mod-file.h"
12#include "pointer-assignment.h"
13#include "program-tree.h"
14#include "resolve-directives.h"
15#include "resolve-names-utils.h"
16#include "rewrite-parse-tree.h"
17#include "flang/Common/Fortran.h"
18#include "flang/Common/default-kinds.h"
19#include "flang/Common/indirection.h"
20#include "flang/Common/restorer.h"
21#include "flang/Common/visit.h"
22#include "flang/Evaluate/characteristics.h"
23#include "flang/Evaluate/check-expression.h"
24#include "flang/Evaluate/common.h"
25#include "flang/Evaluate/fold-designator.h"
26#include "flang/Evaluate/fold.h"
27#include "flang/Evaluate/intrinsics.h"
28#include "flang/Evaluate/tools.h"
29#include "flang/Evaluate/type.h"
30#include "flang/Parser/parse-tree-visitor.h"
31#include "flang/Parser/parse-tree.h"
32#include "flang/Parser/tools.h"
33#include "flang/Semantics/attr.h"
34#include "flang/Semantics/expression.h"
35#include "flang/Semantics/scope.h"
36#include "flang/Semantics/semantics.h"
37#include "flang/Semantics/symbol.h"
38#include "flang/Semantics/tools.h"
39#include "flang/Semantics/type.h"
40#include "llvm/Support/raw_ostream.h"
41#include <list>
42#include <map>
43#include <set>
44#include <stack>

46namespace Fortran::semantics {

48using namespace parser::literals;

50template <typename T> using Indirection = common::Indirection<T>;
51using Message = parser::Message;
52using Messages = parser::Messages;
53using MessageFixedText = parser::MessageFixedText;
54using MessageFormattedText = parser::MessageFormattedText;

56class ResolveNamesVisitor;
57class ScopeHandler;

59// ImplicitRules maps initial character of identifier to the DeclTypeSpec
60// representing the implicit type; std::nullopt if none.
61// It also records the presence of IMPLICIT NONE statements.
62// When inheritFromParent is set, defaults come from the parent rules.
63class ImplicitRules {
64public:
ImplicitRules(SemanticsContext &context, ImplicitRules *parent)
    : parent_{parent}, context_{context} {
  inheritFromParent_ = parent != nullptr;
}
bool isImplicitNoneType() const;
bool isImplicitNoneExternal() const;
void set_isImplicitNoneType(bool x) { isImplicitNoneType_ = x; }
void set_isImplicitNoneExternal(bool x) { isImplicitNoneExternal_ = x; }
void set_inheritFromParent(bool x) { inheritFromParent_ = x; }
// Get the implicit type for this name. May be null.
const DeclTypeSpec *GetType(
    SourceName, bool respectImplicitNone = true) const;
// Record the implicit type for the range of characters [fromLetter,
// toLetter].
void SetTypeMapping(const DeclTypeSpec &type, parser::Location fromLetter,
    parser::Location toLetter);

82private:
static char Incr(char ch);

ImplicitRules *parent_;
SemanticsContext &context_;
bool inheritFromParent_{false}; // look in parent if not specified here
bool isImplicitNoneType_{
    context_.IsEnabled(common::LanguageFeature::ImplicitNoneTypeAlways)};
bool isImplicitNoneExternal_{false};
// map_ contains the mapping between letters and types that were defined
// by the IMPLICIT statements of the related scope. It does not contain
// the default Fortran mappings nor the mapping defined in parents.
std::map<char, common::Reference<const DeclTypeSpec>> map_;

friend llvm::raw_ostream &operator<<(
    llvm::raw_ostream &, const ImplicitRules &);
friend void ShowImplicitRule(
    llvm::raw_ostream &, const ImplicitRules &, char);
100};

102// scope -> implicit rules for that scope
103using ImplicitRulesMap = std::map<const Scope *, ImplicitRules>;

105// Track statement source locations and save messages.
106class MessageHandler {
107public:
MessageHandler() { DIE("MessageHandler: default-constructed")Fortran::common::die("MessageHandler: default-constructed" " at "
 "flang/lib/Semantics/resolve-names.cpp" "(%d)", 108); }
explicit MessageHandler(SemanticsContext &c) : context_{&c} {}
Messages &messages() { return context_->messages(); };
const std::optional<SourceName> &currStmtSource() {
  return context_->location();
}
void set_currStmtSource(const std::optional<SourceName> &source) {
  context_->set_location(source);
}

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

129private:
SemanticsContext *context_;
131};

133// Inheritance graph for the parse tree visitation classes that follow:
134//   BaseVisitor
135//   + AttrsVisitor
136//   | + DeclTypeSpecVisitor
137//   |   + ImplicitRulesVisitor
138//   |     + ScopeHandler -----------+--+
139//   |       + ModuleVisitor ========|==+
140//   |       + InterfaceVisitor      |  |
141//   |       +-+ SubprogramVisitor ==|==+
142//   + ArraySpecVisitor              |  |
143//     + DeclarationVisitor <--------+  |
144//       + ConstructVisitor             |
145//         + ResolveNamesVisitor <------+

147class BaseVisitor {
148public:
BaseVisitor() { DIE("BaseVisitor: default-constructed")Fortran::common::die("BaseVisitor: default-constructed" " at "
 "flang/lib/Semantics/resolve-names.cpp" "(%d)", 149); }
BaseVisitor(
    SemanticsContext &c, ResolveNamesVisitor &v, ImplicitRulesMap &rules)
    : implicitRulesMap_{&rules}, this_{&v}, context_{&c}, messageHandler_{c} {
}
template <typename T> void Walk(const T &);

MessageHandler &messageHandler() { return messageHandler_; }
const std::optional<SourceName> &currStmtSource() {
  return context_->location();
}
SemanticsContext &context() const { return *context_; }
evaluate::FoldingContext &GetFoldingContext() const {
  return context_->foldingContext();
}
bool IsIntrinsic(
    const SourceName &name, std::optional<Symbol::Flag> flag) const {
  if (!flag) {
    return context_->intrinsics().IsIntrinsic(name.ToString());
  } else if (flag == Symbol::Flag::Function) {
    return context_->intrinsics().IsIntrinsicFunction(name.ToString());
  } else if (flag == Symbol::Flag::Subroutine) {
    return context_->intrinsics().IsIntrinsicSubroutine(name.ToString());
  } else {
    DIE("expected Subroutine or Function flag")Fortran::common::die("expected Subroutine or Function flag" " at "
 "flang/lib/Semantics/resolve-names.cpp" "(%d)", 173);
  }
}

bool InModuleFile() const { return GetFoldingContext().inModuleFile(); }

// Make a placeholder symbol for a Name that otherwise wouldn't have one.
// It is not in any scope and always has MiscDetails.
void MakePlaceholder(const parser::Name &, MiscDetails::Kind);

template <typename T> common::IfNoLvalue<T, T> FoldExpr(T &&expr) {
  return evaluate::Fold(GetFoldingContext(), std::move(expr));
}

template <typename T> MaybeExpr EvaluateExpr(const T &expr) {
  return FoldExpr(AnalyzeExpr(*context_, expr));
}

template <typename T>
MaybeExpr EvaluateNonPointerInitializer(
    const Symbol &symbol, const T &expr, parser::CharBlock source) {
  if (!context().HasError(symbol)) {
    if (auto maybeExpr{AnalyzeExpr(*context_, expr)}) {
      auto restorer{GetFoldingContext().messages().SetLocation(source)};
      return evaluate::NonPointerInitializationExpr(
          symbol, std::move(*maybeExpr), GetFoldingContext());
    }
  }
  return std::nullopt;
}

template <typename T> MaybeIntExpr EvaluateIntExpr(const T &expr) {
  return semantics::EvaluateIntExpr(*context_, expr);
}

template <typename T>
MaybeSubscriptIntExpr EvaluateSubscriptIntExpr(const T &expr) {
  if (MaybeIntExpr maybeIntExpr{EvaluateIntExpr(expr)}) {
    return FoldExpr(evaluate::ConvertToType<evaluate::SubscriptInteger>(
        std::move(*maybeIntExpr)));
  } else {
    return std::nullopt;
  }
}

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

227protected:
ImplicitRulesMap *implicitRulesMap_{nullptr};

230private:
ResolveNamesVisitor *this_;
SemanticsContext *context_;
MessageHandler messageHandler_;
234};

236// Provide Post methods to collect attributes into a member variable.
237class AttrsVisitor : public virtual BaseVisitor {
238public:
bool BeginAttrs(); // always returns true
Attrs GetAttrs();
Attrs EndAttrs();
bool SetPassNameOn(Symbol &);
void SetBindNameOn(Symbol &);
void Post(const parser::LanguageBindingSpec &);
bool Pre(const parser::IntentSpec &);
bool Pre(const parser::Pass &);

bool CheckAndSet(Attr);

250// Simple case: encountering CLASSNAME causes ATTRNAME to be set.
251#define HANDLE_ATTR_CLASS(CLASSNAME, ATTRNAME) \
bool Pre(const parser::CLASSNAME &) { \
  CheckAndSet(Attr::ATTRNAME); \
  return false; \
}
HANDLE_ATTR_CLASS(PrefixSpec::Elemental, ELEMENTAL)
HANDLE_ATTR_CLASS(PrefixSpec::Impure, IMPURE)
HANDLE_ATTR_CLASS(PrefixSpec::Module, MODULE)
HANDLE_ATTR_CLASS(PrefixSpec::Non_Recursive, NON_RECURSIVE)
HANDLE_ATTR_CLASS(PrefixSpec::Pure, PURE)
HANDLE_ATTR_CLASS(PrefixSpec::Recursive, RECURSIVE)
HANDLE_ATTR_CLASS(TypeAttrSpec::BindC, BIND_C)
HANDLE_ATTR_CLASS(BindAttr::Deferred, DEFERRED)
HANDLE_ATTR_CLASS(BindAttr::Non_Overridable, NON_OVERRIDABLE)
HANDLE_ATTR_CLASS(Abstract, ABSTRACT)
HANDLE_ATTR_CLASS(Allocatable, ALLOCATABLE)
HANDLE_ATTR_CLASS(Asynchronous, ASYNCHRONOUS)
HANDLE_ATTR_CLASS(Contiguous, CONTIGUOUS)
HANDLE_ATTR_CLASS(External, EXTERNAL)
HANDLE_ATTR_CLASS(Intrinsic, INTRINSIC)
HANDLE_ATTR_CLASS(NoPass, NOPASS)
HANDLE_ATTR_CLASS(Optional, OPTIONAL)
HANDLE_ATTR_CLASS(Parameter, PARAMETER)
HANDLE_ATTR_CLASS(Pointer, POINTER)
HANDLE_ATTR_CLASS(Protected, PROTECTED)
HANDLE_ATTR_CLASS(Save, SAVE)
HANDLE_ATTR_CLASS(Target, TARGET)
HANDLE_ATTR_CLASS(Value, VALUE)
HANDLE_ATTR_CLASS(Volatile, VOLATILE)
280#undef HANDLE_ATTR_CLASS

282protected:
std::optional<Attrs> attrs_;

Attr AccessSpecToAttr(const parser::AccessSpec &x) {
  switch (x.v) {
  case parser::AccessSpec::Kind::Public:
    return Attr::PUBLIC;
  case parser::AccessSpec::Kind::Private:
    return Attr::PRIVATE;
  }
  llvm_unreachable("Switch covers all cases")::llvm::llvm_unreachable_internal("Switch covers all cases", "flang/lib/Semantics/resolve-names.cpp"
, 292); // suppress g++ warning
}
Attr IntentSpecToAttr(const parser::IntentSpec &x) {
  switch (x.v) {
  case parser::IntentSpec::Intent::In:
    return Attr::INTENT_IN;
  case parser::IntentSpec::Intent::Out:
    return Attr::INTENT_OUT;
  case parser::IntentSpec::Intent::InOut:
    return Attr::INTENT_INOUT;
  }
  llvm_unreachable("Switch covers all cases")::llvm::llvm_unreachable_internal("Switch covers all cases", "flang/lib/Semantics/resolve-names.cpp"
, 303); // suppress g++ warning
}

306private:
bool IsDuplicateAttr(Attr);
bool HaveAttrConflict(Attr, Attr, Attr);
bool IsConflictingAttr(Attr);

MaybeExpr bindName_; // from BIND(C, NAME="...")
std::optional<SourceName> passName_; // from PASS(...)
313};

315// Find and create types from declaration-type-spec nodes.
316class DeclTypeSpecVisitor : public AttrsVisitor {
317public:
using AttrsVisitor::Post;
using AttrsVisitor::Pre;
void Post(const parser::IntrinsicTypeSpec::DoublePrecision &);
void Post(const parser::IntrinsicTypeSpec::DoubleComplex &);
void Post(const parser::DeclarationTypeSpec::ClassStar &);
void Post(const parser::DeclarationTypeSpec::TypeStar &);
bool Pre(const parser::TypeGuardStmt &);
void Post(const parser::TypeGuardStmt &);
void Post(const parser::TypeSpec &);

// Walk the parse tree of a type spec and return the DeclTypeSpec for it.
template <typename T>
const DeclTypeSpec *ProcessTypeSpec(const T &x, bool allowForward = false) {
  auto restorer{common::ScopedSet(state_, State{})};
  set_allowForwardReferenceToDerivedType(allowForward);
  BeginDeclTypeSpec();
  Walk(x);
  const auto *type{GetDeclTypeSpec()};
  EndDeclTypeSpec();
  return type;
}

340protected:
struct State {
  bool expectDeclTypeSpec{false}; // should see decl-type-spec only when true
  const DeclTypeSpec *declTypeSpec{nullptr};
  struct {
    DerivedTypeSpec *type{nullptr};
    DeclTypeSpec::Category category{DeclTypeSpec::TypeDerived};
  } derived;
  bool allowForwardReferenceToDerivedType{false};
};

bool allowForwardReferenceToDerivedType() const {
  return state_.allowForwardReferenceToDerivedType;
}
void set_allowForwardReferenceToDerivedType(bool yes) {
  state_.allowForwardReferenceToDerivedType = yes;
}

const DeclTypeSpec *GetDeclTypeSpec();
void BeginDeclTypeSpec();
void EndDeclTypeSpec();
void SetDeclTypeSpec(const DeclTypeSpec &);
void SetDeclTypeSpecCategory(DeclTypeSpec::Category);
DeclTypeSpec::Category GetDeclTypeSpecCategory() const {
  return state_.derived.category;
}
KindExpr GetKindParamExpr(
    TypeCategory, const std::optional<parser::KindSelector> &);
void CheckForAbstractType(const Symbol &typeSymbol);

370private:
State state_;

void MakeNumericType(TypeCategory, int kind);
374};

376// Visit ImplicitStmt and related parse tree nodes and updates implicit rules.
377class ImplicitRulesVisitor : public DeclTypeSpecVisitor {
378public:
using DeclTypeSpecVisitor::Post;
using DeclTypeSpecVisitor::Pre;
using ImplicitNoneNameSpec = parser::ImplicitStmt::ImplicitNoneNameSpec;

void Post(const parser::ParameterStmt &);
bool Pre(const parser::ImplicitStmt &);
bool Pre(const parser::LetterSpec &);
bool Pre(const parser::ImplicitSpec &);
void Post(const parser::ImplicitSpec &);

const DeclTypeSpec *GetType(
    SourceName name, bool respectImplicitNoneType = true) {
  return implicitRules_->GetType(name, respectImplicitNoneType);
}
bool isImplicitNoneType() const {
  return implicitRules_->isImplicitNoneType();
}
bool isImplicitNoneType(const Scope &scope) const {
  return implicitRulesMap_->at(&scope).isImplicitNoneType();
}
bool isImplicitNoneExternal() const {
  return implicitRules_->isImplicitNoneExternal();
}
void set_inheritFromParent(bool x) {
  implicitRules_->set_inheritFromParent(x);
}

406protected:
void BeginScope(const Scope &);
void SetScope(const Scope &);

410private:
// implicit rules in effect for current scope
ImplicitRules *implicitRules_{nullptr};
std::optional<SourceName> prevImplicit_;
std::optional<SourceName> prevImplicitNone_;
std::optional<SourceName> prevImplicitNoneType_;
std::optional<SourceName> prevParameterStmt_;

bool HandleImplicitNone(const std::list<ImplicitNoneNameSpec> &nameSpecs);
419};

421// Track array specifications. They can occur in AttrSpec, EntityDecl,
422// ObjectDecl, DimensionStmt, CommonBlockObject, or BasedPointerStmt.
423// 1. INTEGER, DIMENSION(10) :: x
424// 2. INTEGER :: x(10)
425// 3. ALLOCATABLE :: x(:)
426// 4. DIMENSION :: x(10)
427// 5. COMMON x(10)
428// 6. BasedPointerStmt
429class ArraySpecVisitor : public virtual BaseVisitor {
430public:
void Post(const parser::ArraySpec &);
void Post(const parser::ComponentArraySpec &);
void Post(const parser::CoarraySpec &);
void Post(const parser::AttrSpec &) { PostAttrSpec(); }
void Post(const parser::ComponentAttrSpec &) { PostAttrSpec(); }

437protected:
const ArraySpec &arraySpec();
void set_arraySpec(const ArraySpec arraySpec) { arraySpec_ = arraySpec; }
const ArraySpec &coarraySpec();
void BeginArraySpec();
void EndArraySpec();
void ClearArraySpec() { arraySpec_.clear(); }
void ClearCoarraySpec() { coarraySpec_.clear(); }

446private:
// arraySpec_/coarraySpec_ are populated from any ArraySpec/CoarraySpec
ArraySpec arraySpec_;
ArraySpec coarraySpec_;
// When an ArraySpec is under an AttrSpec or ComponentAttrSpec, it is moved
// into attrArraySpec_
ArraySpec attrArraySpec_;
ArraySpec attrCoarraySpec_;

void PostAttrSpec();
456};

458// Manages a stack of function result information.  We defer the processing
459// of a type specification that appears in the prefix of a FUNCTION statement
460// until the function result variable appears in the specification part
461// or the end of the specification part.  This allows for forward references
462// in the type specification to resolve to local names.
463class FuncResultStack {
464public:
explicit FuncResultStack(ScopeHandler &scopeHandler)
    : scopeHandler_{scopeHandler} {}
~FuncResultStack();

struct FuncInfo {
  explicit FuncInfo(const Scope &s) : scope{s} {}
  const Scope &scope;
  // Parse tree of the type specification in the FUNCTION prefix
  const parser::DeclarationTypeSpec *parsedType{nullptr};
  // Name of the function RESULT in the FUNCTION suffix, if any
  const parser::Name *resultName{nullptr};
  // Result symbol
  Symbol *resultSymbol{nullptr};
  std::optional<SourceName> source;
  bool inFunctionStmt{false}; // true between Pre/Post of FunctionStmt
};

// Completes the definition of the top function's result.
void CompleteFunctionResultType();
// Completes the definition of a symbol if it is the top function's result.
void CompleteTypeIfFunctionResult(Symbol &);

FuncInfo *Top() { return stack_.empty() ? nullptr : &stack_.back(); }
FuncInfo &Push(const Scope &scope) { return stack_.emplace_back(scope); }
void Pop();

491private:
ScopeHandler &scopeHandler_;
std::vector<FuncInfo> stack_;
494};

496// Manage a stack of Scopes
497class ScopeHandler : public ImplicitRulesVisitor {
498public:
using ImplicitRulesVisitor::Post;
using ImplicitRulesVisitor::Pre;

Scope &currScope() { return DEREF(currScope_)Fortran::common::Deref(currScope_, "flang/lib/Semantics/resolve-names.cpp"
, 502); }
// The enclosing host procedure if current scope is in an internal procedure
Scope *GetHostProcedure();
// The innermost enclosing program unit scope, ignoring BLOCK and other
// construct scopes.
Scope &InclusiveScope();
// The enclosing scope, skipping derived types.
Scope &NonDerivedTypeScope();

// Create a new scope and push it on the scope stack.
void PushScope(Scope::Kind kind, Symbol *symbol);
void PushScope(Scope &scope);
void PopScope();
void SetScope(Scope &);

template <typename T> bool Pre(const parser::Statement<T> &x) {
  messageHandler().set_currStmtSource(x.source);
  currScope_->AddSourceRange(x.source);
  return true;
}
template <typename T> void Post(const parser::Statement<T> &) {
  messageHandler().set_currStmtSource(std::nullopt);
}

// Special messages: already declared; referencing symbol's declaration;
// about a type; two names & locations
void SayAlreadyDeclared(const parser::Name &, Symbol &);
void SayAlreadyDeclared(const SourceName &, Symbol &);
void SayAlreadyDeclared(const SourceName &, const SourceName &);
void SayWithReason(
    const parser::Name &, Symbol &, MessageFixedText &&, Message &&);
void SayWithDecl(const parser::Name &, Symbol &, MessageFixedText &&);
void SayLocalMustBeVariable(const parser::Name &, Symbol &);
void SayDerivedType(const SourceName &, MessageFixedText &&, const Scope &);
void Say2(const SourceName &, MessageFixedText &&, const SourceName &,
    MessageFixedText &&);
void Say2(
    const SourceName &, MessageFixedText &&, Symbol &, MessageFixedText &&);
void Say2(
    const parser::Name &, MessageFixedText &&, Symbol &, MessageFixedText &&);

// Search for symbol by name in current, parent derived type, and
// containing scopes
Symbol *FindSymbol(const parser::Name &);
Symbol *FindSymbol(const Scope &, const parser::Name &);
// Search for name only in scope, not in enclosing scopes.
Symbol *FindInScope(const Scope &, const parser::Name &);
Symbol *FindInScope(const Scope &, const SourceName &);
template <typename T> Symbol *FindInScope(const T &name) {
  return FindInScope(currScope(), name);
}
// Search for name in a derived type scope and its parents.
Symbol *FindInTypeOrParents(const Scope &, const parser::Name &);
Symbol *FindInTypeOrParents(const parser::Name &);
Symbol *FindSeparateModuleProcedureInterface(const parser::Name &);
void EraseSymbol(const parser::Name &);
void EraseSymbol(const Symbol &symbol) { currScope().erase(symbol.name()); }
// Make a new symbol with the name and attrs of an existing one
Symbol &CopySymbol(const SourceName &, const Symbol &);

// Make symbols in the current or named scope
Symbol &MakeSymbol(Scope &, const SourceName &, Attrs);
Symbol &MakeSymbol(const SourceName &, Attrs = Attrs{});
Symbol &MakeSymbol(const parser::Name &, Attrs = Attrs{});
Symbol &MakeHostAssocSymbol(const parser::Name &, const Symbol &);

template <typename D>
common::IfNoLvalue<Symbol &, D> MakeSymbol(
    const parser::Name &name, D &&details) {
  return MakeSymbol(name, Attrs{}, std::move(details));
}

template <typename D>
common::IfNoLvalue<Symbol &, D> MakeSymbol(
    const parser::Name &name, const Attrs &attrs, D &&details) {
  return Resolve(name, MakeSymbol(name.source, attrs, std::move(details)));
}

template <typename D>
common::IfNoLvalue<Symbol &, D> MakeSymbol(
    const SourceName &name, const Attrs &attrs, D &&details) {
  // Note: don't use FindSymbol here. If this is a derived type scope,
  // we want to detect whether the name is already declared as a component.
  auto *symbol{FindInScope(name)};
  if (!symbol) {
    symbol = &MakeSymbol(name, attrs);
    symbol->set_details(std::move(details));
    return *symbol;
  }
  if constexpr (std::is_same_v<DerivedTypeDetails, D>) {
    if (auto *d{symbol->detailsIf<GenericDetails>()}) {
      if (!d->specific()) {
        // derived type with same name as a generic
        auto *derivedType{d->derivedType()};
        if (!derivedType) {
          derivedType =
              &currScope().MakeSymbol(name, attrs, std::move(details));
          d->set_derivedType(*derivedType);
        } else if (derivedType->CanReplaceDetails(details)) {
          // was forward-referenced
          CheckDuplicatedAttrs(name, *symbol, attrs);
          SetExplicitAttrs(*derivedType, attrs);
          derivedType->set_details(std::move(details));
        } else {
          SayAlreadyDeclared(name, *derivedType);
        }
        return *derivedType;
      }
    }
  }
  if (symbol->CanReplaceDetails(details)) {
    // update the existing symbol
    CheckDuplicatedAttrs(name, *symbol, attrs);
    SetExplicitAttrs(*symbol, attrs);
    if constexpr (std::is_same_v<SubprogramDetails, D>) {
      // Dummy argument defined by explicit interface?
      details.set_isDummy(IsDummy(*symbol));
    }
    symbol->set_details(std::move(details));
    return *symbol;
  } else if constexpr (std::is_same_v<UnknownDetails, D>) {
    CheckDuplicatedAttrs(name, *symbol, attrs);
    SetExplicitAttrs(*symbol, attrs);
    return *symbol;
  } else {
    if (!CheckPossibleBadForwardRef(*symbol)) {
      if (name.empty() && symbol->name().empty()) {
        // report the error elsewhere
        return *symbol;
      }
      SayAlreadyDeclared(name, *symbol);
    }
    // replace the old symbol with a new one with correct details
    EraseSymbol(*symbol);
    auto &result{MakeSymbol(name, attrs, std::move(details))};
    context().SetError(result);
    return result;
  }
}

void MakeExternal(Symbol &);

// C815 duplicated attribute checking; returns false on error
bool CheckDuplicatedAttr(SourceName, const Symbol &, Attr);
bool CheckDuplicatedAttrs(SourceName, const Symbol &, Attrs);

void SetExplicitAttr(Symbol &symbol, Attr attr) const {
  symbol.attrs().set(attr);
  symbol.implicitAttrs().reset(attr);
}
void SetExplicitAttrs(Symbol &symbol, Attrs attrs) const {
  symbol.attrs() |= attrs;
  symbol.implicitAttrs() &= ~attrs;
}
void SetImplicitAttr(Symbol &symbol, Attr attr) const {
  symbol.attrs().set(attr);
  symbol.implicitAttrs().set(attr);
}

661protected:
FuncResultStack &funcResultStack() { return funcResultStack_; }

// Apply the implicit type rules to this symbol.
void ApplyImplicitRules(Symbol &, bool allowForwardReference = false);
bool ImplicitlyTypeForwardRef(Symbol &);
void AcquireIntrinsicProcedureFlags(Symbol &);
const DeclTypeSpec *GetImplicitType(
    Symbol &, bool respectImplicitNoneType = true);
void CheckEntryDummyUse(SourceName, Symbol *);
bool ConvertToObjectEntity(Symbol &);
bool ConvertToProcEntity(Symbol &);

const DeclTypeSpec &MakeNumericType(
    TypeCategory, const std::optional<parser::KindSelector> &);
const DeclTypeSpec &MakeNumericType(TypeCategory, int);
const DeclTypeSpec &MakeLogicalType(
    const std::optional<parser::KindSelector> &);
const DeclTypeSpec &MakeLogicalType(int);
void NotePossibleBadForwardRef(const parser::Name &);
std::optional<SourceName> HadForwardRef(const Symbol &) const;
bool CheckPossibleBadForwardRef(const Symbol &);

bool inSpecificationPart_{false};
bool inEquivalenceStmt_{false};

// Some information is collected from a specification part for deferred
// processing in DeclarationPartVisitor functions (e.g., CheckSaveStmts())
// that are called by ResolveNamesVisitor::FinishSpecificationPart().  Since
// specification parts can nest (e.g., INTERFACE bodies), the collected
// information that is not contained in the scope needs to be packaged
// and restorable.
struct SpecificationPartState {
  std::set<SourceName> forwardRefs;
  // Collect equivalence sets and process at end of specification part
  std::vector<const std::list<parser::EquivalenceObject> *> equivalenceSets;
  // Names of all common block objects in the scope
  std::set<SourceName> commonBlockObjects;
  // Info about about SAVE statements and attributes in current scope
  struct {
    std::optional<SourceName> saveAll; // "SAVE" without entity list
    std::set<SourceName> entities; // names of entities with save attr
    std::set<SourceName> commons; // names of common blocks with save attr
  } saveInfo;
} specPartState_;

// Some declaration processing can and should be deferred to
// ResolveExecutionParts() to avoid prematurely creating implicitly-typed
// local symbols that should be host associations.
struct DeferredDeclarationState {
  // The content of each namelist group
  std::list<const parser::NamelistStmt::Group *> namelistGroups;
};
DeferredDeclarationState *GetDeferredDeclarationState(bool add = false) {
  if (!add && deferred_.find(&currScope()) == deferred_.end()) {
    return nullptr;
  } else {
    return &deferred_.emplace(&currScope(), DeferredDeclarationState{})
                .first->second;
  }
}

723private:
Scope *currScope_{nullptr};
FuncResultStack funcResultStack_{*this};
std::map<Scope *, DeferredDeclarationState> deferred_;
727};

729class ModuleVisitor : public virtual ScopeHandler {
730public:
bool Pre(const parser::AccessStmt &);
bool Pre(const parser::Only &);
bool Pre(const parser::Rename::Names &);
bool Pre(const parser::Rename::Operators &);
bool Pre(const parser::UseStmt &);
void Post(const parser::UseStmt &);

void BeginModule(const parser::Name &, bool isSubmodule);
bool BeginSubmodule(const parser::Name &, const parser::ParentIdentifier &);
void ApplyDefaultAccess();
Symbol &AddGenericUse(GenericDetails &, const SourceName &, const Symbol &);
void AddAndCheckExplicitIntrinsicUse(SourceName, bool isIntrinsic);
void ClearUseRenames() { useRenames_.clear(); }
void ClearUseOnly() { useOnly_.clear(); }
void ClearExplicitIntrinsicUses() {
  explicitIntrinsicUses_.clear();
  explicitNonIntrinsicUses_.clear();
}

750private:
// The default access spec for this module.
Attr defaultAccess_{Attr::PUBLIC};
// The location of the last AccessStmt without access-ids, if any.
std::optional<SourceName> prevAccessStmt_;
// The scope of the module during a UseStmt
Scope *useModuleScope_{nullptr};
// Names that have appeared in a rename clause of a USE statement
std::set<std::pair<SourceName, Scope *>> useRenames_;
// Names that have appeared in an ONLY clause of a USE statement
std::set<std::pair<SourceName, Scope *>> useOnly_;
// Module names that have appeared in USE statements with explicit
// INTRINSIC or NON_INTRINSIC keywords
std::set<SourceName> explicitIntrinsicUses_;
std::set<SourceName> explicitNonIntrinsicUses_;

Symbol &SetAccess(const SourceName &, Attr attr, Symbol * = nullptr);
// A rename in a USE statement: local => use
struct SymbolRename {
  Symbol *local{nullptr};
  Symbol *use{nullptr};
};
// Record a use from useModuleScope_ of use Name/Symbol as local Name/Symbol
SymbolRename AddUse(const SourceName &localName, const SourceName &useName);
SymbolRename AddUse(const SourceName &, const SourceName &, Symbol *);
void DoAddUse(
    SourceName, SourceName, Symbol &localSymbol, const Symbol &useSymbol);
void AddUse(const GenericSpecInfo &);
// If appropriate, erase a previously USE-associated symbol
void EraseRenamedSymbol(const Symbol &);
// Record a name appearing in a USE rename clause
void AddUseRename(const SourceName &name) {
  useRenames_.emplace(std::make_pair(name, useModuleScope_));
}
bool IsUseRenamed(const SourceName &name) const {
  return useRenames_.find({name, useModuleScope_}) != useRenames_.end();
}
// Record a name appearing in a USE ONLY clause
void AddUseOnly(const SourceName &name) {
  useOnly_.emplace(std::make_pair(name, useModuleScope_));
}
bool IsUseOnly(const SourceName &name) const {
  return useOnly_.find({name, useModuleScope_}) != useOnly_.end();
}
Scope *FindModule(const parser::Name &, std::optional<bool> isIntrinsic,
    Scope *ancestor = nullptr);
796};

798class InterfaceVisitor : public virtual ScopeHandler {
799public:
bool Pre(const parser::InterfaceStmt &);
void Post(const parser::InterfaceStmt &);
void Post(const parser::EndInterfaceStmt &);
bool Pre(const parser::GenericSpec &);
bool Pre(const parser::ProcedureStmt &);
bool Pre(const parser::GenericStmt &);
void Post(const parser::GenericStmt &);

bool inInterfaceBlock() const;
bool isGeneric() const;
bool isAbstract() const;

812protected:
Symbol &GetGenericSymbol() { return DEREF(genericInfo_.top().symbol)Fortran::common::Deref(genericInfo_.top().symbol, "flang/lib/Semantics/resolve-names.cpp"
, 813); }
// Add to generic the symbol for the subprogram with the same name
void CheckGenericProcedures(Symbol &);

817private:
// A new GenericInfo is pushed for each interface block and generic stmt
struct GenericInfo {
  GenericInfo(bool isInterface, bool isAbstract = false)
      : isInterface{isInterface}, isAbstract{isAbstract} {}
  bool isInterface; // in interface block
  bool isAbstract; // in abstract interface block
  Symbol *symbol{nullptr}; // the generic symbol being defined
};
std::stack<GenericInfo> genericInfo_;
const GenericInfo &GetGenericInfo() const { return genericInfo_.top(); }
void SetGenericSymbol(Symbol &symbol) { genericInfo_.top().symbol = &symbol; }

using ProcedureKind = parser::ProcedureStmt::Kind;
// mapping of generic to its specific proc names and kinds
std::multimap<Symbol *, std::pair<const parser::Name *, ProcedureKind>>
    specificProcs_;

void AddSpecificProcs(const std::list<parser::Name> &, ProcedureKind);
void ResolveSpecificsInGeneric(Symbol &generic);
837};

839class SubprogramVisitor : public virtual ScopeHandler, public InterfaceVisitor {
840public:
bool HandleStmtFunction(const parser::StmtFunctionStmt &);
bool Pre(const parser::SubroutineStmt &);
bool Pre(const parser::FunctionStmt &);
void Post(const parser::FunctionStmt &);
bool Pre(const parser::EntryStmt &);
void Post(const parser::EntryStmt &);
bool Pre(const parser::InterfaceBody::Subroutine &);
void Post(const parser::InterfaceBody::Subroutine &);
bool Pre(const parser::InterfaceBody::Function &);
void Post(const parser::InterfaceBody::Function &);
bool Pre(const parser::Suffix &);
bool Pre(const parser::PrefixSpec &);

bool BeginSubprogram(const parser::Name &, Symbol::Flag,
    bool hasModulePrefix = false,
    const parser::LanguageBindingSpec * = nullptr,
    const ProgramTree::EntryStmtList * = nullptr);
bool BeginMpSubprogram(const parser::Name &);
void PushBlockDataScope(const parser::Name &);
void EndSubprogram(std::optional<parser::CharBlock> stmtSource = std::nullopt,
    const std::optional<parser::LanguageBindingSpec> * = nullptr,
    const ProgramTree::EntryStmtList * = nullptr);

864protected:
// Set when we see a stmt function that is really an array element assignment
bool badStmtFuncFound_{false};

868private:
// Edits an existing symbol created for earlier calls to a subprogram or ENTRY
// so that it can be replaced by a later definition.
bool HandlePreviousCalls(const parser::Name &, Symbol &, Symbol::Flag);
void CheckExtantProc(const parser::Name &, Symbol::Flag);
// Create a subprogram symbol in the current scope and push a new scope.
Symbol &PushSubprogramScope(const parser::Name &, Symbol::Flag,
    const parser::LanguageBindingSpec * = nullptr);
Symbol *GetSpecificFromGeneric(const parser::Name &);
Symbol &PostSubprogramStmt();
void CreateDummyArgument(SubprogramDetails &, const parser::Name &);
void CreateEntry(const parser::EntryStmt &stmt, Symbol &subprogram);
void PostEntryStmt(const parser::EntryStmt &stmt);
void HandleLanguageBinding(Symbol *,
    std::optional<parser::CharBlock> stmtSource,
    const std::optional<parser::LanguageBindingSpec> *);
884};

886class DeclarationVisitor : public ArraySpecVisitor,
                         public virtual ScopeHandler {
888public:
using ArraySpecVisitor::Post;
using ScopeHandler::Post;
using ScopeHandler::Pre;

bool Pre(const parser::Initialization &);
void Post(const parser::EntityDecl &);
void Post(const parser::ObjectDecl &);
void Post(const parser::PointerDecl &);
bool Pre(const parser::BindStmt &) { return BeginAttrs(); }
void Post(const parser::BindStmt &) { EndAttrs(); }
bool Pre(const parser::BindEntity &);
bool Pre(const parser::OldParameterStmt &);
bool Pre(const parser::NamedConstantDef &);
bool Pre(const parser::NamedConstant &);
void Post(const parser::EnumDef &);
bool Pre(const parser::Enumerator &);
bool Pre(const parser::AccessSpec &);
bool Pre(const parser::AsynchronousStmt &);
bool Pre(const parser::ContiguousStmt &);
bool Pre(const parser::ExternalStmt &);
bool Pre(const parser::IntentStmt &);
bool Pre(const parser::IntrinsicStmt &);
bool Pre(const parser::OptionalStmt &);
bool Pre(const parser::ProtectedStmt &);
bool Pre(const parser::ValueStmt &);
bool Pre(const parser::VolatileStmt &);
bool Pre(const parser::AllocatableStmt &) {
  objectDeclAttr_ = Attr::ALLOCATABLE;
  return true;
}
void Post(const parser::AllocatableStmt &) { objectDeclAttr_ = std::nullopt; }
bool Pre(const parser::TargetStmt &) {
  objectDeclAttr_ = Attr::TARGET;
  return true;
}
void Post(const parser::TargetStmt &) { objectDeclAttr_ = std::nullopt; }
void Post(const parser::DimensionStmt::Declaration &);
void Post(const parser::CodimensionDecl &);
bool Pre(const parser::TypeDeclarationStmt &) { return BeginDecl(); }
void Post(const parser::TypeDeclarationStmt &);
void Post(const parser::IntegerTypeSpec &);
void Post(const parser::IntrinsicTypeSpec::Real &);
void Post(const parser::IntrinsicTypeSpec::Complex &);
void Post(const parser::IntrinsicTypeSpec::Logical &);
void Post(const parser::IntrinsicTypeSpec::Character &);
void Post(const parser::CharSelector::LengthAndKind &);
void Post(const parser::CharLength &);
void Post(const parser::LengthSelector &);
bool Pre(const parser::KindParam &);
bool Pre(const parser::DeclarationTypeSpec::Type &);
void Post(const parser::DeclarationTypeSpec::Type &);
bool Pre(const parser::DeclarationTypeSpec::Class &);
void Post(const parser::DeclarationTypeSpec::Class &);
void Post(const parser::DeclarationTypeSpec::Record &);
void Post(const parser::DerivedTypeSpec &);
bool Pre(const parser::DerivedTypeDef &);
bool Pre(const parser::DerivedTypeStmt &);
void Post(const parser::DerivedTypeStmt &);
bool Pre(const parser::TypeParamDefStmt &) { return BeginDecl(); }
void Post(const parser::TypeParamDefStmt &);
bool Pre(const parser::TypeAttrSpec::Extends &);
bool Pre(const parser::PrivateStmt &);
bool Pre(const parser::SequenceStmt &);
bool Pre(const parser::ComponentDefStmt &) { return BeginDecl(); }
void Post(const parser::ComponentDefStmt &) { EndDecl(); }
void Post(const parser::ComponentDecl &);
void Post(const parser::FillDecl &);
bool Pre(const parser::ProcedureDeclarationStmt &);
void Post(const parser::ProcedureDeclarationStmt &);
bool Pre(const parser::DataComponentDefStmt &); // returns false
bool Pre(const parser::ProcComponentDefStmt &);
void Post(const parser::ProcComponentDefStmt &);
bool Pre(const parser::ProcPointerInit &);
void Post(const parser::ProcInterface &);
void Post(const parser::ProcDecl &);
bool Pre(const parser::TypeBoundProcedurePart &);
void Post(const parser::TypeBoundProcedurePart &);
void Post(const parser::ContainsStmt &);
bool Pre(const parser::TypeBoundProcBinding &) { return BeginAttrs(); }
void Post(const parser::TypeBoundProcBinding &) { EndAttrs(); }
void Post(const parser::TypeBoundProcedureStmt::WithoutInterface &);
void Post(const parser::TypeBoundProcedureStmt::WithInterface &);
void Post(const parser::FinalProcedureStmt &);
bool Pre(const parser::TypeBoundGenericStmt &);
bool Pre(const parser::StructureDef &); // returns false
bool Pre(const parser::Union::UnionStmt &);
bool Pre(const parser::StructureField &);
void Post(const parser::StructureField &);
bool Pre(const parser::AllocateStmt &);
void Post(const parser::AllocateStmt &);
bool Pre(const parser::StructureConstructor &);
bool Pre(const parser::NamelistStmt::Group &);
bool Pre(const parser::IoControlSpec &);
bool Pre(const parser::CommonStmt::Block &);
bool Pre(const parser::CommonBlockObject &);
void Post(const parser::CommonBlockObject &);
bool Pre(const parser::EquivalenceStmt &);
bool Pre(const parser::SaveStmt &);
bool Pre(const parser::BasedPointerStmt &);

void PointerInitialization(
    const parser::Name &, const parser::InitialDataTarget &);
void PointerInitialization(
    const parser::Name &, const parser::ProcPointerInit &);
void NonPointerInitialization(
    const parser::Name &, const parser::ConstantExpr &);
void CheckExplicitInterface(const parser::Name &);
void CheckBindings(const parser::TypeBoundProcedureStmt::WithoutInterface &);

const parser::Name *ResolveDesignator(const parser::Designator &);

1000protected:
bool BeginDecl();
void EndDecl();
Symbol &DeclareObjectEntity(const parser::Name &, Attrs = Attrs{});
// Make sure that there's an entity in an enclosing scope called Name
Symbol &FindOrDeclareEnclosingEntity(const parser::Name &);
// Declare a LOCAL/LOCAL_INIT entity. If there isn't a type specified
// it comes from the entity in the containing scope, or implicit rules.
// Return pointer to the new symbol, or nullptr on error.
Symbol *DeclareLocalEntity(const parser::Name &);
// Declare a statement entity (i.e., an implied DO loop index for
// a DATA statement or an array constructor).  If there isn't an explict
// type specified, implicit rules apply. Return pointer to the new symbol,
// or nullptr on error.
Symbol *DeclareStatementEntity(const parser::DoVariable &,
    const std::optional<parser::IntegerTypeSpec> &);
Symbol &MakeCommonBlockSymbol(const parser::Name &);
Symbol &MakeCommonBlockSymbol(const std::optional<parser::Name> &);
bool CheckUseError(const parser::Name &);
void CheckAccessibility(const SourceName &, bool, Symbol &);
void CheckCommonBlocks();
void CheckSaveStmts();
void CheckEquivalenceSets();
bool CheckNotInBlock(const char *);
bool NameIsKnownOrIntrinsic(const parser::Name &);
void FinishNamelists();

// Each of these returns a pointer to a resolved Name (i.e. with symbol)
// or nullptr in case of error.
const parser::Name *ResolveStructureComponent(
    const parser::StructureComponent &);
const parser::Name *ResolveDataRef(const parser::DataRef &);
const parser::Name *ResolveName(const parser::Name &);
bool PassesSharedLocalityChecks(const parser::Name &name, Symbol &symbol);
Symbol *NoteInterfaceName(const parser::Name &);
bool IsUplevelReference(const Symbol &);

std::optional<SourceName> BeginCheckOnIndexUseInOwnBounds(
    const parser::DoVariable &name) {
  std::optional<SourceName> result{checkIndexUseInOwnBounds_};
  checkIndexUseInOwnBounds_ = name.thing.thing.source;
  return result;
}
void EndCheckOnIndexUseInOwnBounds(const std::optional<SourceName> &restore) {
  checkIndexUseInOwnBounds_ = restore;
}

1047private:
// The attribute corresponding to the statement containing an ObjectDecl
std::optional<Attr> objectDeclAttr_;
// Info about current character type while walking DeclTypeSpec.
// Also captures any "*length" specifier on an individual declaration.
struct {
  std::optional<ParamValue> length;
  std::optional<KindExpr> kind;
} charInfo_;
// Info about current derived type or STRUCTURE while walking
// DerivedTypeDef / StructureDef
struct {
  const parser::Name *extends{nullptr}; // EXTENDS(name)
  bool privateComps{false}; // components are private by default
  bool privateBindings{false}; // bindings are private by default
  bool sawContains{false}; // currently processing bindings
  bool sequence{false}; // is a sequence type
  const Symbol *type{nullptr}; // derived type being defined
  bool isStructure{false}; // is a DEC STRUCTURE
} derivedTypeInfo_;
// In a ProcedureDeclarationStmt or ProcComponentDefStmt, this is
// the interface name, if any.
const parser::Name *interfaceName_{nullptr};
// Map type-bound generic to binding names of its specific bindings
std::multimap<Symbol *, const parser::Name *> genericBindings_;
// Info about current ENUM
struct EnumeratorState {
  // Enum value must hold inside a C_INT (7.6.2).
  std::optional<int> value{0};
} enumerationState_;
// Set for OldParameterStmt processing
bool inOldStyleParameterStmt_{false};
// Set when walking DATA & array constructor implied DO loop bounds
// to warn about use of the implied DO intex therein.
std::optional<SourceName> checkIndexUseInOwnBounds_;
bool hasBindCName_{false};

bool HandleAttributeStmt(Attr, const std::list<parser::Name> &);
Symbol &HandleAttributeStmt(Attr, const parser::Name &);
Symbol &DeclareUnknownEntity(const parser::Name &, Attrs);
Symbol &DeclareProcEntity(
    const parser::Name &, Attrs, const Symbol *interface);
void SetType(const parser::Name &, const DeclTypeSpec &);
std::optional<DerivedTypeSpec> ResolveDerivedType(const parser::Name &);
std::optional<DerivedTypeSpec> ResolveExtendsType(
    const parser::Name &, const parser::Name *);
Symbol *MakeTypeSymbol(const SourceName &, Details &&);
Symbol *MakeTypeSymbol(const parser::Name &, Details &&);
bool OkToAddComponent(const parser::Name &, const Symbol * = nullptr);
ParamValue GetParamValue(
    const parser::TypeParamValue &, common::TypeParamAttr attr);
void CheckCommonBlockDerivedType(const SourceName &, const Symbol &);
std::optional<MessageFixedText> CheckSaveAttr(const Symbol &);
Attrs HandleSaveName(const SourceName &, Attrs);
void AddSaveName(std::set<SourceName> &, const SourceName &);
void SetSaveAttr(Symbol &);
bool HandleUnrestrictedSpecificIntrinsicFunction(const parser::Name &);
const parser::Name *FindComponent(const parser::Name *, const parser::Name &);
void Initialization(const parser::Name &, const parser::Initialization &,
    bool inComponentDecl);
bool PassesLocalityChecks(const parser::Name &name, Symbol &symbol);
bool CheckForHostAssociatedImplicit(const parser::Name &);

// Declare an object or procedure entity.
// T is one of: EntityDetails, ObjectEntityDetails, ProcEntityDetails
template <typename T>
Symbol &DeclareEntity(const parser::Name &name, Attrs attrs) {
  Symbol &symbol{MakeSymbol(name, attrs)};
  if (context().HasError(symbol) || symbol.has<T>()) {
    return symbol; // OK or error already reported
  } else if (symbol.has<UnknownDetails>()) {
    symbol.set_details(T{});
    return symbol;
  } else if (auto *details{symbol.detailsIf<EntityDetails>()}) {
    symbol.set_details(T{std::move(*details)});
    return symbol;
  } else if (std::is_same_v<EntityDetails, T> &&
      (symbol.has<ObjectEntityDetails>() ||
          symbol.has<ProcEntityDetails>())) {
    return symbol; // OK
  } else if (auto *details{symbol.detailsIf<UseDetails>()}) {
    Say(name.source,
        "'%s' is use-associated from module '%s' and cannot be re-declared"_err_en_US,
        name.source, GetUsedModule(*details).name());
  } else if (auto *details{symbol.detailsIf<SubprogramNameDetails>()}) {
    if (details->kind() == SubprogramKind::Module) {
      Say2(name,
          "Declaration of '%s' conflicts with its use as module procedure"_err_en_US,
          symbol, "Module procedure definition"_en_US);
    } else if (details->kind() == SubprogramKind::Internal) {
      Say2(name,
          "Declaration of '%s' conflicts with its use as internal procedure"_err_en_US,
          symbol, "Internal procedure definition"_en_US);
    } else {
      DIE("unexpected kind")Fortran::common::die("unexpected kind" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 1141);
    }
  } else if (std::is_same_v<ObjectEntityDetails, T> &&
      symbol.has<ProcEntityDetails>()) {
    SayWithDecl(
        name, symbol, "'%s' is already declared as a procedure"_err_en_US);
  } else if (std::is_same_v<ProcEntityDetails, T> &&
      symbol.has<ObjectEntityDetails>()) {
    if (FindCommonBlockContaining(symbol)) {
      SayWithDecl(name, symbol,
          "'%s' may not be a procedure as it is in a COMMON block"_err_en_US);
    } else {
      SayWithDecl(
          name, symbol, "'%s' is already declared as an object"_err_en_US);
    }
  } else if (!CheckPossibleBadForwardRef(symbol)) {
    SayAlreadyDeclared(name, symbol);
  }
  context().SetError(symbol);
  return symbol;
}
bool HasCycle(const Symbol &, const Symbol *interface);
1163};

1165// Resolve construct entities and statement entities.
1166// Check that construct names don't conflict with other names.
1167class ConstructVisitor : public virtual DeclarationVisitor {
1168public:
bool Pre(const parser::ConcurrentHeader &);
bool Pre(const parser::LocalitySpec::Local &);
bool Pre(const parser::LocalitySpec::LocalInit &);
bool Pre(const parser::LocalitySpec::Shared &);
bool Pre(const parser::AcSpec &);
bool Pre(const parser::AcImpliedDo &);
bool Pre(const parser::DataImpliedDo &);
bool Pre(const parser::DataIDoObject &);
bool Pre(const parser::DataStmtObject &);
bool Pre(const parser::DataStmtValue &);
bool Pre(const parser::DoConstruct &);
void Post(const parser::DoConstruct &);
bool Pre(const parser::ForallConstruct &);
void Post(const parser::ForallConstruct &);
bool Pre(const parser::ForallStmt &);
void Post(const parser::ForallStmt &);
bool Pre(const parser::BlockStmt &);
bool Pre(const parser::EndBlockStmt &);
void Post(const parser::Selector &);
void Post(const parser::AssociateStmt &);
void Post(const parser::EndAssociateStmt &);
bool Pre(const parser::Association &);
void Post(const parser::SelectTypeStmt &);
void Post(const parser::SelectRankStmt &);
bool Pre(const parser::SelectTypeConstruct &);
void Post(const parser::SelectTypeConstruct &);
bool Pre(const parser::SelectTypeConstruct::TypeCase &);
void Post(const parser::SelectTypeConstruct::TypeCase &);
// Creates Block scopes with neither symbol name nor symbol details.
bool Pre(const parser::SelectRankConstruct::RankCase &);
void Post(const parser::SelectRankConstruct::RankCase &);
bool Pre(const parser::TypeGuardStmt::Guard &);
void Post(const parser::TypeGuardStmt::Guard &);
void Post(const parser::SelectRankCaseStmt::Rank &);
bool Pre(const parser::ChangeTeamStmt &);
void Post(const parser::EndChangeTeamStmt &);
void Post(const parser::CoarrayAssociation &);

// Definitions of construct names
bool Pre(const parser::WhereConstructStmt &x) { return CheckDef(x.t); }
bool Pre(const parser::ForallConstructStmt &x) { return CheckDef(x.t); }
bool Pre(const parser::CriticalStmt &x) { return CheckDef(x.t); }
bool Pre(const parser::LabelDoStmt &) {
  return false; // error recovery
}
bool Pre(const parser::NonLabelDoStmt &x) { return CheckDef(x.t); }
bool Pre(const parser::IfThenStmt &x) { return CheckDef(x.t); }
bool Pre(const parser::SelectCaseStmt &x) { return CheckDef(x.t); }
bool Pre(const parser::SelectRankConstruct &);
void Post(const parser::SelectRankConstruct &);
bool Pre(const parser::SelectRankStmt &x) {
  return CheckDef(std::get<0>(x.t));
}
bool Pre(const parser::SelectTypeStmt &x) {
  return CheckDef(std::get<0>(x.t));
}

// References to construct names
void Post(const parser::MaskedElsewhereStmt &x) { CheckRef(x.t); }
void Post(const parser::ElsewhereStmt &x) { CheckRef(x.v); }
void Post(const parser::EndWhereStmt &x) { CheckRef(x.v); }
void Post(const parser::EndForallStmt &x) { CheckRef(x.v); }
void Post(const parser::EndCriticalStmt &x) { CheckRef(x.v); }
void Post(const parser::EndDoStmt &x) { CheckRef(x.v); }
void Post(const parser::ElseIfStmt &x) { CheckRef(x.t); }
void Post(const parser::ElseStmt &x) { CheckRef(x.v); }
void Post(const parser::EndIfStmt &x) { CheckRef(x.v); }
void Post(const parser::CaseStmt &x) { CheckRef(x.t); }
void Post(const parser::EndSelectStmt &x) { CheckRef(x.v); }
void Post(const parser::SelectRankCaseStmt &x) { CheckRef(x.t); }
void Post(const parser::TypeGuardStmt &x) { CheckRef(x.t); }
void Post(const parser::CycleStmt &x) { CheckRef(x.v); }
void Post(const parser::ExitStmt &x) { CheckRef(x.v); }

1243private:
// R1105 selector -> expr | variable
// expr is set in either case unless there were errors
struct Selector {
  Selector() {}
  Selector(const SourceName &source, MaybeExpr &&expr)
      : source{source}, expr{std::move(expr)} {}
  operator bool() const { return expr.has_value(); }
  parser::CharBlock source;
  MaybeExpr expr;
};
// association -> [associate-name =>] selector
struct Association {
  const parser::Name *name{nullptr};
  Selector selector;
};
std::vector<Association> associationStack_;
Association *currentAssociation_{nullptr};

template <typename T> bool CheckDef(const T &t) {
  return CheckDef(std::get<std::optional<parser::Name>>(t));
}
template <typename T> void CheckRef(const T &t) {
  CheckRef(std::get<std::optional<parser::Name>>(t));
}
bool CheckDef(const std::optional<parser::Name> &);
void CheckRef(const std::optional<parser::Name> &);
const DeclTypeSpec &ToDeclTypeSpec(evaluate::DynamicType &&);
const DeclTypeSpec &ToDeclTypeSpec(
    evaluate::DynamicType &&, MaybeSubscriptIntExpr &&length);
Symbol *MakeAssocEntity();
void SetTypeFromAssociation(Symbol &);
void SetAttrsFromAssociation(Symbol &);
Selector ResolveSelector(const parser::Selector &);
void ResolveIndexName(const parser::ConcurrentControl &control);
void SetCurrentAssociation(std::size_t n);
Association &GetCurrentAssociation();
void PushAssociation();
void PopAssociation(std::size_t count = 1);
1282};

1284// Create scopes for OpenACC constructs
1285class AccVisitor : public virtual DeclarationVisitor {
1286public:
void AddAccSourceRange(const parser::CharBlock &);

static bool NeedsScope(const parser::OpenACCBlockConstruct &);

bool Pre(const parser::OpenACCBlockConstruct &);
void Post(const parser::OpenACCBlockConstruct &);
bool Pre(const parser::AccBeginBlockDirective &x) {
  AddAccSourceRange(x.source);
  return true;
}
void Post(const parser::AccBeginBlockDirective &) {
  messageHandler().set_currStmtSource(std::nullopt);
}
bool Pre(const parser::AccEndBlockDirective &x) {
  AddAccSourceRange(x.source);
  return true;
}
void Post(const parser::AccEndBlockDirective &) {
  messageHandler().set_currStmtSource(std::nullopt);
}
bool Pre(const parser::AccBeginLoopDirective &x) {
  AddAccSourceRange(x.source);
  return true;
}
void Post(const parser::AccBeginLoopDirective &x) {
  messageHandler().set_currStmtSource(std::nullopt);
}
1314};

1316bool AccVisitor::NeedsScope(const parser::OpenACCBlockConstruct &x) {
const auto &beginBlockDir{std::get<parser::AccBeginBlockDirective>(x.t)};
const auto &beginDir{std::get<parser::AccBlockDirective>(beginBlockDir.t)};
switch (beginDir.v) {
case llvm::acc::Directive::ACCD_data:
case llvm::acc::Directive::ACCD_host_data:
case llvm::acc::Directive::ACCD_kernels:
case llvm::acc::Directive::ACCD_parallel:
case llvm::acc::Directive::ACCD_serial:
  return true;
default:
  return false;
}
1329}

1331void AccVisitor::AddAccSourceRange(const parser::CharBlock &source) {
messageHandler().set_currStmtSource(source);
currScope().AddSourceRange(source);
1334}

1336bool AccVisitor::Pre(const parser::OpenACCBlockConstruct &x) {
if (NeedsScope(x)) {
  PushScope(Scope::Kind::OtherConstruct, nullptr);
}
return true;
1341}

1343void AccVisitor::Post(const parser::OpenACCBlockConstruct &x) {
if (NeedsScope(x)) {
  PopScope();
}
1347}

1349// Create scopes for OpenMP constructs
1350class OmpVisitor : public virtual DeclarationVisitor {
1351public:
void AddOmpSourceRange(const parser::CharBlock &);

static bool NeedsScope(const parser::OpenMPBlockConstruct &);

bool Pre(const parser::OpenMPBlockConstruct &);
void Post(const parser::OpenMPBlockConstruct &);
bool Pre(const parser::OmpBeginBlockDirective &x) {
  AddOmpSourceRange(x.source);
  return true;
}
void Post(const parser::OmpBeginBlockDirective &) {
  messageHandler().set_currStmtSource(std::nullopt);
}
bool Pre(const parser::OmpEndBlockDirective &x) {
  AddOmpSourceRange(x.source);
  return true;
}
void Post(const parser::OmpEndBlockDirective &) {
  messageHandler().set_currStmtSource(std::nullopt);
}

bool Pre(const parser::OpenMPLoopConstruct &) {
  PushScope(Scope::Kind::OtherConstruct, nullptr);
  return true;
}
void Post(const parser::OpenMPLoopConstruct &) { PopScope(); }
bool Pre(const parser::OmpBeginLoopDirective &x) {
  AddOmpSourceRange(x.source);
  return true;
}
void Post(const parser::OmpBeginLoopDirective &) {
  messageHandler().set_currStmtSource(std::nullopt);
}
bool Pre(const parser::OmpEndLoopDirective &x) {
  AddOmpSourceRange(x.source);
  return true;
}
void Post(const parser::OmpEndLoopDirective &) {
  messageHandler().set_currStmtSource(std::nullopt);
}

bool Pre(const parser::OpenMPSectionsConstruct &) {
  PushScope(Scope::Kind::OtherConstruct, nullptr);
  return true;
}
void Post(const parser::OpenMPSectionsConstruct &) { PopScope(); }
bool Pre(const parser::OmpBeginSectionsDirective &x) {
  AddOmpSourceRange(x.source);
  return true;
}
void Post(const parser::OmpBeginSectionsDirective &) {
  messageHandler().set_currStmtSource(std::nullopt);
}
bool Pre(const parser::OmpEndSectionsDirective &x) {
  AddOmpSourceRange(x.source);
  return true;
}
void Post(const parser::OmpEndSectionsDirective &) {
  messageHandler().set_currStmtSource(std::nullopt);
}
1412};

1414bool OmpVisitor::NeedsScope(const parser::OpenMPBlockConstruct &x) {
const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
switch (beginDir.v) {
case llvm::omp::Directive::OMPD_target_data:
case llvm::omp::Directive::OMPD_master:
case llvm::omp::Directive::OMPD_ordered:
case llvm::omp::Directive::OMPD_taskgroup:
  return false;
default:
  return true;
}
1426}

1428void OmpVisitor::AddOmpSourceRange(const parser::CharBlock &source) {
messageHandler().set_currStmtSource(source);
currScope().AddSourceRange(source);
1431}

1433bool OmpVisitor::Pre(const parser::OpenMPBlockConstruct &x) {
if (NeedsScope(x)) {
  PushScope(Scope::Kind::OtherConstruct, nullptr);
}
return true;
1438}

1440void OmpVisitor::Post(const parser::OpenMPBlockConstruct &x) {
if (NeedsScope(x)) {
  PopScope();
}
1444}

1446// Walk the parse tree and resolve names to symbols.
1447class ResolveNamesVisitor : public virtual ScopeHandler,
                          public ModuleVisitor,
                          public SubprogramVisitor,
                          public ConstructVisitor,
                          public OmpVisitor,
                          public AccVisitor {
1453public:
using AccVisitor::Post;
using AccVisitor::Pre;
using ArraySpecVisitor::Post;
using ConstructVisitor::Post;
using ConstructVisitor::Pre;
using DeclarationVisitor::Post;
using DeclarationVisitor::Pre;
using ImplicitRulesVisitor::Post;
using ImplicitRulesVisitor::Pre;
using InterfaceVisitor::Post;
using InterfaceVisitor::Pre;
using ModuleVisitor::Post;
using ModuleVisitor::Pre;
using OmpVisitor::Post;
using OmpVisitor::Pre;
using ScopeHandler::Post;
using ScopeHandler::Pre;
using SubprogramVisitor::Post;
using SubprogramVisitor::Pre;

ResolveNamesVisitor(
    SemanticsContext &context, ImplicitRulesMap &rules, Scope &top)
    : BaseVisitor{context, *this, rules}, topScope_{top} {
  PushScope(top);
}

Scope &topScope() const { return topScope_; }

// Default action for a parse tree node is to visit children.
template <typename T> bool Pre(const T &) { return true; }
template <typename T> void Post(const T &) {}

bool Pre(const parser::SpecificationPart &);
void Post(const parser::Program &);
bool Pre(const parser::ImplicitStmt &);
void Post(const parser::PointerObject &);
void Post(const parser::AllocateObject &);
bool Pre(const parser::PointerAssignmentStmt &);
void Post(const parser::Designator &);
void Post(const parser::SubstringInquiry &);
template <typename A, typename B>
void Post(const parser::LoopBounds<A, B> &x) {
  ResolveName(*parser::Unwrap<parser::Name>(x.name));
}
void Post(const parser::ProcComponentRef &);
bool Pre(const parser::FunctionReference &);
bool Pre(const parser::CallStmt &);
bool Pre(const parser::ImportStmt &);
void Post(const parser::TypeGuardStmt &);
bool Pre(const parser::StmtFunctionStmt &);
bool Pre(const parser::DefinedOpName &);
bool Pre(const parser::ProgramUnit &);
void Post(const parser::AssignStmt &);
void Post(const parser::AssignedGotoStmt &);

// These nodes should never be reached: they are handled in ProgramUnit
bool Pre(const parser::MainProgram &) {
  llvm_unreachable("This node is handled in ProgramUnit")::llvm::llvm_unreachable_internal("This node is handled in ProgramUnit"
, "flang/lib/Semantics/resolve-names.cpp", 1511);
}
bool Pre(const parser::FunctionSubprogram &) {
  llvm_unreachable("This node is handled in ProgramUnit")::llvm::llvm_unreachable_internal("This node is handled in ProgramUnit"
, "flang/lib/Semantics/resolve-names.cpp", 1514);
}
bool Pre(const parser::SubroutineSubprogram &) {
  llvm_unreachable("This node is handled in ProgramUnit")::llvm::llvm_unreachable_internal("This node is handled in ProgramUnit"
, "flang/lib/Semantics/resolve-names.cpp", 1517);
}
bool Pre(const parser::SeparateModuleSubprogram &) {
  llvm_unreachable("This node is handled in ProgramUnit")::llvm::llvm_unreachable_internal("This node is handled in ProgramUnit"
, "flang/lib/Semantics/resolve-names.cpp", 1520);
}
bool Pre(const parser::Module &) {
  llvm_unreachable("This node is handled in ProgramUnit")::llvm::llvm_unreachable_internal("This node is handled in ProgramUnit"
, "flang/lib/Semantics/resolve-names.cpp", 1523);
}
bool Pre(const parser::Submodule &) {
  llvm_unreachable("This node is handled in ProgramUnit")::llvm::llvm_unreachable_internal("This node is handled in ProgramUnit"
, "flang/lib/Semantics/resolve-names.cpp", 1526);
}
bool Pre(const parser::BlockData &) {
  llvm_unreachable("This node is handled in ProgramUnit")::llvm::llvm_unreachable_internal("This node is handled in ProgramUnit"
, "flang/lib/Semantics/resolve-names.cpp", 1529);
}

void NoteExecutablePartCall(Symbol::Flag, const parser::Call &);

friend void ResolveSpecificationParts(SemanticsContext &, const Symbol &);

1536private:
// Kind of procedure we are expecting to see in a ProcedureDesignator
std::optional<Symbol::Flag> expectedProcFlag_;
std::optional<SourceName> prevImportStmt_;
Scope &topScope_;

void PreSpecificationConstruct(const parser::SpecificationConstruct &);
void CreateCommonBlockSymbols(const parser::CommonStmt &);
void CreateGeneric(const parser::GenericSpec &);
void FinishSpecificationPart(const std::list<parser::DeclarationConstruct> &);
void AnalyzeStmtFunctionStmt(const parser::StmtFunctionStmt &);
void CheckImports();
void CheckImport(const SourceName &, const SourceName &);
void HandleCall(Symbol::Flag, const parser::Call &);
void HandleProcedureName(Symbol::Flag, const parser::Name &);
bool CheckImplicitNoneExternal(const SourceName &, const Symbol &);
bool SetProcFlag(const parser::Name &, Symbol &, Symbol::Flag);
void ResolveSpecificationParts(ProgramTree &);
void AddSubpNames(ProgramTree &);
bool BeginScopeForNode(const ProgramTree &);
void EndScopeForNode(const ProgramTree &);
void FinishSpecificationParts(const ProgramTree &);
void FinishDerivedTypeInstantiation(Scope &);
void ResolveExecutionParts(const ProgramTree &);
1560};

1562// ImplicitRules implementation

1564bool ImplicitRules::isImplicitNoneType() const {
if (isImplicitNoneType_) {
  return true;
} else if (map_.empty() && inheritFromParent_) {
  return parent_->isImplicitNoneType();
} else {
  return false; // default if not specified
}
1572}

1574bool ImplicitRules::isImplicitNoneExternal() const {
if (isImplicitNoneExternal_) {
  return true;
} else if (inheritFromParent_) {
  return parent_->isImplicitNoneExternal();
} else {
  return false; // default if not specified
}
1582}

1584const DeclTypeSpec *ImplicitRules::GetType(
  SourceName name, bool respectImplicitNoneType) const {
char ch{name.begin()[0]};
if (isImplicitNoneType_ && respectImplicitNoneType) {
  return nullptr;
} else if (auto it{map_.find(ch)}; it != map_.end()) {
  return &*it->second;
} else if (inheritFromParent_) {
  return parent_->GetType(name, respectImplicitNoneType);
} else if (ch >= 'i' && ch <= 'n') {
  return &context_.MakeNumericType(TypeCategory::Integer);
} else if (ch >= 'a' && ch <= 'z') {
  return &context_.MakeNumericType(TypeCategory::Real);
} else {
  return nullptr;
}
1600}

1602void ImplicitRules::SetTypeMapping(const DeclTypeSpec &type,
  parser::Location fromLetter, parser::Location toLetter) {
for (char ch = *fromLetter; ch; ch = ImplicitRules::Incr(ch)) {
  auto res{map_.emplace(ch, type)};
  if (!res.second) {
    context_.Say(parser::CharBlock{fromLetter},
        "More than one implicit type specified for '%c'"_err_en_US, ch);
  }
  if (ch == *toLetter) {
    break;
  }
}
1614}

1616// Return the next char after ch in a way that works for ASCII or EBCDIC.
1617// Return '\0' for the char after 'z'.
1618char ImplicitRules::Incr(char ch) {
switch (ch) {
case 'i':
  return 'j';
case 'r':
  return 's';
case 'z':
  return '\0';
default:
  return ch + 1;
}
1629}

1631llvm::raw_ostream &operator<<(
  llvm::raw_ostream &o, const ImplicitRules &implicitRules) {
o << "ImplicitRules:\n";
for (char ch = 'a'; ch; ch = ImplicitRules::Incr(ch)) {
  ShowImplicitRule(o, implicitRules, ch);
}
ShowImplicitRule(o, implicitRules, '_');
ShowImplicitRule(o, implicitRules, '$');
ShowImplicitRule(o, implicitRules, '@');
return o;
1641}
1642void ShowImplicitRule(
  llvm::raw_ostream &o, const ImplicitRules &implicitRules, char ch) {
auto it{implicitRules.map_.find(ch)};
if (it != implicitRules.map_.end()) {
  o << "  " << ch << ": " << *it->second << '\n';
}
1648}

1650template <typename T> void BaseVisitor::Walk(const T &x) {
parser::Walk(x, *this_);
1
Calling 'Walk<Fortran::parser::TypeBoundProcedurePart, Fortran::semantics::ResolveNamesVisitor>'→
1652}

1654void BaseVisitor::MakePlaceholder(
  const parser::Name &name, MiscDetails::Kind kind) {
if (!name.symbol) {
  name.symbol = &context_->globalScope().MakeSymbol(
      name.source, Attrs{}, MiscDetails{kind});
}
1660}

1662// AttrsVisitor implementation

1664bool AttrsVisitor::BeginAttrs() {
CHECK(!attrs_)((!attrs_) || (Fortran::common::die("CHECK(" "!attrs_" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 1665)
, false));
attrs_ = std::make_optional<Attrs>();
return true;
1668}
1669Attrs AttrsVisitor::GetAttrs() {
CHECK(attrs_)((attrs_) || (Fortran::common::die("CHECK(" "attrs_" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 1670)
, false));
return *attrs_;
1672}
1673Attrs AttrsVisitor::EndAttrs() {
Attrs result{GetAttrs()};
attrs_.reset();
passName_ = std::nullopt;
bindName_.reset();
return result;
1679}

1681bool AttrsVisitor::SetPassNameOn(Symbol &symbol) {
if (!passName_) {
  return false;
}
common::visit(common::visitors{
                  [&](ProcEntityDetails &x) { x.set_passName(*passName_); },
                  [&](ProcBindingDetails &x) { x.set_passName(*passName_); },
                  [](auto &) { common::die("unexpected pass name"); },
              },
    symbol.details());
return true;
1692}

1694void AttrsVisitor::SetBindNameOn(Symbol &symbol) {
if (!attrs_ || !attrs_->test(Attr::BIND_C)) {
  return;
}
std::optional<std::string> label{
    evaluate::GetScalarConstantValue<evaluate::Ascii>(bindName_)};
if (ClassifyProcedure(symbol) == ProcedureDefinitionClass::Internal) {
  if (label) { // C1552: no NAME= allowed even if null
    Say(symbol.name(),
        "An internal procedure may not have a BIND(C,NAME=) binding label"_err_en_US);
  }
  return;
}
// 18.9.2(2): discard leading and trailing blanks
if (label) {
  auto first{label->find_first_not_of(" ")};
  if (first == std::string::npos) {
    // Empty NAME= means no binding at all (18.10.2p2)
    return;
  }
  auto last{label->find_last_not_of(" ")};
  label = label->substr(first, last - first + 1);
} else {
  label = parser::ToLowerCaseLetters(symbol.name().ToString());
}
// 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 (oldBindName != *newBindName) {
      Say(symbol.name(), "The entity '%s' has multiple BIND names"_err_en_US);
    }
  }
}
1732}

1734void AttrsVisitor::Post(const parser::LanguageBindingSpec &x) {
CHECK(attrs_)((attrs_) || (Fortran::common::die("CHECK(" "attrs_" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 1735)
, false));
if (CheckAndSet(Attr::BIND_C)) {
  if (x.v) {
    bindName_ = EvaluateExpr(*x.v);
  }
}
1741}
1742bool AttrsVisitor::Pre(const parser::IntentSpec &x) {
CHECK(attrs_)((attrs_) || (Fortran::common::die("CHECK(" "attrs_" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 1743)
, false));
CheckAndSet(IntentSpecToAttr(x));
return false;
1746}
1747bool AttrsVisitor::Pre(const parser::Pass &x) {
if (CheckAndSet(Attr::PASS)) {
  if (x.v) {
    passName_ = x.v->source;
    MakePlaceholder(*x.v, MiscDetails::Kind::PassName);
  }
}
return false;
1755}

1757// C730, C743, C755, C778, C1543 say no attribute or prefix repetitions
1758bool AttrsVisitor::IsDuplicateAttr(Attr attrName) {
if (attrs_->test(attrName)) {
  Say(currStmtSource().value(),
      "Attribute '%s' cannot be used more than once"_warn_en_US,
      AttrToString(attrName));
  return true;
}
return false;
1766}

1768// See if attrName violates a constraint cause by a conflict.  attr1 and attr2
1769// name attributes that cannot be used on the same declaration
1770bool AttrsVisitor::HaveAttrConflict(Attr attrName, Attr attr1, Attr attr2) {
if ((attrName == attr1 && attrs_->test(attr2)) ||
    (attrName == attr2 && attrs_->test(attr1))) {
  Say(currStmtSource().value(),
      "Attributes '%s' and '%s' conflict with each other"_err_en_US,
      AttrToString(attr1), AttrToString(attr2));
  return true;
}
return false;
1779}
1780// C759, C1543
1781bool AttrsVisitor::IsConflictingAttr(Attr attrName) {
return HaveAttrConflict(attrName, Attr::INTENT_IN, Attr::INTENT_INOUT) ||
    HaveAttrConflict(attrName, Attr::INTENT_IN, Attr::INTENT_OUT) ||
    HaveAttrConflict(attrName, Attr::INTENT_INOUT, Attr::INTENT_OUT) ||
    HaveAttrConflict(attrName, Attr::PASS, Attr::NOPASS) || // C781
    HaveAttrConflict(attrName, Attr::PURE, Attr::IMPURE) ||
    HaveAttrConflict(attrName, Attr::PUBLIC, Attr::PRIVATE) ||
    HaveAttrConflict(attrName, Attr::RECURSIVE, Attr::NON_RECURSIVE);
1789}
1790bool AttrsVisitor::CheckAndSet(Attr attrName) {
CHECK(attrs_)((attrs_) || (Fortran::common::die("CHECK(" "attrs_" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 1791)
, false));
if (IsConflictingAttr(attrName) || IsDuplicateAttr(attrName)) {
  return false;
}
attrs_->set(attrName);
return true;
1797}

1799// DeclTypeSpecVisitor implementation

1801const DeclTypeSpec *DeclTypeSpecVisitor::GetDeclTypeSpec() {
return state_.declTypeSpec;
1803}

1805void DeclTypeSpecVisitor::BeginDeclTypeSpec() {
CHECK(!state_.expectDeclTypeSpec)((!state_.expectDeclTypeSpec) || (Fortran::common::die("CHECK("
 "!state_.expectDeclTypeSpec" ") failed" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 1806), false));
CHECK(!state_.declTypeSpec)((!state_.declTypeSpec) || (Fortran::common::die("CHECK(" "!state_.declTypeSpec"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 1807), false));
state_.expectDeclTypeSpec = true;
1809}
1810void DeclTypeSpecVisitor::EndDeclTypeSpec() {
CHECK(state_.expectDeclTypeSpec)((state_.expectDeclTypeSpec) || (Fortran::common::die("CHECK("
 "state_.expectDeclTypeSpec" ") failed" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 1811), false));
state_ = {};
1813}

1815void DeclTypeSpecVisitor::SetDeclTypeSpecCategory(
  DeclTypeSpec::Category category) {
CHECK(state_.expectDeclTypeSpec)((state_.expectDeclTypeSpec) || (Fortran::common::die("CHECK("
 "state_.expectDeclTypeSpec" ") failed" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 1817), false));
state_.derived.category = category;
1819}

1821bool DeclTypeSpecVisitor::Pre(const parser::TypeGuardStmt &) {
BeginDeclTypeSpec();
return true;
1824}
1825void DeclTypeSpecVisitor::Post(const parser::TypeGuardStmt &) {
EndDeclTypeSpec();
1827}

1829void 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}) {
  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()}) {
      CheckForAbstractType(derived->typeSymbol()); // C703
      typeSpec.declTypeSpec = spec;
    }
    break;
  default:
    CRASH_NO_CASEFortran::common::die("no case" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 1848);
  }
}
1851}

1853void DeclTypeSpecVisitor::Post(
  const parser::IntrinsicTypeSpec::DoublePrecision &) {
MakeNumericType(TypeCategory::Real, context().doublePrecisionKind());
1856}
1857void DeclTypeSpecVisitor::Post(
  const parser::IntrinsicTypeSpec::DoubleComplex &) {
MakeNumericType(TypeCategory::Complex, context().doublePrecisionKind());
1860}
1861void DeclTypeSpecVisitor::MakeNumericType(TypeCategory category, int kind) {
SetDeclTypeSpec(context().MakeNumericType(category, kind));
1863}

1865void DeclTypeSpecVisitor::CheckForAbstractType(const Symbol &typeSymbol) {
if (typeSymbol.attrs().test(Attr::ABSTRACT)) {
  Say("ABSTRACT derived type may not be used here"_err_en_US);
}
1869}

1871void DeclTypeSpecVisitor::Post(const parser::DeclarationTypeSpec::ClassStar &) {
SetDeclTypeSpec(context().globalScope().MakeClassStarType());
1873}
1874void DeclTypeSpecVisitor::Post(const parser::DeclarationTypeSpec::TypeStar &) {
SetDeclTypeSpec(context().globalScope().MakeTypeStarType());
1876}

1878// Check that we're expecting to see a DeclTypeSpec (and haven't seen one yet)
1879// and save it in state_.declTypeSpec.
1880void DeclTypeSpecVisitor::SetDeclTypeSpec(const DeclTypeSpec &declTypeSpec) {
CHECK(state_.expectDeclTypeSpec)((state_.expectDeclTypeSpec) || (Fortran::common::die("CHECK("
 "state_.expectDeclTypeSpec" ") failed" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 1881), false));
CHECK(!state_.declTypeSpec)((!state_.declTypeSpec) || (Fortran::common::die("CHECK(" "!state_.declTypeSpec"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 1882), false));
state_.declTypeSpec = &declTypeSpec;
1884}

1886KindExpr DeclTypeSpecVisitor::GetKindParamExpr(
  TypeCategory category, const std::optional<parser::KindSelector> &kind) {
return AnalyzeKindSelector(context(), category, kind);
1889}

1891// MessageHandler implementation

1893Message &MessageHandler::Say(MessageFixedText &&msg) {
return context_->Say(currStmtSource().value(), std::move(msg));
1895}
1896Message &MessageHandler::Say(MessageFormattedText &&msg) {
return context_->Say(currStmtSource().value(), std::move(msg));
1898}
1899Message &MessageHandler::Say(const SourceName &name, MessageFixedText &&msg) {
return Say(name, std::move(msg), name);
1901}

1903// ImplicitRulesVisitor implementation

1905void ImplicitRulesVisitor::Post(const parser::ParameterStmt &) {
prevParameterStmt_ = currStmtSource();
1907}

1909bool ImplicitRulesVisitor::Pre(const parser::ImplicitStmt &x) {
bool result{
    common::visit(common::visitors{
                      [&](const std::list<ImplicitNoneNameSpec> &y) {
                        return HandleImplicitNone(y);
                      },
                      [&](const std::list<parser::ImplicitSpec> &) {
                        if (prevImplicitNoneType_) {
                          Say("IMPLICIT statement after IMPLICIT NONE or "
                              "IMPLICIT NONE(TYPE) statement"_err_en_US);
                          return false;
                        }
                        implicitRules_->set_isImplicitNoneType(false);
                        return true;
                      },
                  },
        x.u)};
prevImplicit_ = currStmtSource();
return result;
1928}

1930bool ImplicitRulesVisitor::Pre(const parser::LetterSpec &x) {
auto loLoc{std::get<parser::Location>(x.t)};
auto hiLoc{loLoc};
if (auto hiLocOpt{std::get<std::optional<parser::Location>>(x.t)}) {
  hiLoc = *hiLocOpt;
  if (*hiLoc < *loLoc) {
    Say(hiLoc, "'%s' does not follow '%s' alphabetically"_err_en_US,
        std::string(hiLoc, 1), std::string(loLoc, 1));
    return false;
  }
}
implicitRules_->SetTypeMapping(*GetDeclTypeSpec(), loLoc, hiLoc);
return false;
1943}

1945bool ImplicitRulesVisitor::Pre(const parser::ImplicitSpec &) {
BeginDeclTypeSpec();
set_allowForwardReferenceToDerivedType(true);
return true;
1949}

1951void ImplicitRulesVisitor::Post(const parser::ImplicitSpec &) {
EndDeclTypeSpec();
1953}

1955void ImplicitRulesVisitor::SetScope(const Scope &scope) {
implicitRules_ = &DEREF(implicitRulesMap_)Fortran::common::Deref(implicitRulesMap_, "flang/lib/Semantics/resolve-names.cpp"
, 1956).at(&scope);
prevImplicit_ = std::nullopt;
prevImplicitNone_ = std::nullopt;
prevImplicitNoneType_ = std::nullopt;
prevParameterStmt_ = std::nullopt;
1961}
1962void ImplicitRulesVisitor::BeginScope(const Scope &scope) {
// find or create implicit rules for this scope
DEREF(implicitRulesMap_)Fortran::common::Deref(implicitRulesMap_, "flang/lib/Semantics/resolve-names.cpp"
, 1964).try_emplace(&scope, context(), implicitRules_);
SetScope(scope);
1966}

1968// TODO: for all of these errors, reference previous statement too
1969bool ImplicitRulesVisitor::HandleImplicitNone(
  const std::list<ImplicitNoneNameSpec> &nameSpecs) {
if (prevImplicitNone_) {
  Say("More than one IMPLICIT NONE statement"_err_en_US);
  Say(*prevImplicitNone_, "Previous IMPLICIT NONE statement"_en_US);
  return false;
}
if (prevParameterStmt_) {
  Say("IMPLICIT NONE statement after PARAMETER statement"_err_en_US);
  return false;
}
prevImplicitNone_ = currStmtSource();
bool implicitNoneTypeNever{
    context().IsEnabled(common::LanguageFeature::ImplicitNoneTypeNever)};
if (nameSpecs.empty()) {
  if (!implicitNoneTypeNever) {
    prevImplicitNoneType_ = currStmtSource();
    implicitRules_->set_isImplicitNoneType(true);
    if (prevImplicit_) {
      Say("IMPLICIT NONE statement after IMPLICIT statement"_err_en_US);
      return false;
    }
  }
} else {
  int sawType{0};
  int sawExternal{0};
  for (const auto noneSpec : nameSpecs) {
    switch (noneSpec) {
    case ImplicitNoneNameSpec::External:
      implicitRules_->set_isImplicitNoneExternal(true);
      ++sawExternal;
      break;
    case ImplicitNoneNameSpec::Type:
      if (!implicitNoneTypeNever) {
        prevImplicitNoneType_ = currStmtSource();
        implicitRules_->set_isImplicitNoneType(true);
        if (prevImplicit_) {
          Say("IMPLICIT NONE(TYPE) after IMPLICIT statement"_err_en_US);
          return false;
        }
        ++sawType;
      }
      break;
    }
  }
  if (sawType > 1) {
    Say("TYPE specified more than once in IMPLICIT NONE statement"_err_en_US);
    return false;
  }
  if (sawExternal > 1) {
    Say("EXTERNAL specified more than once in IMPLICIT NONE statement"_err_en_US);
    return false;
  }
}
return true;
2024}

2026// ArraySpecVisitor implementation

2028void ArraySpecVisitor::Post(const parser::ArraySpec &x) {
CHECK(arraySpec_.empty())((arraySpec_.empty()) || (Fortran::common::die("CHECK(" "arraySpec_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2029), false));
arraySpec_ = AnalyzeArraySpec(context(), x);
2031}
2032void ArraySpecVisitor::Post(const parser::ComponentArraySpec &x) {
CHECK(arraySpec_.empty())((arraySpec_.empty()) || (Fortran::common::die("CHECK(" "arraySpec_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2033), false));
arraySpec_ = AnalyzeArraySpec(context(), x);
2035}
2036void ArraySpecVisitor::Post(const parser::CoarraySpec &x) {
CHECK(coarraySpec_.empty())((coarraySpec_.empty()) || (Fortran::common::die("CHECK(" "coarraySpec_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2037), false));
coarraySpec_ = AnalyzeCoarraySpec(context(), x);
2039}

2041const ArraySpec &ArraySpecVisitor::arraySpec() {
return !arraySpec_.empty() ? arraySpec_ : attrArraySpec_;
2043}
2044const ArraySpec &ArraySpecVisitor::coarraySpec() {
return !coarraySpec_.empty() ? coarraySpec_ : attrCoarraySpec_;
2046}
2047void ArraySpecVisitor::BeginArraySpec() {
CHECK(arraySpec_.empty())((arraySpec_.empty()) || (Fortran::common::die("CHECK(" "arraySpec_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2048), false));
CHECK(coarraySpec_.empty())((coarraySpec_.empty()) || (Fortran::common::die("CHECK(" "coarraySpec_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2049), false));
CHECK(attrArraySpec_.empty())((attrArraySpec_.empty()) || (Fortran::common::die("CHECK(" "attrArraySpec_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2050), false));
CHECK(attrCoarraySpec_.empty())((attrCoarraySpec_.empty()) || (Fortran::common::die("CHECK("
 "attrCoarraySpec_.empty()" ") failed" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 2051), false));
2052}
2053void ArraySpecVisitor::EndArraySpec() {
CHECK(arraySpec_.empty())((arraySpec_.empty()) || (Fortran::common::die("CHECK(" "arraySpec_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2054), false));
CHECK(coarraySpec_.empty())((coarraySpec_.empty()) || (Fortran::common::die("CHECK(" "coarraySpec_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2055), false));
attrArraySpec_.clear();
attrCoarraySpec_.clear();
2058}
2059void ArraySpecVisitor::PostAttrSpec() {
// Save dimension/codimension from attrs so we can process array/coarray-spec
// on the entity-decl
if (!arraySpec_.empty()) {
  if (attrArraySpec_.empty()) {
    attrArraySpec_ = arraySpec_;
    arraySpec_.clear();
  } else {
    Say(currStmtSource().value(),
        "Attribute 'DIMENSION' cannot be used more than once"_err_en_US);
  }
}
if (!coarraySpec_.empty()) {
  if (attrCoarraySpec_.empty()) {
    attrCoarraySpec_ = coarraySpec_;
    coarraySpec_.clear();
  } else {
    Say(currStmtSource().value(),
        "Attribute 'CODIMENSION' cannot be used more than once"_err_en_US);
  }
}
2080}

2082// FuncResultStack implementation

2084FuncResultStack::~FuncResultStack() { CHECK(stack_.empty())((stack_.empty()) || (Fortran::common::die("CHECK(" "stack_.empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2084), false)); }

2086void FuncResultStack::CompleteFunctionResultType() {
// If the function has a type in the prefix, process it now.
FuncInfo *info{Top()};
if (info && &info->scope == &scopeHandler_.currScope()) {
  if (info->parsedType && info->resultSymbol) {
    scopeHandler_.messageHandler().set_currStmtSource(info->source);
    if (const auto *type{
            scopeHandler_.ProcessTypeSpec(*info->parsedType, true)}) {
      Symbol &symbol{*info->resultSymbol};
      if (!scopeHandler_.context().HasError(symbol)) {
        if (symbol.GetType()) {
          scopeHandler_.Say(symbol.name(),
              "Function cannot have both an explicit type prefix and a RESULT suffix"_err_en_US);
          scopeHandler_.context().SetError(symbol);
        } else {
          symbol.SetType(*type);
        }
      }
    }
    info->parsedType = nullptr;
  }
}
2108}

2110// Called from ConvertTo{Object/Proc}Entity to cope with any appearance
2111// of the function result in a specification expression.
2112void FuncResultStack::CompleteTypeIfFunctionResult(Symbol &symbol) {
if (FuncInfo * info{Top()}) {
  if (info->resultSymbol == &symbol) {
    CompleteFunctionResultType();
  }
}
2118}

2120void FuncResultStack::Pop() {
if (!stack_.empty() && &stack_.back().scope == &scopeHandler_.currScope()) {
  stack_.pop_back();
}
2124}

2126// ScopeHandler implementation

2128void ScopeHandler::SayAlreadyDeclared(const parser::Name &name, Symbol &prev) {
SayAlreadyDeclared(name.source, prev);
2130}
2131void ScopeHandler::SayAlreadyDeclared(const SourceName &name, Symbol &prev) {
if (context().HasError(prev)) {
  // don't report another error about prev
} else {
  if (const auto *details{prev.detailsIf<UseDetails>()}) {
    Say(name, "'%s' is already declared in this scoping unit"_err_en_US)
        .Attach(details->location(),
            "It is use-associated with '%s' in module '%s'"_en_US,
            details->symbol().name(), GetUsedModule(*details).name());
  } else {
    SayAlreadyDeclared(name, prev.name());
  }
  context().SetError(prev);
}
2145}
2146void ScopeHandler::SayAlreadyDeclared(
  const SourceName &name1, const SourceName &name2) {
if (name1.begin() < name2.begin()) {
  SayAlreadyDeclared(name2, name1);
} else {
  Say(name1, "'%s' is already declared in this scoping unit"_err_en_US)
      .Attach(name2, "Previous declaration of '%s'"_en_US, name2);
}
2154}

2156void ScopeHandler::SayWithReason(const parser::Name &name, Symbol &symbol,
  MessageFixedText &&msg1, Message &&msg2) {
bool isFatal{msg1.IsFatal()};
Say(name, std::move(msg1), symbol.name()).Attach(std::move(msg2));
context().SetError(symbol, isFatal);
2161}

2163void ScopeHandler::SayWithDecl(
  const parser::Name &name, Symbol &symbol, MessageFixedText &&msg) {
bool isFatal{msg.IsFatal()};
Say(name, std::move(msg), symbol.name())
    .Attach(Message{name.source,
        symbol.test(Symbol::Flag::Implicit)
            ? "Implicit declaration of '%s'"_en_US
            : "Declaration of '%s'"_en_US,
        name.source});
context().SetError(symbol, isFatal);
2173}

2175void ScopeHandler::SayLocalMustBeVariable(
  const parser::Name &name, Symbol &symbol) {
SayWithDecl(name, symbol,
    "The name '%s' must be a variable to appear"
    " in a locality-spec"_err_en_US);
2180}

2182void ScopeHandler::SayDerivedType(
  const SourceName &name, MessageFixedText &&msg, const Scope &type) {
const Symbol &typeSymbol{DEREF(type.GetSymbol())Fortran::common::Deref(type.GetSymbol(), "flang/lib/Semantics/resolve-names.cpp"
, 2184)};
Say(name, std::move(msg), name, typeSymbol.name())
    .Attach(typeSymbol.name(), "Declaration of derived type '%s'"_en_US,
        typeSymbol.name());
2188}
2189void ScopeHandler::Say2(const SourceName &name1, MessageFixedText &&msg1,
  const SourceName &name2, MessageFixedText &&msg2) {
Say(name1, std::move(msg1)).Attach(name2, std::move(msg2), name2);
2192}
2193void ScopeHandler::Say2(const SourceName &name, MessageFixedText &&msg1,
  Symbol &symbol, MessageFixedText &&msg2) {
bool isFatal{msg1.IsFatal()};
Say2(name, std::move(msg1), symbol.name(), std::move(msg2));
context().SetError(symbol, isFatal);
2198}
2199void ScopeHandler::Say2(const parser::Name &name, MessageFixedText &&msg1,
  Symbol &symbol, MessageFixedText &&msg2) {
bool isFatal{msg1.IsFatal()};
Say2(name.source, std::move(msg1), symbol.name(), std::move(msg2));
context().SetError(symbol, isFatal);
2204}

2206// This is essentially GetProgramUnitContaining(), but it can return
2207// a mutable Scope &, it ignores statement functions, and it fails
2208// gracefully for error recovery (returning the original Scope).
2209template <typename T> static T &GetInclusiveScope(T &scope) {
for (T *s{&scope}; !s->IsGlobal(); s = &s->parent()) {
  switch (s->kind()) {
  case Scope::Kind::Module:
  case Scope::Kind::MainProgram:
  case Scope::Kind::Subprogram:
  case Scope::Kind::BlockData:
    if (!s->IsStmtFunction()) {
      return *s;
    }
    break;
  default:;
  }
}
return scope;
2224}

2226Scope &ScopeHandler::InclusiveScope() { return GetInclusiveScope(currScope()); }

2228Scope *ScopeHandler::GetHostProcedure() {
Scope &parent{InclusiveScope().parent()};
switch (parent.kind()) {
case Scope::Kind::Subprogram:
  return &parent;
case Scope::Kind::MainProgram:
  return &parent;
default:
  return nullptr;
}
2238}

2240Scope &ScopeHandler::NonDerivedTypeScope() {
return currScope_->IsDerivedType() ? currScope_->parent() : *currScope_;
2242}

2244void ScopeHandler::PushScope(Scope::Kind kind, Symbol *symbol) {
PushScope(currScope().MakeScope(kind, symbol));
2246}
2247void ScopeHandler::PushScope(Scope &scope) {
currScope_ = &scope;
auto kind{currScope_->kind()};
if (kind != Scope::Kind::BlockConstruct &&
    kind != Scope::Kind::OtherConstruct) {
  BeginScope(scope);
}
// The name of a module or submodule cannot be "used" in its scope,
// as we read 19.3.1(2), so we allow the name to be used as a local
// identifier in the module or submodule too.  Same with programs
// (14.1(3)) and BLOCK DATA.
if (!currScope_->IsDerivedType() && kind != Scope::Kind::Module &&
    kind != Scope::Kind::MainProgram && kind != Scope::Kind::BlockData) {
  if (auto *symbol{scope.symbol()}) {
    // Create a dummy symbol so we can't create another one with the same
    // name. It might already be there if we previously pushed the scope.
    SourceName name{symbol->name()};
    if (!FindInScope(scope, name)) {
      auto &newSymbol{MakeSymbol(name)};
      if (kind == Scope::Kind::Subprogram) {
        // Allow for recursive references.  If this symbol is a function
        // without an explicit RESULT(), this new symbol will be discarded
        // and replaced with an object of the same name.
        newSymbol.set_details(HostAssocDetails{*symbol});
      } else {
        newSymbol.set_details(MiscDetails{MiscDetails::Kind::ScopeName});
      }
    }
  }
}
2277}
2278void ScopeHandler::PopScope() {
// Entities that are not yet classified as objects or procedures are now
// assumed to be objects.
// TODO: Statement functions
for (auto &pair : currScope()) {
  ConvertToObjectEntity(*pair.second);
}
funcResultStack_.Pop();
// If popping back into a global scope, pop back to the main global scope.
SetScope(currScope_->parent().IsGlobal() ? context().globalScope()
                                         : currScope_->parent());
2289}
2290void ScopeHandler::SetScope(Scope &scope) {
currScope_ = &scope;
ImplicitRulesVisitor::SetScope(InclusiveScope());
2293}

2295Symbol *ScopeHandler::FindSymbol(const parser::Name &name) {
return FindSymbol(currScope(), name);
2297}
2298Symbol *ScopeHandler::FindSymbol(const Scope &scope, const parser::Name &name) {
if (scope.IsDerivedType()) {
  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));
}
2313}

2315Symbol &ScopeHandler::MakeSymbol(
  Scope &scope, const SourceName &name, Attrs attrs) {
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)((pair.second) || (Fortran::common::die("CHECK(" "pair.second"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2323), false)); // name was not found, so must be able to add
  return *pair.first->second;
}
2326}
2327Symbol &ScopeHandler::MakeSymbol(const SourceName &name, Attrs attrs) {
return MakeSymbol(currScope(), name, attrs);
2329}
2330Symbol &ScopeHandler::MakeSymbol(const parser::Name &name, Attrs attrs) {
return Resolve(name, MakeSymbol(name.source, attrs));
2332}
2333Symbol &ScopeHandler::MakeHostAssocSymbol(
  const parser::Name &name, const Symbol &hostSymbol) {
Symbol &symbol{*NonDerivedTypeScope()
                    .try_emplace(name.source, HostAssocDetails{hostSymbol})
                    .first->second};
name.symbol = &symbol;
symbol.attrs() = hostSymbol.attrs(); // TODO: except PRIVATE, PUBLIC?
symbol.flags() = hostSymbol.flags();
return symbol;
2342}
2343Symbol &ScopeHandler::CopySymbol(const SourceName &name, const Symbol &symbol) {
CHECK(!FindInScope(name))((!FindInScope(name)) || (Fortran::common::die("CHECK(" "!FindInScope(name)"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 2344), false));
return MakeSymbol(currScope(), name, symbol.attrs());
2346}

2348// Look for name only in scope, not in enclosing scopes.
2349Symbol *ScopeHandler::FindInScope(
  const Scope &scope, const parser::Name &name) {
return Resolve(name, FindInScope(scope, name.source));
2352}
2353Symbol *ScopeHandler::FindInScope(const Scope &scope, const SourceName &name) {
// all variants of names, e.g. "operator(.ne.)" for "operator(/=)"
for (const std::string &n : GetAllNames(context(), name)) {
  auto it{scope.find(SourceName{n})};
  if (it != scope.end()) {
    return &*it->second;
  }
}
return nullptr;
2362}

2364// Find a component or type parameter by name in a derived type or its parents.
2365Symbol *ScopeHandler::FindInTypeOrParents(
  const Scope &scope, const parser::Name &name) {
return Resolve(name, scope.FindComponent(name.source));
2368}
2369Symbol *ScopeHandler::FindInTypeOrParents(const parser::Name &name) {
return FindInTypeOrParents(currScope(), name);
2371}

2373void ScopeHandler::EraseSymbol(const parser::Name &name) {
currScope().erase(name.source);
name.symbol = nullptr;
2376}

2378static bool NeedsType(const Symbol &symbol) {
return !symbol.GetType() &&
    common::visit(common::visitors{
                      [](const EntityDetails &) { return true; },
                      [](const ObjectEntityDetails &) { return true; },
                      [](const AssocEntityDetails &) { return true; },
                      [&](const ProcEntityDetails &p) {
                        return symbol.test(Symbol::Flag::Function) &&
                            !symbol.attrs().test(Attr::INTRINSIC) &&
                            !p.type() && !p.procInterface();
                      },
                      [](const auto &) { return false; },
                  },
        symbol.details());
2392}

2394void ScopeHandler::ApplyImplicitRules(
  Symbol &symbol, bool allowForwardReference) {
funcResultStack_.CompleteTypeIfFunctionResult(symbol);
if (context().HasError(symbol) || !NeedsType(symbol)) {
  return;
}
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;
  } else if (symbol.test(Symbol::Flag::Subroutine)) {
    functionOrSubroutineFlag = Symbol::Flag::Subroutine;
  }
  if (IsIntrinsic(symbol.name(), functionOrSubroutineFlag)) {
    // type will be determined in expression semantics
    AcquireIntrinsicProcedureFlags(symbol);
    return;
  }
}
if (allowForwardReference && ImplicitlyTypeForwardRef(symbol)) {
  return;
}
if (!context().HasError(symbol)) {
  Say(symbol.name(), "No explicit type declared for '%s'"_err_en_US);
  context().SetError(symbol);
}
2425}

2427// Extension: Allow forward references to scalar integer dummy arguments
2428// to appear in specification expressions under IMPLICIT NONE(TYPE) when
2429// what would otherwise have been their implicit type is default INTEGER.
2430bool ScopeHandler::ImplicitlyTypeForwardRef(Symbol &symbol) {
if (!inSpecificationPart_ || context().HasError(symbol) || !IsDummy(symbol) ||
    symbol.Rank() != 0 ||
    !context().languageFeatures().IsEnabled(
        common::LanguageFeature::ForwardRefDummyImplicitNone)) {
  return false;
}
const DeclTypeSpec *type{
    GetImplicitType(symbol, false /*ignore IMPLICIT NONE*/)};
if (!type || !type->IsNumeric(TypeCategory::Integer)) {
  return false;
}
auto kind{evaluate::ToInt64(type->numericTypeSpec().kind())};
if (!kind || *kind != context().GetDefaultKind(TypeCategory::Integer)) {
  return false;
}
if (!ConvertToObjectEntity(symbol)) {
  return false;
}
// TODO: check no INTENT(OUT)?
if (context().languageFeatures().ShouldWarn(
        common::LanguageFeature::ForwardRefDummyImplicitNone)) {
  Say(symbol.name(),
      "Dummy argument '%s' was used without being explicitly typed"_warn_en_US,
      symbol.name());
}
symbol.set(Symbol::Flag::Implicit);
symbol.SetType(*type);
return true;
2459}

2461// Ensure that the symbol for an intrinsic procedure is marked with
2462// the INTRINSIC attribute.  Also set PURE &/or ELEMENTAL as
2463// appropriate.
2464void ScopeHandler::AcquireIntrinsicProcedureFlags(Symbol &symbol) {
SetImplicitAttr(symbol, Attr::INTRINSIC);
switch (context().intrinsics().GetIntrinsicClass(symbol.name().ToString())) {
case evaluate::IntrinsicClass::elementalFunction:
case evaluate::IntrinsicClass::elementalSubroutine:
  SetExplicitAttr(symbol, Attr::ELEMENTAL);
  SetExplicitAttr(symbol, Attr::PURE);
  break;
case evaluate::IntrinsicClass::impureSubroutine:
  break;
default:
  SetExplicitAttr(symbol, Attr::PURE);
}
2477}

2479const DeclTypeSpec *ScopeHandler::GetImplicitType(
  Symbol &symbol, bool respectImplicitNoneType) {
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()}) {
    // Resolve any forward-referenced derived type; a quick no-op else.
    auto &instantiatable{*const_cast<DerivedTypeSpec *>(derived)};
    instantiatable.Instantiate(currScope());
  }
}
return type;
2496}

2498void ScopeHandler::CheckEntryDummyUse(SourceName source, Symbol *symbol) {
if (!inSpecificationPart_ && symbol &&
    symbol->test(Symbol::Flag::EntryDummyArgument)) {
  Say(source,
      "Dummy argument '%s' may not be used before its ENTRY statement"_err_en_US,
      symbol->name());
  symbol->set(Symbol::Flag::EntryDummyArgument, false);
}
2506}

2508// Convert symbol to be a ObjectEntity or return false if it can't be.
2509bool ScopeHandler::ConvertToObjectEntity(Symbol &symbol) {
if (symbol.has<ObjectEntityDetails>()) {
  // nothing to do
} else if (symbol.has<UnknownDetails>()) {
  // These are attributes that a name could have picked up from
  // an attribute statement or type declaration statement.
  if (symbol.attrs().HasAny({Attr::EXTERNAL, Attr::INTRINSIC})) {
    return false;
  }
  symbol.set_details(ObjectEntityDetails{});
} else if (auto *details{symbol.detailsIf<EntityDetails>()}) {
  if (symbol.attrs().HasAny({Attr::EXTERNAL, Attr::INTRINSIC})) {
    return false;
  }
  funcResultStack_.CompleteTypeIfFunctionResult(symbol);
  symbol.set_details(ObjectEntityDetails{std::move(*details)});
} else if (auto *useDetails{symbol.detailsIf<UseDetails>()}) {
  return useDetails->symbol().has<ObjectEntityDetails>();
} else if (auto *hostDetails{symbol.detailsIf<HostAssocDetails>()}) {
  return hostDetails->symbol().has<ObjectEntityDetails>();
} else {
  return false;
}
return true;
2533}
2534// Convert symbol to be a ProcEntity or return false if it can't be.
2535bool ScopeHandler::ConvertToProcEntity(Symbol &symbol) {
if (symbol.has<ProcEntityDetails>()) {
  // nothing to do
} else if (symbol.has<UnknownDetails>()) {
  symbol.set_details(ProcEntityDetails{});
} else if (auto *details{symbol.detailsIf<EntityDetails>()}) {
  if (IsFunctionResult(symbol) &&
      !(IsPointer(symbol) && symbol.attrs().test(Attr::EXTERNAL))) {
    // Don't turn function result into a procedure pointer unless both
    // POINTER and EXTERNAL
    return false;
  }
  funcResultStack_.CompleteTypeIfFunctionResult(symbol);
  symbol.set_details(ProcEntityDetails{std::move(*details)});
  if (symbol.GetType() && !symbol.test(Symbol::Flag::Implicit)) {
    CHECK(!symbol.test(Symbol::Flag::Subroutine))((!symbol.test(Symbol::Flag::Subroutine)) || (Fortran::common
::die("CHECK(" "!symbol.test(Symbol::Flag::Subroutine)" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 2550)
, false));
    symbol.set(Symbol::Flag::Function);
  }
} else if (auto *useDetails{symbol.detailsIf<UseDetails>()}) {
  return useDetails->symbol().has<ProcEntityDetails>();
} else if (auto *hostDetails{symbol.detailsIf<HostAssocDetails>()}) {
  return hostDetails->symbol().has<ProcEntityDetails>();
} else {
  return false;
}
return true;
2561}

2563const DeclTypeSpec &ScopeHandler::MakeNumericType(
  TypeCategory category, const std::optional<parser::KindSelector> &kind) {
KindExpr value{GetKindParamExpr(category, kind)};
if (auto known{evaluate::ToInt64(value)}) {
  return MakeNumericType(category, static_cast<int>(*known));
} else {
  return currScope_->MakeNumericType(category, std::move(value));
}
2571}

2573const DeclTypeSpec &ScopeHandler::MakeNumericType(
  TypeCategory category, int kind) {
return context().MakeNumericType(category, kind);
2576}

2578const DeclTypeSpec &ScopeHandler::MakeLogicalType(
  const std::optional<parser::KindSelector> &kind) {
KindExpr value{GetKindParamExpr(TypeCategory::Logical, kind)};
if (auto known{evaluate::ToInt64(value)}) {
  return MakeLogicalType(static_cast<int>(*known));
} else {
  return currScope_->MakeLogicalType(std::move(value));
}
2586}

2588const DeclTypeSpec &ScopeHandler::MakeLogicalType(int kind) {
return context().MakeLogicalType(kind);
2590}

2592void ScopeHandler::NotePossibleBadForwardRef(const parser::Name &name) {
if (inSpecificationPart_ && name.symbol) {
  auto kind{currScope().kind()};
  if ((kind == Scope::Kind::Subprogram && !currScope().IsStmtFunction()) ||
      kind == Scope::Kind::BlockConstruct) {
    bool isHostAssociated{&name.symbol->owner() == &currScope()
            ? name.symbol->has<HostAssocDetails>()
            : name.symbol->owner().Contains(currScope())};
    if (isHostAssociated) {
      specPartState_.forwardRefs.insert(name.source);
    }
  }
}
2605}

2607std::optional<SourceName> ScopeHandler::HadForwardRef(
  const Symbol &symbol) const {
auto iter{specPartState_.forwardRefs.find(symbol.name())};
if (iter != specPartState_.forwardRefs.end()) {
  return *iter;
}
return std::nullopt;
2614}

2616bool ScopeHandler::CheckPossibleBadForwardRef(const Symbol &symbol) {
if (!context().HasError(symbol)) {
  if (auto fwdRef{HadForwardRef(symbol)}) {
    const Symbol *outer{symbol.owner().FindSymbol(symbol.name())};
    if (outer && symbol.has<UseDetails>() &&
        &symbol.GetUltimate() == &outer->GetUltimate()) {
      // e.g. IMPORT of host's USE association
      return false;
    }
    Say(*fwdRef,
        "Forward reference to '%s' is not allowed in the same specification part"_err_en_US,
        *fwdRef)
        .Attach(symbol.name(), "Later declaration of '%s'"_en_US, *fwdRef);
    context().SetError(symbol);
    return true;
  }
  if (IsDummy(symbol) && isImplicitNoneType() &&
      symbol.test(Symbol::Flag::Implicit) && !context().HasError(symbol)) {
    // Dummy was implicitly typed despite IMPLICIT NONE(TYPE) in
    // ApplyImplicitRules() due to use in a specification expression,
    // and no explicit type declaration appeared later.
    Say(symbol.name(),
        "No explicit type declared for dummy argument '%s'"_err_en_US);
    context().SetError(symbol);
    return true;
  }
}
return false;
2644}

2646void ScopeHandler::MakeExternal(Symbol &symbol) {
if (!symbol.attrs().test(Attr::EXTERNAL)) {
  SetImplicitAttr(symbol, Attr::EXTERNAL);
  if (symbol.attrs().test(Attr::INTRINSIC)) { // C840
    Say(symbol.name(),
        "Symbol '%s' cannot have both EXTERNAL and INTRINSIC attributes"_err_en_US,
        symbol.name());
  }
}
2655}

2657bool ScopeHandler::CheckDuplicatedAttr(
  SourceName name, const Symbol &symbol, Attr attr) {
if (attr == Attr::SAVE || attr == Attr::BIND_C) {
  // these are checked elsewhere
} else if (symbol.attrs().test(attr)) { // C815
  if (symbol.implicitAttrs().test(attr)) {
    // Implied attribute is now confirmed explicitly
  } else {
    Say(name, "%s attribute was already specified on '%s'"_err_en_US,
        EnumToString(attr), name);
    return false;
  }
}
return true;
2671}

2673bool ScopeHandler::CheckDuplicatedAttrs(
  SourceName name, const Symbol &symbol, Attrs attrs) {
bool ok{true};
attrs.IterateOverMembers(
    [&](Attr x) { ok &= CheckDuplicatedAttr(name, symbol, x); });
return ok;
2679}

2681// ModuleVisitor implementation

2683bool ModuleVisitor::Pre(const parser::Only &x) {
common::visit(common::visitors{
                  [&](const Indirection<parser::GenericSpec> &generic) {
                    GenericSpecInfo genericSpecInfo{generic.value()};
                    AddUseOnly(genericSpecInfo.symbolName());
                    AddUse(genericSpecInfo);
                  },
                  [&](const parser::Name &name) {
                    AddUseOnly(name.source);
                    Resolve(name, AddUse(name.source, name.source).use);
                  },
                  [&](const parser::Rename &rename) { Walk(rename); },
              },
    x.u);
return false;
2698}

2700bool ModuleVisitor::Pre(const parser::Rename::Names &x) {
const auto &localName{std::get<0>(x.t)};
const auto &useName{std::get<1>(x.t)};
AddUseRename(useName.source);
SymbolRename rename{AddUse(localName.source, useName.source)};
if (rename.use) {
  EraseRenamedSymbol(*rename.use);
}
Resolve(useName, rename.use);
Resolve(localName, rename.local);
return false;
2711}
2712bool ModuleVisitor::Pre(const parser::Rename::Operators &x) {
const parser::DefinedOpName &local{std::get<0>(x.t)};
const parser::DefinedOpName &use{std::get<1>(x.t)};
GenericSpecInfo localInfo{local};
GenericSpecInfo useInfo{use};
if (IsIntrinsicOperator(context(), local.v.source)) {
  Say(local.v,
      "Intrinsic operator '%s' may not be used as a defined operator"_err_en_US);
} else if (IsLogicalConstant(context(), local.v.source)) {
  Say(local.v,
      "Logical constant '%s' may not be used as a defined operator"_err_en_US);
} else {
  SymbolRename rename{AddUse(localInfo.symbolName(), useInfo.symbolName())};
  if (rename.use) {
    EraseRenamedSymbol(*rename.use);
  }
  useInfo.Resolve(rename.use);
  localInfo.Resolve(rename.local);
}
return false;
2732}

2734// Set useModuleScope_ to the Scope of the module being used.
2735bool ModuleVisitor::Pre(const parser::UseStmt &x) {
std::optional<bool> isIntrinsic;
if (x.nature) {
  isIntrinsic = *x.nature == parser::UseStmt::ModuleNature::Intrinsic;
  AddAndCheckExplicitIntrinsicUse(x.moduleName.source, *isIntrinsic);
} else if (currScope().IsModule() && currScope().symbol() &&
    currScope().symbol()->attrs().test(Attr::INTRINSIC)) {
  // Intrinsic modules USE only other intrinsic modules
  isIntrinsic = true;
}
useModuleScope_ = FindModule(x.moduleName, isIntrinsic);
if (!useModuleScope_) {
  return false;
}
// use the name from this source file
useModuleScope_->symbol()->ReplaceName(x.moduleName.source);
return true;
2752}

2754void ModuleVisitor::Post(const parser::UseStmt &x) {
if (const auto *list{std::get_if<std::list<parser::Rename>>(&x.u)}) {
  // Not a use-only: collect the names that were used in renames,
  // then add a use for each public name that was not renamed.
  std::set<SourceName> useNames;
  for (const auto &rename : *list) {
    common::visit(common::visitors{
                      [&](const parser::Rename::Names &names) {
                        useNames.insert(std::get<1>(names.t).source);
                      },
                      [&](const parser::Rename::Operators &ops) {
                        useNames.insert(std::get<1>(ops.t).v.source);
                      },
                  },
        rename.u);
  }
  for (const auto &[name, symbol] : *useModuleScope_) {
    if (symbol->attrs().test(Attr::PUBLIC) && !IsUseRenamed(symbol->name()) &&
        (!symbol->attrs().test(Attr::INTRINSIC) ||
            symbol->has<UseDetails>()) &&
        !symbol->has<MiscDetails>() && useNames.count(name) == 0) {
      SourceName location{x.moduleName.source};
      if (auto *localSymbol{FindInScope(name)}) {
        DoAddUse(location, localSymbol->name(), *localSymbol, *symbol);
      } else {
        DoAddUse(location, location, CopySymbol(name, *symbol), *symbol);
      }
    }
  }
}
useModuleScope_ = nullptr;
2785}

2787ModuleVisitor::SymbolRename ModuleVisitor::AddUse(
  const SourceName &localName, const SourceName &useName) {
return AddUse(localName, useName, FindInScope(*useModuleScope_, useName));
2790}

2792ModuleVisitor::SymbolRename ModuleVisitor::AddUse(
  const SourceName &localName, const SourceName &useName, Symbol *useSymbol) {
if (!useModuleScope_) {
  return {}; // error occurred finding module
}
if (!useSymbol) {
  Say(useName, "'%s' not found in module '%s'"_err_en_US, MakeOpName(useName),
      useModuleScope_->GetName().value());
  return {};
}
if (useSymbol->attrs().test(Attr::PRIVATE) &&
    !FindModuleFileContaining(currScope())) {
  // Privacy is not enforced in module files so that generic interfaces
  // can be resolved to private specific procedures in specification
  // expressions.
  Say(useName, "'%s' is PRIVATE in '%s'"_err_en_US, MakeOpName(useName),
      useModuleScope_->GetName().value());
  return {};
}
auto &localSymbol{MakeSymbol(localName)};
DoAddUse(useName, localName, localSymbol, *useSymbol);
return {&localSymbol, useSymbol};
2814}

2816// symbol must be either a Use or a Generic formed by merging two uses.
2817// Convert it to a UseError with this additional location.
2818static bool ConvertToUseError(
  Symbol &symbol, const SourceName &location, const Scope &module) {
const auto *useDetails{symbol.detailsIf<UseDetails>()};
if (!useDetails) {
  if (auto *genericDetails{symbol.detailsIf<GenericDetails>()}) {
    if (!genericDetails->uses().empty()) {
      useDetails = &genericDetails->uses().at(0)->get<UseDetails>();
    }
  }
}
if (useDetails) {
  symbol.set_details(
      UseErrorDetails{*useDetails}.add_occurrence(location, module));
  return true;
} else {
  return false;
}
2835}

2837// If a symbol has previously been USE-associated and did not appear in a USE
2838// ONLY clause, erase it from the current scope.  This is needed when a name
2839// appears in a USE rename clause.
2840void ModuleVisitor::EraseRenamedSymbol(const Symbol &useSymbol) {
const SourceName &name{useSymbol.name()};
if (const Symbol * symbol{FindInScope(name)}) {
  if (auto *useDetails{symbol->detailsIf<UseDetails>()}) {
    const Symbol &moduleSymbol{useDetails->symbol()};
    if (moduleSymbol.name() == name &&
        moduleSymbol.owner() == useSymbol.owner() && IsUseRenamed(name) &&
        !IsUseOnly(name)) {
      EraseSymbol(*symbol);
    }
  }
}
2852}

2854void ModuleVisitor::DoAddUse(SourceName location, SourceName localName,
  Symbol &localSymbol, const Symbol &useSymbol) {
if (localName != useSymbol.name()) {
  EraseRenamedSymbol(useSymbol);
}
if (auto *details{localSymbol.detailsIf<UseErrorDetails>()}) {
  details->add_occurrence(location, *useModuleScope_);
  return;
}

if (localSymbol.has<UnknownDetails>()) {
  localSymbol.set_details(UseDetails{localName, useSymbol});
  localSymbol.attrs() =
      useSymbol.attrs() & ~Attrs{Attr::PUBLIC, Attr::PRIVATE};
  localSymbol.implicitAttrs() =
      localSymbol.attrs() & Attrs{Attr::ASYNCHRONOUS, Attr::VOLATILE};
  localSymbol.flags() = useSymbol.flags();
  return;
}

Symbol &localUltimate{localSymbol.GetUltimate()};
const Symbol &useUltimate{useSymbol.GetUltimate()};
if (&localUltimate == &useUltimate) {
  // use-associating the same symbol again -- ok
  return;
}

auto checkAmbiguousDerivedType{[this, location, localName](
                                   const Symbol *t1, const Symbol *t2) {
  if (!t1 || !t2) {
    return true;
  } else {
    t1 = &t1->GetUltimate();
    t2 = &t2->GetUltimate();
    if (&t1 != &t2) {
      Say(location,
          "Generic interface '%s' has ambiguous derived types from modules '%s' and '%s'"_err_en_US,
          localName, t1->owner().GetName().value(),
          t2->owner().GetName().value());
      return false;
    }
  }
}};

auto *localGeneric{localUltimate.detailsIf<GenericDetails>()};
const auto *useGeneric{useUltimate.detailsIf<GenericDetails>()};
auto combine{false};
if (localGeneric) {
  if (useGeneric) {
    if (!checkAmbiguousDerivedType(
            localGeneric->derivedType(), useGeneric->derivedType())) {
      return;
    }
    combine = true;
  } else if (useUltimate.has<DerivedTypeDetails>()) {
    if (checkAmbiguousDerivedType(
            &useUltimate, localGeneric->derivedType())) {
      combine = true;
    } else {
      return;
    }
  } else if (&useUltimate == &BypassGeneric(localUltimate).GetUltimate()) {
    return; // nothing to do; used subprogram is local's specific
  }
} else if (useGeneric) {
  if (localUltimate.has<DerivedTypeDetails>()) {
    if (checkAmbiguousDerivedType(
            &localUltimate, useGeneric->derivedType())) {
      combine = true;
    } else {
      return;
    }
  } else if (&localUltimate == &BypassGeneric(useUltimate).GetUltimate()) {
    // Local is the specific of the used generic; replace it.
    EraseSymbol(localSymbol);
    Symbol &newSymbol{MakeSymbol(localName,
        useUltimate.attrs() & ~Attrs{Attr::PUBLIC, Attr::PRIVATE},
        UseDetails{localName, useUltimate})};
    newSymbol.flags() = useSymbol.flags();
    return;
  }
} else {
  auto localClass{ClassifyProcedure(localUltimate)};
  auto useClass{ClassifyProcedure(useUltimate)};
  if (localClass == useClass &&
      (localClass == ProcedureDefinitionClass::Intrinsic ||
          localClass == ProcedureDefinitionClass::External) &&
      localUltimate.name() == useUltimate.name()) {
    auto localChars{evaluate::characteristics::Procedure::Characterize(
        localUltimate, GetFoldingContext())};
    auto useChars{evaluate::characteristics::Procedure::Characterize(
        useUltimate, GetFoldingContext())};
    if (localChars && useChars) {
      if (*localChars == *useChars) {
        // Same intrinsic or external procedure defined identically in two
        // modules
        return;
      }
    }
  }
}
if (!combine) {
  if (!ConvertToUseError(localSymbol, location, *useModuleScope_)) {
    Say(location,
        "Cannot use-associate '%s'; it is already declared in this scope"_err_en_US,
        localName)
        .Attach(localSymbol.name(), "Previous declaration of '%s'"_en_US,
            localName);
  }
  return;
}

// Two items are being use-associated from different modules
// to the same local name.  At least one of them must be a generic,
// and the other one can be a generic or a derived type.
// (It could also have been the specific of the generic, but those
// cases are handled above without needing to make a local copy of the
// generic.)

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 (localGeneric->specific()) {
      generic.set_specific(*localGeneric->specific());
    }
    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 (useGeneric->specific()) {
      if (!localGeneric->specific()) {
        localGeneric->set_specific(
            *const_cast<Symbol *>(useGeneric->specific()));
      } else if (&localGeneric->specific()->GetUltimate() !=
          &useGeneric->specific()->GetUltimate()) {
        Say(location,
            "Cannot use-associate generic interface '%s' with specific procedure of the same name when another such generic is in scope"_err_en_US,
            localName)
            .Attach(
                localSymbol.name(), "Previous USE of '%s'"_en_US, localName);
      }
    }
  } else {
    CHECK(useUltimate.has<DerivedTypeDetails>())((useUltimate.has<DerivedTypeDetails>()) || (Fortran::common
::die("CHECK(" "useUltimate.has<DerivedTypeDetails>()" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 3010)
, false));
    localGeneric->set_derivedType(
        AddGenericUse(*localGeneric, localName, useUltimate));
  }
} else {
  CHECK(useGeneric && localUltimate.has<DerivedTypeDetails>())((useGeneric && localUltimate.has<DerivedTypeDetails
>()) || (Fortran::common::die("CHECK(" "useGeneric && localUltimate.has<DerivedTypeDetails>()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 3015), false));
  CHECK(localSymbol.has<UseDetails>())((localSymbol.has<UseDetails>()) || (Fortran::common::die
("CHECK(" "localSymbol.has<UseDetails>()" ") failed" " at "
 "flang/lib/Semantics/resolve-names.cpp" "(%d)", 3016), false
));
  // Create a local copy of the use-associated generic, then extend it
  // with the local derived type.
  GenericDetails generic;
  generic.CopyFrom(*useGeneric);
  if (useGeneric->specific()) {
    generic.set_specific(*const_cast<Symbol *>(useGeneric->specific()));
  }
  EraseSymbol(localSymbol);
  Symbol &newSymbol{MakeSymbol(localName,
      useUltimate.attrs() & ~Attrs{Attr::PUBLIC, Attr::PRIVATE},
      std::move(generic))};
  newSymbol.flags() = useUltimate.flags();
  auto &newUseGeneric{newSymbol.get<GenericDetails>()};
  AddGenericUse(newUseGeneric, localName, useUltimate);
  newUseGeneric.AddUse(localSymbol);
  newUseGeneric.set_derivedType(localSymbol);
}
3034}

3036void ModuleVisitor::AddUse(const GenericSpecInfo &info) {
if (useModuleScope_) {
  const auto &name{info.symbolName()};
  auto rename{AddUse(name, name, FindInScope(*useModuleScope_, name))};
  info.Resolve(rename.use);
}
3042}

3044// Create a UseDetails symbol for this USE and add it to generic
3045Symbol &ModuleVisitor::AddGenericUse(
  GenericDetails &generic, const SourceName &name, const Symbol &useSymbol) {
Symbol &newSymbol{
    currScope().MakeSymbol(name, {}, UseDetails{name, useSymbol})};
generic.AddUse(newSymbol);
return newSymbol;
3051}

3053// Enforce C1406
3054void ModuleVisitor::AddAndCheckExplicitIntrinsicUse(
  SourceName name, bool isIntrinsic) {
if (isIntrinsic) {
  if (auto iter{explicitNonIntrinsicUses_.find(name)};
      iter != explicitNonIntrinsicUses_.end()) {
    Say(name,
        "Cannot USE,INTRINSIC module '%s' in the same scope as USE,NON_INTRINSIC"_err_en_US,
        name)
        .Attach(*iter, "Previous USE of '%s'"_en_US, *iter);
  }
  explicitIntrinsicUses_.insert(name);
} else {
  if (auto iter{explicitIntrinsicUses_.find(name)};
      iter != explicitIntrinsicUses_.end()) {
    Say(name,
        "Cannot USE,NON_INTRINSIC module '%s' in the same scope as USE,INTRINSIC"_err_en_US,
        name)
        .Attach(*iter, "Previous USE of '%s'"_en_US, *iter);
  }
  explicitNonIntrinsicUses_.insert(name);
}
3075}

3077bool ModuleVisitor::BeginSubmodule(
  const parser::Name &name, const parser::ParentIdentifier &parentId) {
const auto &ancestorName{std::get<parser::Name>(parentId.t)};
Scope *parentScope{nullptr};
Scope *ancestor{FindModule(ancestorName, false /*not intrinsic*/)};
if (ancestor) {
  if (const auto &parentName{
          std::get<std::optional<parser::Name>>(parentId.t)}) {
    parentScope = FindModule(*parentName, false /*not intrinsic*/, ancestor);
  } else {
    parentScope = ancestor;
  }
}
if (parentScope) {
  PushScope(*parentScope);
} else {
  // Error recovery: there's no ancestor scope, so create a dummy one to
  // hold the submodule's scope.
  SourceName dummyName{context().GetTempName(currScope())};
  Symbol &dummySymbol{MakeSymbol(dummyName, Attrs{}, ModuleDetails{false})};
  PushScope(Scope::Kind::Module, &dummySymbol);
  parentScope = &currScope();
}
BeginModule(name, true);
if (ancestor && !ancestor->AddSubmodule(name.source, currScope())) {
  Say(name, "Module '%s' already has a submodule named '%s'"_err_en_US,
      ancestorName.source, name.source);
}
return true;
3106}

3108void ModuleVisitor::BeginModule(const parser::Name &name, bool isSubmodule) {
auto &symbol{MakeSymbol(name, ModuleDetails{isSubmodule})};
auto &details{symbol.get<ModuleDetails>()};
PushScope(Scope::Kind::Module, &symbol);
details.set_scope(&currScope());
defaultAccess_ = Attr::PUBLIC;
prevAccessStmt_ = std::nullopt;
3115}

3117// Find a module or submodule by name and return its scope.
3118// If ancestor is present, look for a submodule of that ancestor module.
3119// May have to read a .mod file to find it.
3120// If an error occurs, report it and return nullptr.
3121Scope *ModuleVisitor::FindModule(const parser::Name &name,
  std::optional<bool> isIntrinsic, Scope *ancestor) {
ModFileReader reader{context()};
Scope *scope{reader.Read(name.source, isIntrinsic, ancestor)};
if (!scope) {
  return nullptr;
}
if (DoesScopeContain(scope, currScope())) { // 14.2.2(1)
  Say(name, "Module '%s' cannot USE itself"_err_en_US);
}
Resolve(name, scope->symbol());
return scope;
3133}

3135void ModuleVisitor::ApplyDefaultAccess() {
for (auto &pair : currScope()) {
  Symbol &symbol = *pair.second;
  if (!symbol.attrs().HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
    SetImplicitAttr(symbol, defaultAccess_);
  }
}
3142}

3144// InterfaceVistor implementation

3146bool InterfaceVisitor::Pre(const parser::InterfaceStmt &x) {
bool isAbstract{std::holds_alternative<parser::Abstract>(x.u)};
genericInfo_.emplace(/*isInterface*/ true, isAbstract);
return BeginAttrs();
3150}

3152void InterfaceVisitor::Post(const parser::InterfaceStmt &) { EndAttrs(); }

3154void InterfaceVisitor::Post(const parser::EndInterfaceStmt &) {
genericInfo_.pop();
3156}

3158// Create a symbol in genericSymbol_ for this GenericSpec.
3159bool InterfaceVisitor::Pre(const parser::GenericSpec &x) {
if (auto *symbol{FindInScope(GenericSpecInfo{x}.symbolName())}) {
  SetGenericSymbol(*symbol);
}
return false;
3164}

3166bool InterfaceVisitor::Pre(const parser::ProcedureStmt &x) {
if (!isGeneric()) {
  Say("A PROCEDURE statement is only allowed in a generic interface block"_err_en_US);
  return false;
}
auto kind{std::get<parser::ProcedureStmt::Kind>(x.t)};
const auto &names{std::get<std::list<parser::Name>>(x.t)};
AddSpecificProcs(names, kind);
return false;
3175}

3177bool InterfaceVisitor::Pre(const parser::GenericStmt &) {
genericInfo_.emplace(/*isInterface*/ false);
return true;
3180}
3181void InterfaceVisitor::Post(const parser::GenericStmt &x) {
if (auto &accessSpec{std::get<std::optional<parser::AccessSpec>>(x.t)}) {
  SetExplicitAttr(*GetGenericInfo().symbol, AccessSpecToAttr(*accessSpec));
}
const auto &names{std::get<std::list<parser::Name>>(x.t)};
AddSpecificProcs(names, ProcedureKind::Procedure);
genericInfo_.pop();
3188}

3190bool InterfaceVisitor::inInterfaceBlock() const {
return !genericInfo_.empty() && GetGenericInfo().isInterface;
3192}
3193bool InterfaceVisitor::isGeneric() const {
return !genericInfo_.empty() && GetGenericInfo().symbol;
3195}
3196bool InterfaceVisitor::isAbstract() const {
return !genericInfo_.empty() && GetGenericInfo().isAbstract;
3198}

3200void InterfaceVisitor::AddSpecificProcs(
  const std::list<parser::Name> &names, ProcedureKind kind) {
for (const auto &name : names) {
  specificProcs_.emplace(
      GetGenericInfo().symbol, std::make_pair(&name, kind));
}
3206}

3208// By now we should have seen all specific procedures referenced by name in
3209// this generic interface. Resolve those names to symbols.
3210void InterfaceVisitor::ResolveSpecificsInGeneric(Symbol &generic) {
auto &details{generic.get<GenericDetails>()};
UnorderedSymbolSet symbolsSeen;
for (const Symbol &symbol : details.specificProcs()) {
  symbolsSeen.insert(symbol.GetUltimate());
}
auto range{specificProcs_.equal_range(&generic)};
for (auto it{range.first}; it != range.second; ++it) {
  const parser::Name *name{it->second.first};
  auto kind{it->second.second};
  const auto *symbol{FindSymbol(*name)};
  if (!symbol) {
    Say(*name, "Procedure '%s' not found"_err_en_US);
    continue;
  }
  // Subtlety: when *symbol is a use- or host-association, the specific
  // procedure that is recorded in the GenericDetails below must be *symbol,
  // not the specific procedure shadowed by a generic, because that specific
  // procedure may be a symbol from another module and its name unavailable to
  // emit to a module file.
  const Symbol &bypassed{BypassGeneric(*symbol)};
  const Symbol &specific{
      symbol == &symbol->GetUltimate() ? bypassed : *symbol};
  const Symbol &ultimate{bypassed.GetUltimate()};
  ProcedureDefinitionClass defClass{ClassifyProcedure(ultimate)};
  if (defClass == ProcedureDefinitionClass::Module) {
    // ok
  } else if (kind == ProcedureKind::ModuleProcedure) {
    Say(*name, "'%s' is not a module procedure"_err_en_US);
    continue;
  } else {
    switch (defClass) {
    case ProcedureDefinitionClass::Intrinsic:
    case ProcedureDefinitionClass::External:
    case ProcedureDefinitionClass::Internal:
    case ProcedureDefinitionClass::Dummy:
    case ProcedureDefinitionClass::Pointer:
      break;
    case ProcedureDefinitionClass::None:
      Say(*name, "'%s' is not a procedure"_err_en_US);
      continue;
    default:
      Say(*name,
          "'%s' is not a procedure that can appear in a generic interface"_err_en_US);
      continue;
    }
  }
  if (symbolsSeen.insert(ultimate).second /*true if added*/) {
    // When a specific procedure is a USE association, that association
    // is saved in the generic's specifics, not its ultimate symbol,
    // so that module file output of interfaces can distinguish them.
    details.AddSpecificProc(specific, name->source);
  } else if (&specific == &ultimate) {
    Say(name->source,
        "Procedure '%s' is already specified in generic '%s'"_err_en_US,
        name->source, MakeOpName(generic.name()));
  } else {
    Say(name->source,
        "Procedure '%s' from module '%s' is already specified in generic '%s'"_err_en_US,
        ultimate.name(), ultimate.owner().GetName().value(),
        MakeOpName(generic.name()));
  }
}
specificProcs_.erase(range.first, range.second);
3274}

3276// Mixed interfaces are allowed by the standard.
3277// If there is a derived type with the same name, they must all be functions.
3278void InterfaceVisitor::CheckGenericProcedures(Symbol &generic) {
ResolveSpecificsInGeneric(generic);
auto &details{generic.get<GenericDetails>()};
if (auto *proc{details.CheckSpecific()}) {
  auto msg{
      "'%s' should not be the name of both a generic interface and a"
      " procedure unless it is a specific procedure of the generic"_warn_en_US};
  if (proc->name().begin() > generic.name().begin()) {
    Say(proc->name(), std::move(msg));
  } else {
    Say(generic.name(), std::move(msg));
  }
}
auto &specifics{details.specificProcs()};
if (specifics.empty()) {
  if (details.derivedType()) {
    generic.set(Symbol::Flag::Function);
  }
  return;
}
const Symbol &firstSpecific{specifics.front()};
bool isFunction{firstSpecific.test(Symbol::Flag::Function)};
bool isBoth{false};
for (const Symbol &specific : specifics) {
  if (isFunction != specific.test(Symbol::Flag::Function)) { // C1514
    auto &msg{Say(generic.name(),
        "Generic interface '%s' has both a function and a subroutine"_warn_en_US)};
    if (isFunction) {
      msg.Attach(firstSpecific.name(), "Function declaration"_en_US);
      msg.Attach(specific.name(), "Subroutine declaration"_en_US);
    } else {
      msg.Attach(firstSpecific.name(), "Subroutine declaration"_en_US);
      msg.Attach(specific.name(), "Function declaration"_en_US);
    }
    isFunction = false;
    isBoth = true;
    break;
  }
}
if (!isFunction && details.derivedType()) {
  SayDerivedType(generic.name(),
      "Generic interface '%s' may only contain functions due to derived type"
      " with same name"_err_en_US,
      *details.derivedType()->GetUltimate().scope());
}
if (!isBoth) {
  generic.set(isFunction ? Symbol::Flag::Function : Symbol::Flag::Subroutine);
}
3326}

3328// SubprogramVisitor implementation

3330// Return false if it is actually an assignment statement.
3331bool SubprogramVisitor::HandleStmtFunction(const parser::StmtFunctionStmt &x) {
const auto &name{std::get<parser::Name>(x.t)};
const DeclTypeSpec *resultType{nullptr};
// Look up name: provides return type or tells us if it's an array
if (auto *symbol{FindSymbol(name)}) {
  auto *details{symbol->detailsIf<EntityDetails>()};
  if (!details || symbol->has<ObjectEntityDetails>() ||
      symbol->has<ProcEntityDetails>()) {
    badStmtFuncFound_ = true;
    return false;
  }
  // TODO: check that attrs are compatible with stmt func
  resultType = details->type();
  symbol->details() = UnknownDetails{}; // will be replaced below
}
if (badStmtFuncFound_) {
  Say(name, "'%s' has not been declared as an array"_err_en_US);
  return false;
}
auto &symbol{PushSubprogramScope(name, Symbol::Flag::Function)};
symbol.set(Symbol::Flag::StmtFunction);
EraseSymbol(symbol); // removes symbol added by PushSubprogramScope
auto &details{symbol.get<SubprogramDetails>()};
for (const auto &dummyName : std::get<std::list<parser::Name>>(x.t)) {
  ObjectEntityDetails dummyDetails{true};
  if (auto *dummySymbol{FindInScope(currScope().parent(), dummyName)}) {
    if (auto *d{dummySymbol->detailsIf<EntityDetails>()}) {
      if (d->type()) {
        dummyDetails.set_type(*d->type());
      }
    }
  }
  Symbol &dummy{MakeSymbol(dummyName, std::move(dummyDetails))};
  ApplyImplicitRules(dummy);
  details.add_dummyArg(dummy);
}
ObjectEntityDetails resultDetails;
if (resultType) {
  resultDetails.set_type(*resultType);
}
resultDetails.set_funcResult(true);
Symbol &result{MakeSymbol(name, std::move(resultDetails))};
result.flags().set(Symbol::Flag::StmtFunction);
ApplyImplicitRules(result);
details.set_result(result);
// The analysis of the expression that constitutes the body of the
// statement function is deferred to FinishSpecificationPart() so that
// all declarations and implicit typing are complete.
PopScope();
return true;
3381}

3383bool SubprogramVisitor::Pre(const parser::Suffix &suffix) {
if (suffix.resultName) {
  if (IsFunction(currScope())) {
    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()}) {
      msg.Attach(subprogram->name(), "Containing subprogram"_en_US);
    }
  }
}
// LanguageBindingSpec deferred to Post(EntryStmt) or, for FunctionStmt,
// all the way to EndSubprogram().
return false;
3404}

3406bool SubprogramVisitor::Pre(const parser::PrefixSpec &x) {
// Save this to process after UseStmt and ImplicitPart
if (const auto *parsedType{std::get_if<parser::DeclarationTypeSpec>(&x.u)}) {
  FuncResultStack::FuncInfo &info{DEREF(funcResultStack().Top())Fortran::common::Deref(funcResultStack().Top(), "flang/lib/Semantics/resolve-names.cpp"
, 3409)};
  if (info.parsedType) { // C1543
    Say(currStmtSource().value(),
        "FUNCTION prefix cannot specify the type more than once"_err_en_US);
    return false;
  } else {
    info.parsedType = parsedType;
    info.source = currStmtSource();
    return false;
  }
} else {
  return true;
}
3422}

3424bool SubprogramVisitor::Pre(const parser::InterfaceBody::Subroutine &x) {
const auto &name{std::get<parser::Name>(
    std::get<parser::Statement<parser::SubroutineStmt>>(x.t).statement.t)};
return BeginSubprogram(name, Symbol::Flag::Subroutine);
3428}
3429void SubprogramVisitor::Post(const parser::InterfaceBody::Subroutine &x) {
const auto &stmt{std::get<parser::Statement<parser::SubroutineStmt>>(x.t)};
EndSubprogram(stmt.source,
    &std::get<std::optional<parser::LanguageBindingSpec>>(stmt.statement.t));
3433}
3434bool SubprogramVisitor::Pre(const parser::InterfaceBody::Function &x) {
const auto &name{std::get<parser::Name>(
    std::get<parser::Statement<parser::FunctionStmt>>(x.t).statement.t)};
return BeginSubprogram(name, Symbol::Flag::Function);
3438}
3439void SubprogramVisitor::Post(const parser::InterfaceBody::Function &x) {
const auto &stmt{std::get<parser::Statement<parser::FunctionStmt>>(x.t)};
const auto &maybeSuffix{
    std::get<std::optional<parser::Suffix>>(stmt.statement.t)};
EndSubprogram(stmt.source, maybeSuffix ? &maybeSuffix->binding : nullptr);
3444}

3446bool SubprogramVisitor::Pre(const parser::SubroutineStmt &stmt) {
BeginAttrs();
Walk(std::get<std::list<parser::PrefixSpec>>(stmt.t));
Walk(std::get<parser::Name>(stmt.t));
Walk(std::get<std::list<parser::DummyArg>>(stmt.t));
// Don't traverse the LanguageBindingSpec now; it's deferred to EndSubprogram.
Symbol &symbol{PostSubprogramStmt()};
SubprogramDetails &details{symbol.get<SubprogramDetails>()};
for (const auto &dummyArg : std::get<std::list<parser::DummyArg>>(stmt.t)) {
  if (const auto *dummyName{std::get_if<parser::Name>(&dummyArg.u)}) {
    CreateDummyArgument(details, *dummyName);
  } else {
    details.add_alternateReturn();
  }
}
return false;
3462}
3463bool SubprogramVisitor::Pre(const parser::FunctionStmt &) {
FuncResultStack::FuncInfo &info{DEREF(funcResultStack().Top())Fortran::common::Deref(funcResultStack().Top(), "flang/lib/Semantics/resolve-names.cpp"
, 3464)};
CHECK(!info.inFunctionStmt)((!info.inFunctionStmt) || (Fortran::common::die("CHECK(" "!info.inFunctionStmt"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 3465), false));
info.inFunctionStmt = true;
return BeginAttrs();
3468}
3469bool SubprogramVisitor::Pre(const parser::EntryStmt &) { return BeginAttrs(); }

3471void SubprogramVisitor::Post(const parser::FunctionStmt &stmt) {
const auto &name{std::get<parser::Name>(stmt.t)};
Symbol &symbol{PostSubprogramStmt()};
SubprogramDetails &details{symbol.get<SubprogramDetails>()};
for (const auto &dummyName : std::get<std::list<parser::Name>>(stmt.t)) {
  CreateDummyArgument(details, dummyName);
}
const parser::Name *funcResultName;
FuncResultStack::FuncInfo &info{DEREF(funcResultStack().Top())Fortran::common::Deref(funcResultStack().Top(), "flang/lib/Semantics/resolve-names.cpp"
, 3479)};
CHECK(info.inFunctionStmt)((info.inFunctionStmt) || (Fortran::common::die("CHECK(" "info.inFunctionStmt"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 3480), false));
info.inFunctionStmt = false;
bool distinctResultName{
    info.resultName && info.resultName->source != name.source};
if (distinctResultName) {
  // Note that RESULT is ignored if it has the same name as the function.
  // The symbol created by PushScope() is retained as a place-holder
  // for error detection.
  funcResultName = info.resultName;
} else {
  EraseSymbol(name); // was added by PushScope()
  funcResultName = &name;
}
if (details.isFunction()) {
  CHECK(context().HasError(currScope().symbol()))((context().HasError(currScope().symbol())) || (Fortran::common
::die("CHECK(" "context().HasError(currScope().symbol())" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 3494)
, false));
} else {
  // RESULT(x) can be the same explicitly-named RESULT(x) as an ENTRY
  // statement.
  Symbol *result{nullptr};
  if (distinctResultName) {
    if (auto iter{currScope().find(funcResultName->source)};
        iter != currScope().end()) {
      Symbol &entryResult{*iter->second};
      if (IsFunctionResult(entryResult)) {
        result = &entryResult;
      }
    }
  }
  if (result) {
    Resolve(*funcResultName, *result);
  } else {
    // add function result to function scope
    EntityDetails funcResultDetails;
    funcResultDetails.set_funcResult(true);
    result = &MakeSymbol(*funcResultName, std::move(funcResultDetails));
  }
  info.resultSymbol = result;
  details.set_result(*result);
}
// C1560.
if (info.resultName && !distinctResultName) {
  Say(info.resultName->source,
      "The function name should not appear in RESULT, references to '%s' "
      "inside the function will be considered as references to the "
      "result only"_warn_en_US,
      name.source);
  // RESULT name was ignored above, the only side effect from doing so will be
  // the inability to make recursive calls. The related parser::Name is still
  // resolved to the created function result symbol because every parser::Name
  // should be resolved to avoid internal errors.
  Resolve(*info.resultName, info.resultSymbol);
}
name.symbol = &symbol; // must not be function result symbol
// Clear the RESULT() name now in case an ENTRY statement in the implicit-part
// has a RESULT() suffix.
info.resultName = nullptr;
3536}

3538Symbol &SubprogramVisitor::PostSubprogramStmt() {
Symbol &symbol{*currScope().symbol()};
SetExplicitAttrs(symbol, EndAttrs());
if (symbol.attrs().test(Attr::MODULE)) {
  symbol.attrs().set(Attr::EXTERNAL, false);
  symbol.implicitAttrs().set(Attr::EXTERNAL, false);
}
return symbol;
3546}

3548void SubprogramVisitor::Post(const parser::EntryStmt &stmt) {
if (const auto &suffix{std::get<std::optional<parser::Suffix>>(stmt.t)}) {
  Walk(suffix->binding);
}
PostEntryStmt(stmt);
EndAttrs();
3554}

3556void SubprogramVisitor::CreateDummyArgument(
  SubprogramDetails &details, const parser::Name &name) {
Symbol *dummy{FindInScope(name)};
if (dummy) {
  if (IsDummy(*dummy)) {
    if (dummy->test(Symbol::Flag::EntryDummyArgument)) {
      dummy->set(Symbol::Flag::EntryDummyArgument, false);
    } else {
      Say(name,
          "'%s' appears more than once as a dummy argument name in this subprogram"_err_en_US,
          name.source);
      return;
    }
  } else {
    SayWithDecl(name, *dummy,
        "'%s' may not appear as a dummy argument name in this subprogram"_err_en_US);
    return;
  }
} else {
  dummy = &MakeSymbol(name, EntityDetails{true});
}
details.add_dummyArg(DEREF(dummy)Fortran::common::Deref(dummy, "flang/lib/Semantics/resolve-names.cpp"
, 3577));
3578}

3580void SubprogramVisitor::CreateEntry(
  const parser::EntryStmt &stmt, Symbol &subprogram) {
const auto &entryName{std::get<parser::Name>(stmt.t)};
Scope &outer{currScope().parent()};
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 (!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
    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;
      }
    }
  }
}
if (outer.IsModule() && !attrs.test(Attr::PRIVATE)) {
  attrs.set(Attr::PUBLIC);
}
Symbol *entrySymbol{nullptr};
if (hasGlobalBindingName) {
  // Hide the entry's symbol in a new anonymous global scope so
  // that its name doesn't clash with anything.
  Symbol &symbol{MakeSymbol(outer, context().GetTempName(outer), Attrs{})};
  symbol.set_details(MiscDetails{MiscDetails::Kind::ScopeName});
  Scope &hidden{outer.MakeScope(Scope::Kind::Global, &symbol)};
  entrySymbol = &MakeSymbol(hidden, entryName.source, attrs);
} else {
  entrySymbol = FindInScope(outer, entryName.source);
  if (entrySymbol) {
    if (auto *generic{entrySymbol->detailsIf<GenericDetails>()}) {
      if (auto *specific{generic->specific()}) {
        // Forward reference to ENTRY from a generic interface
        entrySymbol = specific;
        CheckDuplicatedAttrs(entryName.source, *entrySymbol, attrs);
        SetExplicitAttrs(*entrySymbol, attrs);
      }
    }
  } else {
    entrySymbol = &MakeSymbol(outer, entryName.source, attrs);
  }
}
SubprogramDetails entryDetails;
entryDetails.set_entryScope(currScope());
entrySymbol->set(subpFlag);
if (subpFlag == Symbol::Flag::Function) {
  Symbol *result{nullptr};
  EntityDetails resultDetails;
  resultDetails.set_funcResult(true);
  if (distinctResultName) {
    if (!badResultName) {
      // RESULT(x) can be the same explicitly-named RESULT(x) as
      // the enclosing function or another ENTRY.
      if (auto iter{currScope().find(suffix->resultName->source)};
          iter != currScope().end()) {
        result = &*iter->second;
      }
      if (!result) {
        result = &MakeSymbol(
            *distinctResultName, Attrs{}, std::move(resultDetails));
      }
      Resolve(*suffix->resultName, *result);
    }
  } else {
    result = &MakeSymbol(entryName.source, Attrs{}, std::move(resultDetails));
  }
  if (result) {
    entryDetails.set_result(*result);
  }
}
if (subpFlag == Symbol::Flag::Subroutine ||
    (distinctResultName && !badResultName)) {
  Symbol &assoc{MakeSymbol(entryName.source)};
  assoc.set_details(HostAssocDetails{*entrySymbol});
  assoc.set(Symbol::Flag::Subroutine);
}
Resolve(entryName, *entrySymbol);
std::set<SourceName> dummies;
for (const auto &dummyArg : std::get<std::list<parser::DummyArg>>(stmt.t)) {
  if (const auto *dummyName{std::get_if<parser::Name>(&dummyArg.u)}) {
    auto pair{dummies.insert(dummyName->source)};
    if (!pair.second) {
      Say(*dummyName,
          "'%s' appears more than once as a dummy argument name in this ENTRY statement"_err_en_US,
          dummyName->source);
      continue;
    }
    Symbol *dummy{FindInScope(*dummyName)};
    if (dummy) {
      if (!IsDummy(*dummy)) {
        evaluate::AttachDeclaration(
            Say(*dummyName,
                "'%s' may not appear as a dummy argument name in this ENTRY statement"_err_en_US,
                dummyName->source),
            *dummy);
        continue;
      }
    } else {
      dummy = &MakeSymbol(*dummyName, EntityDetails{true});
      dummy->set(Symbol::Flag::EntryDummyArgument);
    }
    entryDetails.add_dummyArg(DEREF(dummy)Fortran::common::Deref(dummy, "flang/lib/Semantics/resolve-names.cpp"
, 3713));
  } else if (subpFlag == Symbol::Flag::Function) { // C1573
    Say(entryName,
        "ENTRY in a function may not have an alternate return dummy argument"_err_en_US);
    break;
  } else {
    entryDetails.add_alternateReturn();
  }
}
entrySymbol->set_details(std::move(entryDetails));
3723}

3725void SubprogramVisitor::PostEntryStmt(const parser::EntryStmt &stmt) {
// The entry symbol should have already been created and resolved
// in CreateEntry(), called by BeginSubprogram(), with one exception (below).
const auto &name{std::get<parser::Name>(stmt.t)};
Scope &inclusiveScope{InclusiveScope()};
if (!name.symbol) {
  if (inclusiveScope.kind() != Scope::Kind::Subprogram) {
    Say(name.source,
        "ENTRY '%s' may appear only in a subroutine or function"_err_en_US,
        name.source);
  } else if (FindSeparateModuleSubprogramInterface(inclusiveScope.symbol())) {
    Say(name.source,
        "ENTRY '%s' may not appear in a separate module procedure"_err_en_US,
        name.source);
  } else {
    // C1571 - entry is nested, so was not put into the program tree; error
    // is emitted from MiscChecker in semantics.cpp.
  }
  return;
}
Symbol &entrySymbol{*name.symbol};
if (context().HasError(entrySymbol)) {
  return;
}
if (!entrySymbol.has<SubprogramDetails>()) {
  SayAlreadyDeclared(name, entrySymbol);
  return;
}
SubprogramDetails &entryDetails{entrySymbol.get<SubprogramDetails>()};
CHECK(entryDetails.entryScope() == &inclusiveScope)((entryDetails.entryScope() == &inclusiveScope) || (Fortran
::common::die("CHECK(" "entryDetails.entryScope() == &inclusiveScope"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 3754), false));
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 (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);
        }
        dummy->set(Symbol::Flag::EntryDummyArgument, false);
      }
    }
  }
}
3774}

3776Symbol *ScopeHandler::FindSeparateModuleProcedureInterface(
  const parser::Name &name) {
auto *symbol{FindSymbol(name)};
if (symbol && symbol->has<SubprogramNameDetails>()) {
  const Scope *parent{nullptr};
  if (currScope().IsSubmodule()) {
    parent = currScope().symbol()->get<ModuleDetails>().parent();
  }
  symbol = parent ? FindSymbol(*parent, name) : nullptr;
}
if (symbol) {
  if (auto *generic{symbol->detailsIf<GenericDetails>()}) {
    symbol = generic->specific();
  }
}
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;
3800}

3802// A subprogram declared with MODULE PROCEDURE
3803bool SubprogramVisitor::BeginMpSubprogram(const parser::Name &name) {
Symbol *symbol{FindSeparateModuleProcedureInterface(name)};
if (!symbol) {
  return false;
}
if (symbol->owner() == currScope() && symbol->scope()) {
  // This is a MODULE PROCEDURE whose interface appears in its host.
  // Convert the module procedure's interface into a subprogram.
  SetScope(DEREF(symbol->scope())Fortran::common::Deref(symbol->scope(), "flang/lib/Semantics/resolve-names.cpp"
, 3811));
  symbol->get<SubprogramDetails>().set_isInterface(false);
} else {
  // Copy the interface into a new subprogram scope.
  EraseSymbol(name);
  Symbol &newSymbol{MakeSymbol(name, SubprogramDetails{})};
  PushScope(Scope::Kind::Subprogram, &newSymbol);
  newSymbol.get<SubprogramDetails>().set_moduleInterface(*symbol);
  newSymbol.attrs() |= symbol->attrs();
  newSymbol.set(symbol->test(Symbol::Flag::Subroutine)
          ? Symbol::Flag::Subroutine
          : Symbol::Flag::Function);
  MapSubprogramToNewSymbols(*symbol, newSymbol, currScope());
}
return true;
3826}

3828// A subprogram or interface declared with SUBROUTINE or FUNCTION
3829bool SubprogramVisitor::BeginSubprogram(const parser::Name &name,
  Symbol::Flag subpFlag, bool hasModulePrefix,
  const parser::LanguageBindingSpec *bindingSpec,
  const ProgramTree::EntryStmtList *entryStmts) {
if (hasModulePrefix && currScope().IsGlobal()) { // C1547
  Say(name,
      "'%s' is a MODULE procedure which must be declared within a "
      "MODULE or SUBMODULE"_err_en_US);
  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.
    EraseSymbol(name);
  }
}
Symbol &newSymbol{PushSubprogramScope(name, subpFlag, bindingSpec)};
if (moduleInterface) {
  newSymbol.get<SubprogramDetails>().set_moduleInterface(*moduleInterface);
  if (moduleInterface->attrs().test(Attr::PRIVATE)) {
    SetImplicitAttr(newSymbol, Attr::PRIVATE);
  } else if (moduleInterface->attrs().test(Attr::PUBLIC)) {
    SetImplicitAttr(newSymbol, Attr::PUBLIC);
  }
}
if (entryStmts) {
  for (const auto &ref : *entryStmts) {
    CreateEntry(*ref, newSymbol);
  }
}
return true;
3863}

3865void SubprogramVisitor::HandleLanguageBinding(Symbol *symbol,
  std::optional<parser::CharBlock> stmtSource,
  const std::optional<parser::LanguageBindingSpec> *binding) {
if (binding && *binding && symbol) {
  // Finally process the BIND(C,NAME=name) now that symbols in the name
  // expression will resolve to local names if needed.
  auto flagRestorer{common::ScopedSet(inSpecificationPart_, false)};
  auto originalStmtSource{messageHandler().currStmtSource()};
  messageHandler().set_currStmtSource(stmtSource);
  BeginAttrs();
  Walk(**binding);
  SetBindNameOn(*symbol);
  symbol->attrs() |= EndAttrs();
  messageHandler().set_currStmtSource(originalStmtSource);
}
3880}

3882void SubprogramVisitor::EndSubprogram(
  std::optional<parser::CharBlock> stmtSource,
  const std::optional<parser::LanguageBindingSpec> *binding,
  const ProgramTree::EntryStmtList *entryStmts) {
HandleLanguageBinding(currScope().symbol(), stmtSource, binding);
if (entryStmts) {
  for (const auto &ref : *entryStmts) {
    const parser::EntryStmt &entryStmt{*ref};
    if (const auto &suffix{
            std::get<std::optional<parser::Suffix>>(entryStmt.t)}) {
      const auto &name{std::get<parser::Name>(entryStmt.t)};
      HandleLanguageBinding(name.symbol, name.source, &suffix->binding);
    }
  }
}
PopScope();
3898}

3900bool SubprogramVisitor::HandlePreviousCalls(
  const parser::Name &name, Symbol &symbol, Symbol::Flag subpFlag) {
// If the extant symbol is a generic, check its homonymous specific
// procedure instead if it has one.
if (auto *generic{symbol.detailsIf<GenericDetails>()}) {
  return generic->specific() &&
      HandlePreviousCalls(name, *generic->specific(), subpFlag);
} else if (const auto *proc{symbol.detailsIf<ProcEntityDetails>()}; proc &&
           !proc->isDummy() &&
           !symbol.attrs().HasAny(Attrs{Attr::INTRINSIC, Attr::POINTER})) {
  // There's a symbol created for previous calls to this subprogram or
  // ENTRY's name.  We have to replace that symbol in situ to avoid the
  // obligation to rewrite symbol pointers in the parse tree.
  if (!symbol.test(subpFlag)) {
    Say2(name,
        subpFlag == Symbol::Flag::Function
            ? "'%s' was previously called as a subroutine"_err_en_US
            : "'%s' was previously called as a function"_err_en_US,
        symbol, "Previous call of '%s'"_en_US);
  }
  EntityDetails entity;
  if (proc->type()) {
    entity.set_type(*proc->type());
  }
  symbol.details() = std::move(entity);
  return true;
} else {
  return symbol.has<UnknownDetails>() || symbol.has<SubprogramNameDetails>();
}
3929}

3931void SubprogramVisitor::CheckExtantProc(
  const parser::Name &name, Symbol::Flag subpFlag) {
if (auto *prev{FindSymbol(name)}) {
  if (IsDummy(*prev)) {
  } else if (auto *entity{prev->detailsIf<EntityDetails>()};
             IsPointer(*prev) && entity && !entity->type()) {
    // POINTER attribute set before interface
  } else if (inInterfaceBlock() && currScope() != prev->owner()) {
    // Procedures in an INTERFACE block do not resolve to symbols
    // in scopes between the global scope and the current scope.
  } else if (!HandlePreviousCalls(name, *prev, subpFlag)) {
    SayAlreadyDeclared(name, *prev);
  }
}
3945}

3947Symbol &SubprogramVisitor::PushSubprogramScope(const parser::Name &name,
  Symbol::Flag subpFlag, const parser::LanguageBindingSpec *bindingSpec) {
Symbol *symbol{GetSpecificFromGeneric(name)};
if (!symbol) {
  if (bindingSpec && currScope().IsGlobal() && bindingSpec->v) {
    // Create this new top-level subprogram with a binding label
    // in a new global scope, so that its symbol's name won't clash
    // with another symbol that has a distinct binding label.
    PushScope(Scope::Kind::Global,
        &MakeSymbol(context().GetTempName(currScope()), Attrs{},
            MiscDetails{MiscDetails::Kind::ScopeName}));
  }
  CheckExtantProc(name, subpFlag);
  symbol = &MakeSymbol(name, SubprogramDetails{});
}
symbol->ReplaceName(name.source);
symbol->set(subpFlag);
PushScope(Scope::Kind::Subprogram, symbol);
if (subpFlag == Symbol::Flag::Function) {
  funcResultStack().Push(currScope());
}
if (inInterfaceBlock()) {
  auto &details{symbol->get<SubprogramDetails>()};
  details.set_isInterface();
  if (isAbstract()) {
    SetExplicitAttr(*symbol, Attr::ABSTRACT);
  } else {
    MakeExternal(*symbol);
  }
  if (isGeneric()) {
    Symbol &genericSymbol{GetGenericSymbol()};
    if (genericSymbol.has<GenericDetails>()) {
      genericSymbol.get<GenericDetails>().AddSpecificProc(
          *symbol, name.source);
    } else {
      CHECK(context().HasError(genericSymbol))((context().HasError(genericSymbol)) || (Fortran::common::die
("CHECK(" "context().HasError(genericSymbol)" ") failed" " at "
 "flang/lib/Semantics/resolve-names.cpp" "(%d)", 3982), false
));
    }
  }
  set_inheritFromParent(false);
}
FindSymbol(name)->set(subpFlag); // PushScope() created symbol
return *symbol;
3989}

3991void SubprogramVisitor::PushBlockDataScope(const parser::Name &name) {
if (auto *prev{FindSymbol(name)}) {
  if (prev->attrs().test(Attr::EXTERNAL) && prev->has<ProcEntityDetails>()) {
    if (prev->test(Symbol::Flag::Subroutine) ||
        prev->test(Symbol::Flag::Function)) {
      Say2(name, "BLOCK DATA '%s' has been called"_err_en_US, *prev,
          "Previous call of '%s'"_en_US);
    }
    EraseSymbol(name);
  }
}
if (name.source.empty()) {
  // Don't let unnamed BLOCK DATA conflict with unnamed PROGRAM
  PushScope(Scope::Kind::BlockData, nullptr);
} else {
  PushScope(Scope::Kind::BlockData, &MakeSymbol(name, SubprogramDetails{}));
}
4008}

4010// If name is a generic, return specific subprogram with the same name.
4011Symbol *SubprogramVisitor::GetSpecificFromGeneric(const parser::Name &name) {
// Search for the name but don't resolve it
if (auto *symbol{currScope().FindSymbol(name.source)}) {
  if (symbol->has<SubprogramNameDetails>()) {
    if (inInterfaceBlock()) {
      // Subtle: clear any MODULE flag so that the new interface
      // symbol doesn't inherit it and ruin the ability to check it.
      symbol->attrs().reset(Attr::MODULE);
    }
  } else if (auto *details{symbol->detailsIf<GenericDetails>()}) {
    // found generic, want specific procedure
    auto *specific{details->specific()};
    if (inInterfaceBlock()) {
      if (specific) {
        // Defining an interface in a generic of the same name which is
        // already shadowing another procedure.  In some cases, the shadowed
        // procedure is about to be replaced.
        if (specific->has<SubprogramNameDetails>() &&
            specific->attrs().test(Attr::MODULE)) {
          // The shadowed procedure is a separate module procedure that is
          // actually defined later in this (sub)module.
          // Define its interface now as a new symbol.
          specific = nullptr;
        } else if (&specific->owner() != &symbol->owner()) {
          // The shadowed procedure was from an enclosing scope and will be
          // overridden by this interface definition.
          specific = nullptr;
        }
        if (!specific) {
          details->clear_specific();
        }
      } else if (const auto *dType{details->derivedType()}) {
        if (&dType->owner() != &symbol->owner()) {
          // The shadowed derived type was from an enclosing scope and
          // will be overridden by this interface definition.
          details->clear_derivedType();
        }
      }
    }
    if (!specific) {
      specific =
          &currScope().MakeSymbol(name.source, Attrs{}, SubprogramDetails{});
      if (details->derivedType()) {
        // A specific procedure with the same name as a derived type
        SayAlreadyDeclared(name, *details->derivedType());
      } else {
        details->set_specific(Resolve(name, *specific));
      }
    } else if (isGeneric()) {
      SayAlreadyDeclared(name, *specific);
    }
    if (specific->has<SubprogramNameDetails>()) {
      specific->set_details(Details{SubprogramDetails{}});
    }
    return specific;
  }
}
return nullptr;
4069}

4071// DeclarationVisitor implementation

4073bool DeclarationVisitor::BeginDecl() {
BeginDeclTypeSpec();
BeginArraySpec();
return BeginAttrs();
4077}
4078void DeclarationVisitor::EndDecl() {
EndDeclTypeSpec();
EndArraySpec();
EndAttrs();
4082}

4084bool DeclarationVisitor::CheckUseError(const parser::Name &name) {
const auto *details{
    name.symbol ? name.symbol->detailsIf<UseErrorDetails>() : nullptr};
if (!details) {
  return false;
}
Message &msg{Say(name, "Reference to '%s' is ambiguous"_err_en_US)};
for (const auto &[location, module] : details->occurrences()) {
  msg.Attach(location, "'%s' was use-associated from module '%s'"_en_US,
      name.source, module->GetName().value());
}
context().SetError(*name.symbol);
return true;
4097}

4099// Report error if accessibility of symbol doesn't match isPrivate.
4100void DeclarationVisitor::CheckAccessibility(
  const SourceName &name, bool isPrivate, Symbol &symbol) {
if (symbol.attrs().test(Attr::PRIVATE) != isPrivate) {
  Say2(name,
      "'%s' does not have the same accessibility as its previous declaration"_err_en_US,
      symbol, "Previous declaration of '%s'"_en_US);
}
4107}

4109void DeclarationVisitor::Post(const parser::TypeDeclarationStmt &) {
EndDecl();
4111}

4113void DeclarationVisitor::Post(const parser::DimensionStmt::Declaration &x) {
DeclareObjectEntity(std::get<parser::Name>(x.t));
4115}
4116void DeclarationVisitor::Post(const parser::CodimensionDecl &x) {
DeclareObjectEntity(std::get<parser::Name>(x.t));
4118}

4120bool DeclarationVisitor::Pre(const parser::Initialization &) {
// Defer inspection of initializers to Initialization() so that the
// symbol being initialized will be available within the initialization
// expression.
return false;
4125}

4127void DeclarationVisitor::Post(const parser::EntityDecl &x) {
const auto &name{std::get<parser::ObjectName>(x.t)};
Attrs attrs{attrs_ ? HandleSaveName(name.source, *attrs_) : Attrs{}};
Symbol &symbol{DeclareUnknownEntity(name, attrs)};
symbol.ReplaceName(name.source);
if (const auto &init{std::get<std::optional<parser::Initialization>>(x.t)}) {
  ConvertToObjectEntity(symbol) || ConvertToProcEntity(symbol);
  symbol.set(
      Symbol::Flag::EntryDummyArgument, false); // forestall excessive errors
  Initialization(name, *init, false);
} else if (attrs.test(Attr::PARAMETER)) { // C882, C883
  Say(name, "Missing initialization for parameter '%s'"_err_en_US);
}
4140}

4142void DeclarationVisitor::Post(const parser::PointerDecl &x) {
const auto &name{std::get<parser::Name>(x.t)};
if (const auto &deferredShapeSpecs{
        std::get<std::optional<parser::DeferredShapeSpecList>>(x.t)}) {
  CHECK(arraySpec().empty())((arraySpec().empty()) || (Fortran::common::die("CHECK(" "arraySpec().empty()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 4146), false));
  BeginArraySpec();
  set_arraySpec(AnalyzeDeferredShapeSpecList(context(), *deferredShapeSpecs));
  Symbol &symbol{DeclareObjectEntity(name, Attrs{Attr::POINTER})};
  symbol.ReplaceName(name.source);
  EndArraySpec();
} else {
  if (const auto *symbol{FindInScope(name)}) {
    const auto *subp{symbol->detailsIf<SubprogramDetails>()};
    if (!symbol->has<UseDetails>() && // error caught elsewhere
        !symbol->has<ObjectEntityDetails>() &&
        !symbol->has<ProcEntityDetails>() &&
        !symbol->CanReplaceDetails(ObjectEntityDetails{}) &&
        !symbol->CanReplaceDetails(ProcEntityDetails{}) &&
        !(subp && subp->isInterface())) {
      Say(name, "'%s' cannot have the POINTER attribute"_err_en_US);
    }
  }
  HandleAttributeStmt(Attr::POINTER, std::get<parser::Name>(x.t));
}
4166}

4168bool DeclarationVisitor::Pre(const parser::BindEntity &x) {
auto kind{std::get<parser::BindEntity::Kind>(x.t)};
auto &name{std::get<parser::Name>(x.t)};
Symbol *symbol;
if (kind == parser::BindEntity::Kind::Object) {
  symbol = &HandleAttributeStmt(Attr::BIND_C, name);
} else {
  symbol = &MakeCommonBlockSymbol(name);
  SetExplicitAttr(*symbol, Attr::BIND_C);
}
// 8.6.4(1)
// Some entities such as named constant or module name need to checked
// elsewhere. This is to skip the ICE caused by setting Bind name for non-name
// things such as data type and also checks for procedures.
if (symbol->has<CommonBlockDetails>() || symbol->has<ObjectEntityDetails>() ||
    symbol->has<EntityDetails>()) {
  SetBindNameOn(*symbol);
} else {
  Say(name,
      "Only variable and named common block can be in BIND statement"_err_en_US);
}
return false;
4190}
4191bool DeclarationVisitor::Pre(const parser::OldParameterStmt &x) {
inOldStyleParameterStmt_ = true;
Walk(x.v);
inOldStyleParameterStmt_ = false;
return false;
4196}
4197bool DeclarationVisitor::Pre(const parser::NamedConstantDef &x) {
auto &name{std::get<parser::NamedConstant>(x.t).v};
auto &symbol{HandleAttributeStmt(Attr::PARAMETER, name)};
if (!ConvertToObjectEntity(symbol) ||
    symbol.test(Symbol::Flag::CrayPointer) ||
    symbol.test(Symbol::Flag::CrayPointee)) {
  SayWithDecl(
      name, symbol, "PARAMETER attribute not allowed on '%s'"_err_en_US);
  return false;
}
const auto &expr{std::get<parser::ConstantExpr>(x.t)};
auto &details{symbol.get<ObjectEntityDetails>()};
if (inOldStyleParameterStmt_) {
  // non-standard extension PARAMETER statement (no parentheses)
  Walk(expr);
  auto folded{EvaluateExpr(expr)};
  if (details.type()) {
    SayWithDecl(name, symbol,
        "Alternative style PARAMETER '%s' must not already have an explicit type"_err_en_US);
  } else if (folded) {
    auto at{expr.thing.value().source};
    if (evaluate::IsActuallyConstant(*folded)) {
      if (const auto *type{currScope().GetType(*folded)}) {
        if (type->IsPolymorphic()) {
          Say(at, "The expression must not be polymorphic"_err_en_US);
        } else if (auto shape{ToArraySpec(
                       GetFoldingContext(), evaluate::GetShape(*folded))}) {
          // The type of the named constant is assumed from the expression.
          details.set_type(*type);
          details.set_init(std::move(*folded));
          details.set_shape(std::move(*shape));
        } else {
          Say(at, "The expression must have constant shape"_err_en_US);
        }
      } else {
        Say(at, "The expression must have a known type"_err_en_US);
      }
    } else {
      Say(at, "The expression must be a constant of known type"_err_en_US);
    }
  }
} else {
  // standard-conforming PARAMETER statement (with parentheses)
  ApplyImplicitRules(symbol);
  Walk(expr);
  if (auto converted{EvaluateNonPointerInitializer(
          symbol, expr, expr.thing.value().source)}) {
    details.set_init(std::move(*converted));
  }
}
return false;
4248}
4249bool DeclarationVisitor::Pre(const parser::NamedConstant &x) {
const parser::Name &name{x.v};
if (!FindSymbol(name)) {
  Say(name, "Named constant '%s' not found"_err_en_US);
} else {
  CheckUseError(name);
}
return false;
4257}

4259bool DeclarationVisitor::Pre(const parser::Enumerator &enumerator) {
const parser::Name &name{std::get<parser::NamedConstant>(enumerator.t).v};
Symbol *symbol{FindInScope(name)};
if (symbol && !symbol->has<UnknownDetails>()) {
  // Contrary to named constants appearing in a PARAMETER statement,
  // enumerator names should not have their type, dimension or any other
  // attributes defined before they are declared in the enumerator statement,
  // with the exception of accessibility.
  // This is not explicitly forbidden by the standard, but they are scalars
  // which type is left for the compiler to chose, so do not let users try to
  // tamper with that.
  SayAlreadyDeclared(name, *symbol);
  symbol = nullptr;
} else {
  // Enumerators are treated as PARAMETER (section 7.6 paragraph (4))
  symbol = &MakeSymbol(name, Attrs{Attr::PARAMETER}, ObjectEntityDetails{});
  symbol->SetType(context().MakeNumericType(
      TypeCategory::Integer, evaluate::CInteger::kind));
}

if (auto &init{std::get<std::optional<parser::ScalarIntConstantExpr>>(
        enumerator.t)}) {
  Walk(*init); // Resolve names in expression before evaluation.
  if (auto value{EvaluateInt64(context(), *init)}) {
    // Cast all init expressions to C_INT so that they can then be
    // safely incremented (see 7.6 Note 2).
    enumerationState_.value = static_cast<int>(*value);
  } else {
    Say(name,
        "Enumerator value could not be computed "
        "from the given expression"_err_en_US);
    // Prevent resolution of next enumerators value
    enumerationState_.value = std::nullopt;
  }
}

if (symbol) {
  if (enumerationState_.value) {
    symbol->get<ObjectEntityDetails>().set_init(SomeExpr{
        evaluate::Expr<evaluate::CInteger>{*enumerationState_.value}});
  } else {
    context().SetError(*symbol);
  }
}

if (enumerationState_.value) {
  (*enumerationState_.value)++;
}
return false;
4308}

4310void DeclarationVisitor::Post(const parser::EnumDef &) {
enumerationState_ = EnumeratorState{};
4312}

4314bool DeclarationVisitor::Pre(const parser::AccessSpec &x) {
Attr attr{AccessSpecToAttr(x)};
if (!NonDerivedTypeScope().IsModule()) { // C817
  Say(currStmtSource().value(),
      "%s attribute may only appear in the specification part of a module"_err_en_US,
      EnumToString(attr));
}
CheckAndSet(attr);
return false;
4323}

4325bool DeclarationVisitor::Pre(const parser::AsynchronousStmt &x) {
return HandleAttributeStmt(Attr::ASYNCHRONOUS, x.v);
4327}
4328bool DeclarationVisitor::Pre(const parser::ContiguousStmt &x) {
return HandleAttributeStmt(Attr::CONTIGUOUS, x.v);
4330}
4331bool DeclarationVisitor::Pre(const parser::ExternalStmt &x) {
HandleAttributeStmt(Attr::EXTERNAL, x.v);
for (const auto &name : x.v) {
  auto *symbol{FindSymbol(name)};
  if (!ConvertToProcEntity(DEREF(symbol)Fortran::common::Deref(symbol, "flang/lib/Semantics/resolve-names.cpp"
, 4335))) {
    SayWithDecl(
        name, *symbol, "EXTERNAL attribute not allowed on '%s'"_err_en_US);
  } else if (symbol->attrs().test(Attr::INTRINSIC)) { // C840
    Say(symbol->name(),
        "Symbol '%s' cannot have both INTRINSIC and EXTERNAL attributes"_err_en_US,
        symbol->name());
  }
}
return false;
4345}
4346bool DeclarationVisitor::Pre(const parser::IntentStmt &x) {
auto &intentSpec{std::get<parser::IntentSpec>(x.t)};
auto &names{std::get<std::list<parser::Name>>(x.t)};
return CheckNotInBlock("INTENT") && // C1107
    HandleAttributeStmt(IntentSpecToAttr(intentSpec), names);
4351}
4352bool DeclarationVisitor::Pre(const parser::IntrinsicStmt &x) {
HandleAttributeStmt(Attr::INTRINSIC, x.v);
for (const auto &name : x.v) {
  if (!IsIntrinsic(name.source, std::nullopt)) {
    Say(name.source, "'%s' is not a known intrinsic procedure"_err_en_US);
  }
  auto &symbol{DEREF(FindSymbol(name))Fortran::common::Deref(FindSymbol(name), "flang/lib/Semantics/resolve-names.cpp"
, 4358)};
  if (symbol.has<GenericDetails>()) {
    // Generic interface is extending intrinsic; ok
  } else if (!ConvertToProcEntity(symbol)) {
    SayWithDecl(
        name, symbol, "INTRINSIC attribute not allowed on '%s'"_err_en_US);
  } else if (symbol.attrs().test(Attr::EXTERNAL)) { // C840
    Say(symbol.name(),
        "Symbol '%s' cannot have both EXTERNAL and INTRINSIC attributes"_err_en_US,
        symbol.name());
  } else if (symbol.GetType()) {
    // These warnings are worded so that they should make sense in either
    // order.
    Say(symbol.name(),
        "Explicit type declaration ignored for intrinsic function '%s'"_warn_en_US,
        symbol.name())
        .Attach(name.source,
            "INTRINSIC statement for explicitly-typed '%s'"_en_US,
            name.source);
  }
}
return false;
4380}
4381bool DeclarationVisitor::Pre(const parser::OptionalStmt &x) {
return CheckNotInBlock("OPTIONAL") && // C1107
    HandleAttributeStmt(Attr::OPTIONAL, x.v);
4384}
4385bool DeclarationVisitor::Pre(const parser::ProtectedStmt &x) {
return HandleAttributeStmt(Attr::PROTECTED, x.v);
4387}
4388bool DeclarationVisitor::Pre(const parser::ValueStmt &x) {
return CheckNotInBlock("VALUE") && // C1107
    HandleAttributeStmt(Attr::VALUE, x.v);
4391}
4392bool DeclarationVisitor::Pre(const parser::VolatileStmt &x) {
return HandleAttributeStmt(Attr::VOLATILE, x.v);
4394}
4395// Handle a statement that sets an attribute on a list of names.
4396bool DeclarationVisitor::HandleAttributeStmt(
  Attr attr, const std::list<parser::Name> &names) {
for (const auto &name : names) {
  HandleAttributeStmt(attr, name);
}
return false;
4402}
4403Symbol &DeclarationVisitor::HandleAttributeStmt(
  Attr attr, const parser::Name &name) {
auto *symbol{FindInScope(name)};
if (attr == Attr::ASYNCHRONOUS || attr == Attr::VOLATILE) {
  // these can be set on a symbol that is host-assoc or use-assoc
  if (!symbol &&
      (currScope().kind() == Scope::Kind::Subprogram ||
          currScope().kind() == Scope::Kind::BlockConstruct)) {
    if (auto *hostSymbol{FindSymbol(name)}) {
      symbol = &MakeHostAssocSymbol(name, *hostSymbol);
    }
  }
} else if (symbol && symbol->has<UseDetails>()) {
  Say(currStmtSource().value(),
      "Cannot change %s attribute on use-associated '%s'"_err_en_US,
      EnumToString(attr), name.source);
  return *symbol;
}
if (!symbol) {
  symbol = &MakeSymbol(name, EntityDetails{});
}
if (CheckDuplicatedAttr(name.source, *symbol, attr)) {
  SetExplicitAttr(*symbol, attr);
  symbol->attrs() = HandleSaveName(name.source, symbol->attrs());
}
return *symbol;
4429}
4430// C1107
4431bool DeclarationVisitor::CheckNotInBlock(const char *stmt) {
if (currScope().kind() == Scope::Kind::BlockConstruct) {
  Say(MessageFormattedText{
      "%s statement is not allowed in a BLOCK construct"_err_en_US, stmt});
  return false;
} else {
  return true;
}
4439}

4441void DeclarationVisitor::Post(const parser::ObjectDecl &x) {
CHECK(objectDeclAttr_)((objectDeclAttr_) || (Fortran::common::die("CHECK(" "objectDeclAttr_"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 4442), false));
const auto &name{std::get<parser::ObjectName>(x.t)};
DeclareObjectEntity(name, Attrs{*objectDeclAttr_});
4445}

4447// Declare an entity not yet known to be an object or proc.
4448Symbol &DeclarationVisitor::DeclareUnknownEntity(
  const parser::Name &name, Attrs attrs) {
if (!arraySpec().empty() || !coarraySpec().empty()) {
  return DeclareObjectEntity(name, attrs);
} else {
  Symbol &symbol{DeclareEntity<EntityDetails>(name, attrs)};
  if (auto *type{GetDeclTypeSpec()}) {
    SetType(name, *type);
  }
  charInfo_.length.reset();
  if (symbol.attrs().test(Attr::EXTERNAL)) {
    ConvertToProcEntity(symbol);
  }
  SetBindNameOn(symbol);
  return symbol;
}
4464}

4466bool DeclarationVisitor::HasCycle(
  const Symbol &procSymbol, const Symbol *interface) {
SourceOrderedSymbolSet procsInCycle;
procsInCycle.insert(procSymbol);
while (interface) {
  if (procsInCycle.count(*interface) > 0) {
    for (const auto &procInCycle : procsInCycle) {
      Say(procInCycle->name(),
          "The interface for procedure '%s' is recursively "
          "defined"_err_en_US,
          procInCycle->name());
      context().SetError(*procInCycle);
    }
    return true;
  } else if (const auto *procDetails{
                 interface->detailsIf<ProcEntityDetails>()}) {
    procsInCycle.insert(*interface);
    interface = procDetails->procInterface();
  } else {
    break;
  }
}
return false;
4489}

4491Symbol &DeclarationVisitor::DeclareProcEntity(
  const parser::Name &name, Attrs attrs, const Symbol *interface) {
Symbol &symbol{DeclareEntity<ProcEntityDetails>(name, attrs)};
if (auto *details{symbol.detailsIf<ProcEntityDetails>()}) {
  if (details->IsInterfaceSet()) {
    SayWithDecl(name, symbol,
        "The interface for procedure '%s' has already been "
        "declared"_err_en_US);
    context().SetError(symbol);
  } else if (HasCycle(symbol, interface)) {
    return symbol;
  } else if (interface) {
    details->set_procInterface(*interface);
    if (interface->test(Symbol::Flag::Function)) {
      symbol.set(Symbol::Flag::Function);
    } else if (interface->test(Symbol::Flag::Subroutine)) {
      symbol.set(Symbol::Flag::Subroutine);
    }
  } else if (auto *type{GetDeclTypeSpec()}) {
    SetType(name, *type);
    symbol.set(Symbol::Flag::Function);
  }
  SetBindNameOn(symbol);
  SetPassNameOn(symbol);
}
return symbol;
4517}

4519Symbol &DeclarationVisitor::DeclareObjectEntity(
  const parser::Name &name, Attrs attrs) {
Symbol &symbol{DeclareEntity<ObjectEntityDetails>(name, attrs)};
if (auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
  if (auto *type{GetDeclTypeSpec()}) {
    SetType(name, *type);
  }
  if (!arraySpec().empty()) {
    if (details->IsArray()) {
      if (!context().HasError(symbol)) {
        Say(name,
            "The dimensions of '%s' have already been declared"_err_en_US);
        context().SetError(symbol);
      }
    } else {
      details->set_shape(arraySpec());
    }
  }
  if (!coarraySpec().empty()) {
    if (details->IsCoarray()) {
      if (!context().HasError(symbol)) {
        Say(name,
            "The codimensions of '%s' have already been declared"_err_en_US);
        context().SetError(symbol);
      }
    } else {
      details->set_coshape(coarraySpec());
    }
  }
  SetBindNameOn(symbol);
}
ClearArraySpec();
ClearCoarraySpec();
charInfo_.length.reset();
return symbol;
4554}

4556void DeclarationVisitor::Post(const parser::IntegerTypeSpec &x) {
SetDeclTypeSpec(MakeNumericType(TypeCategory::Integer, x.v));
4558}
4559void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Real &x) {
SetDeclTypeSpec(MakeNumericType(TypeCategory::Real, x.kind));
4561}
4562void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Complex &x) {
SetDeclTypeSpec(MakeNumericType(TypeCategory::Complex, x.kind));
4564}
4565void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Logical &x) {
SetDeclTypeSpec(MakeLogicalType(x.kind));
4567}
4568void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Character &) {
if (!charInfo_.length) {
  charInfo_.length = ParamValue{1, common::TypeParamAttr::Len};
}
if (!charInfo_.kind) {
  charInfo_.kind =
      KindExpr{context().GetDefaultKind(TypeCategory::Character)};
}
SetDeclTypeSpec(currScope().MakeCharacterType(
    std::move(*charInfo_.length), std::move(*charInfo_.kind)));
charInfo_ = {};
4579}
4580void DeclarationVisitor::Post(const parser::CharSelector::LengthAndKind &x) {
charInfo_.kind = EvaluateSubscriptIntExpr(x.kind);
std::optional<std::int64_t> intKind{ToInt64(charInfo_.kind)};
if (intKind &&
    !context().targetCharacteristics().IsTypeEnabled(
        TypeCategory::Character, *intKind)) { // C715, C719
  Say(currStmtSource().value(),
      "KIND value (%jd) not valid for CHARACTER"_err_en_US, *intKind);
  charInfo_.kind = std::nullopt; // prevent further errors
}
if (x.length) {
  charInfo_.length = GetParamValue(*x.length, common::TypeParamAttr::Len);
}
4593}
4594void DeclarationVisitor::Post(const parser::CharLength &x) {
if (const auto *length{std::get_if<std::uint64_t>(&x.u)}) {
  charInfo_.length = ParamValue{
      static_cast<ConstantSubscript>(*length), common::TypeParamAttr::Len};
} else {
  charInfo_.length = GetParamValue(
      std::get<parser::TypeParamValue>(x.u), common::TypeParamAttr::Len);
}
4602}
4603void DeclarationVisitor::Post(const parser::LengthSelector &x) {
if (const auto *param{std::get_if<parser::TypeParamValue>(&x.u)}) {
  charInfo_.length = GetParamValue(*param, common::TypeParamAttr::Len);
}
4607}

4609bool DeclarationVisitor::Pre(const parser::KindParam &x) {
if (const auto *kind{std::get_if<
        parser::Scalar<parser::Integer<parser::Constant<parser::Name>>>>(
        &x.u)}) {
  const parser::Name &name{kind->thing.thing.thing};
  if (!FindSymbol(name)) {
    Say(name, "Parameter '%s' not found"_err_en_US);
  }
}
return false;
4619}

4621bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Type &) {
CHECK(GetDeclTypeSpecCategory() == DeclTypeSpec::Category::TypeDerived)((GetDeclTypeSpecCategory() == DeclTypeSpec::Category::TypeDerived
) || (Fortran::common::die("CHECK(" "GetDeclTypeSpecCategory() == DeclTypeSpec::Category::TypeDerived"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 4622), false));
return true;
4624}

4626void DeclarationVisitor::Post(const parser::DeclarationTypeSpec::Type &type) {
const parser::Name &derivedName{std::get<parser::Name>(type.derived.t)};
if (const Symbol * derivedSymbol{derivedName.symbol}) {
  CheckForAbstractType(*derivedSymbol); // C706
}
4631}

4633bool DeclarationVisitor::Pre(const parser::DeclarationTypeSpec::Class &) {
SetDeclTypeSpecCategory(DeclTypeSpec::Category::ClassDerived);
return true;
4636}

4638void DeclarationVisitor::Post(
  const parser::DeclarationTypeSpec::Class &parsedClass) {
const auto &typeName{std::get<parser::Name>(parsedClass.derived.t)};
if (auto spec{ResolveDerivedType(typeName)};
    spec && !IsExtensibleType(&*spec)) { // C705
  SayWithDecl(typeName, *typeName.symbol,
      "Non-extensible derived type '%s' may not be used with CLASS"
      " keyword"_err_en_US);
}
4647}

4649void DeclarationVisitor::Post(const parser::DerivedTypeSpec &x) {
const auto &typeName{std::get<parser::Name>(x.t)};
auto spec{ResolveDerivedType(typeName)};
if (!spec) {
  return;
}
bool seenAnyName{false};
for (const auto &typeParamSpec :
    std::get<std::list<parser::TypeParamSpec>>(x.t)) {
  const auto &optKeyword{
      std::get<std::optional<parser::Keyword>>(typeParamSpec.t)};
  std::optional<SourceName> name;
  if (optKeyword) {
    seenAnyName = true;
    name = optKeyword->v.source;
  } else if (seenAnyName) {
    Say(typeName.source, "Type parameter value must have a name"_err_en_US);
    continue;
  }
  const auto &value{std::get<parser::TypeParamValue>(typeParamSpec.t)};
  // The expressions in a derived type specifier whose values define
  // non-defaulted type parameters are evaluated (folded) in the enclosing
  // scope.  The KIND/LEN distinction is resolved later in
  // DerivedTypeSpec::CookParameters().
  ParamValue param{GetParamValue(value, common::TypeParamAttr::Kind)};
  if (!param.isExplicit() || param.GetExplicit()) {
    spec->AddRawParamValue(
        common::GetPtrFromOptional(optKeyword), std::move(param));
  }
}
// The DerivedTypeSpec *spec is used initially as a search key.
// If it turns out to have the same name and actual parameter
// value expressions as another DerivedTypeSpec in the current
// scope does, then we'll use that extant spec; otherwise, when this
// spec is distinct from all derived types previously instantiated
// in the current scope, this spec will be moved into that collection.
const auto &dtDetails{spec->typeSymbol().get<DerivedTypeDetails>()};
auto category{GetDeclTypeSpecCategory()};
if (dtDetails.isForwardReferenced()) {
  DeclTypeSpec &type{currScope().MakeDerivedType(category, std::move(*spec))};
  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)}) {
  // 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()) {
    // Defer instantiation; use the derived type's definition's scope.
    derived.set_scope(DEREF(spec->typeSymbol().scope())Fortran::common::Deref(spec->typeSymbol().scope(), "flang/lib/Semantics/resolve-names.cpp"
, 4708));
  } else if (&currScope() == spec->typeSymbol().scope()) {
    // Direct recursive use of a type in the definition of one of its
    // components: defer instantiation
  } else {
    auto restorer{
        GetFoldingContext().messages().SetLocation(currStmtSource().value())};
    derived.Instantiate(currScope());
  }
  SetDeclTypeSpec(type);
}
// Capture the DerivedTypeSpec in the parse tree for use in building
// structure constructor expressions.
x.derivedTypeSpec = &GetDeclTypeSpec()->derivedTypeSpec();
4722}

4724void 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(
          *spec, DeclTypeSpec::TypeDerived)}) {
    SetDeclTypeSpec(*extant);
  } else {
    Say(typeName.source, "%s is not a known STRUCTURE"_err_en_US,
        typeName.source);
  }
}
4738}

4740// The descendents of DerivedTypeDef in the parse tree are visited directly
4741// in this Pre() routine so that recursive use of the derived type can be
4742// supported in the components.
4743bool DeclarationVisitor::Pre(const parser::DerivedTypeDef &x) {
auto &stmt{std::get<parser::Statement<parser::DerivedTypeStmt>>(x.t)};
Walk(stmt);
Walk(std::get<std::list<parser::Statement<parser::TypeParamDefStmt>>>(x.t));
auto &scope{currScope()};
CHECK(scope.symbol())((scope.symbol()) || (Fortran::common::die("CHECK(" "scope.symbol()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 4748), false));
CHECK(scope.symbol()->scope() == &scope)((scope.symbol()->scope() == &scope) || (Fortran::common
::die("CHECK(" "scope.symbol()->scope() == &scope" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 4749)
, false));
auto &details{scope.symbol()->get<DerivedTypeDetails>()};
details.set_isForwardReferenced(false);
std::set<SourceName> paramNames;
for (auto &paramName : std::get<std::list<parser::Name>>(stmt.statement.t)) {
  details.add_paramName(paramName.source);
  auto *symbol{FindInScope(scope, paramName)};
  if (!symbol) {
    Say(paramName,
        "No definition found for type parameter '%s'"_err_en_US); // C742
    // No symbol for a type param.  Create one and mark it as containing an
    // error to improve subsequent semantic processing
    BeginAttrs();
    Symbol *typeParam{MakeTypeSymbol(
        paramName, TypeParamDetails{common::TypeParamAttr::Len})};
    context().SetError(*typeParam);
    EndAttrs();
  } else if (!symbol->has<TypeParamDetails>()) {
    Say2(paramName, "'%s' is not defined as a type parameter"_err_en_US,
        *symbol, "Definition of '%s'"_en_US); // C741
  }
  if (!paramNames.insert(paramName.source).second) {
    Say(paramName,
        "Duplicate type parameter name: '%s'"_err_en_US); // C731
  }
}
for (const auto &[name, symbol] : currScope()) {
  if (symbol->has<TypeParamDetails>() && !paramNames.count(name)) {
    SayDerivedType(name,
        "'%s' is not a type parameter of this derived type"_err_en_US,
        currScope()); // C741
  }
}
Walk(std::get<std::list<parser::Statement<parser::PrivateOrSequence>>>(x.t));
const auto &componentDefs{
    std::get<std::list<parser::Statement<parser::ComponentDefStmt>>>(x.t)};
Walk(componentDefs);
if (derivedTypeInfo_.sequence) {
  details.set_sequence(true);
  if (componentDefs.empty()) { // C740
    Say(stmt.source,
        "A sequence type must have at least one component"_err_en_US);
  }
  if (!details.paramNames().empty()) { // C740
    Say(stmt.source,
        "A sequence type may not have type parameters"_err_en_US);
  }
  if (derivedTypeInfo_.extends) { // C735
    Say(stmt.source,
        "A sequence type may not have the EXTENDS attribute"_err_en_US);
  }
}
Walk(std::get<std::optional<parser::TypeBoundProcedurePart>>(x.t));
Walk(std::get<parser::Statement<parser::EndTypeStmt>>(x.t));
derivedTypeInfo_ = {};
PopScope();
return false;
4806}

4808bool DeclarationVisitor::Pre(const parser::DerivedTypeStmt &) {
return BeginAttrs();
4810}
4811void DeclarationVisitor::Post(const parser::DerivedTypeStmt &x) {
auto &name{std::get<parser::Name>(x.t)};
// Resolve the EXTENDS() clause before creating the derived
// type's symbol to foil attempts to recursively extend a type.
auto *extendsName{derivedTypeInfo_.extends};
std::optional<DerivedTypeSpec> extendsType{
    ResolveExtendsType(name, extendsName)};
auto &symbol{MakeSymbol(name, GetAttrs(), DerivedTypeDetails{})};
symbol.ReplaceName(name.source);
derivedTypeInfo_.type = &symbol;
PushScope(Scope::Kind::DerivedType, &symbol);
if (extendsType) {
  // Declare the "parent component"; private if the type is.
  // Any symbol stored in the EXTENDS() clause is temporarily
  // hidden so that a new symbol can be created for the parent
  // component without producing spurious errors about already
  // existing.
  const Symbol &extendsSymbol{extendsType->typeSymbol()};
  auto restorer{common::ScopedSet(extendsName->symbol, nullptr)};
  if (OkToAddComponent(*extendsName, &extendsSymbol)) {
    auto &comp{DeclareEntity<ObjectEntityDetails>(*extendsName, Attrs{})};
    comp.attrs().set(
        Attr::PRIVATE, extendsSymbol.attrs().test(Attr::PRIVATE));
    comp.implicitAttrs().set(
        Attr::PRIVATE, extendsSymbol.implicitAttrs().test(Attr::PRIVATE));
    comp.set(Symbol::Flag::ParentComp);
    DeclTypeSpec &type{currScope().MakeDerivedType(
        DeclTypeSpec::TypeDerived, std::move(*extendsType))};
    type.derivedTypeSpec().set_scope(*extendsSymbol.scope());
    comp.SetType(type);
    DerivedTypeDetails &details{symbol.get<DerivedTypeDetails>()};
    details.add_component(comp);
  }
}
EndAttrs();
4846}

4848void 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})}) {
    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));
        }
      }
    }
  }
}
EndDecl();
4867}
4868bool DeclarationVisitor::Pre(const parser::TypeAttrSpec::Extends &x) {
if (derivedTypeInfo_.extends) {
  Say(currStmtSource().value(),
      "Attribute 'EXTENDS' cannot be used more than once"_err_en_US);
} else {
  derivedTypeInfo_.extends = &x.v;
}
return false;
4876}

4878bool DeclarationVisitor::Pre(const parser::PrivateStmt &) {
if (!currScope().parent().IsModule()) {
  Say("PRIVATE is only allowed in a derived type that is"
      " in a module"_err_en_US); // C766
} else if (derivedTypeInfo_.sawContains) {
  derivedTypeInfo_.privateBindings = true;
} else if (!derivedTypeInfo_.privateComps) {
  derivedTypeInfo_.privateComps = true;
} else {
  Say("PRIVATE may not appear more than once in"
      " derived type components"_warn_en_US); // C738
}
return false;
4891}
4892bool DeclarationVisitor::Pre(const parser::SequenceStmt &) {
if (derivedTypeInfo_.sequence) {
  Say("SEQUENCE may not appear more than once in"
      " derived type components"_warn_en_US); // C738
}
derivedTypeInfo_.sequence = true;
return false;
4899}
4900void DeclarationVisitor::Post(const parser::ComponentDecl &x) {
const auto &name{std::get<parser::Name>(x.t)};
auto attrs{GetAttrs()};
if (derivedTypeInfo_.privateComps &&
    !attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
  attrs.set(Attr::PRIVATE);
}
if (const auto *declType{GetDeclTypeSpec()}) {
  if (const auto *derived{declType->AsDerived()}) {
    if (!attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
      if (derivedTypeInfo_.type == &derived->typeSymbol()) { // C744
        Say("Recursive use of the derived type requires "
            "POINTER or ALLOCATABLE"_err_en_US);
      }
    }
    // TODO: This would be more appropriate in CheckDerivedType()
    if (auto it{FindCoarrayUltimateComponent(*derived)}) { // C748
      std::string ultimateName{it.BuildResultDesignatorName()};
      // Strip off the leading "%"
      if (ultimateName.length() > 1) {
        ultimateName.erase(0, 1);
        if (attrs.HasAny({Attr::POINTER, Attr::ALLOCATABLE})) {
          evaluate::AttachDeclaration(
              Say(name.source,
                  "A component with a POINTER or ALLOCATABLE attribute may "
                  "not "
                  "be of a type with a coarray ultimate component (named "
                  "'%s')"_err_en_US,
                  ultimateName),
              derived->typeSymbol());
        }
        if (!arraySpec().empty() || !coarraySpec().empty()) {
          evaluate::AttachDeclaration(
              Say(name.source,
                  "An array or coarray component may not be of a type with a "
                  "coarray ultimate component (named '%s')"_err_en_US,
                  ultimateName),
              derived->typeSymbol());
        }
      }
    }
  }
}
if (OkToAddComponent(name)) {
  auto &symbol{DeclareObjectEntity(name, attrs)};
  if (symbol.has<ObjectEntityDetails>()) {
    if (auto &init{std::get<std::optional<parser::Initialization>>(x.t)}) {
      Initialization(name, *init, true);
    }
  }
  currScope().symbol()->get<DerivedTypeDetails>().add_component(symbol);
}
ClearArraySpec();
ClearCoarraySpec();
4954}
4955void DeclarationVisitor::Post(const parser::FillDecl &x) {
// Replace "%FILL" with a distinct generated name
const auto &name{std::get<parser::Name>(x.t)};
const_cast<SourceName &>(name.source) = context().GetTempName(currScope());
if (OkToAddComponent(name)) {
  auto &symbol{DeclareObjectEntity(name, GetAttrs())};
  currScope().symbol()->get<DerivedTypeDetails>().add_component(symbol);
}
ClearArraySpec();
4964}
4965bool DeclarationVisitor::Pre(const parser::ProcedureDeclarationStmt &x) {
CHECK(!interfaceName_)((!interfaceName_) || (Fortran::common::die("CHECK(" "!interfaceName_"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 4966), false));
const auto &procAttrSpec{std::get<std::list<parser::ProcAttrSpec>>(x.t)};
for (const parser::ProcAttrSpec &procAttr : procAttrSpec) {
  if (auto *bindC{std::get_if<parser::LanguageBindingSpec>(&procAttr.u)}) {
    if (bindC->v.has_value()) {
      hasBindCName_ = true;
      break;
    }
  }
}
return BeginDecl();
4977}
4978void DeclarationVisitor::Post(const parser::ProcedureDeclarationStmt &) {
interfaceName_ = nullptr;
hasBindCName_ = false;
EndDecl();
4982}
4983bool DeclarationVisitor::Pre(const parser::DataComponentDefStmt &x) {
// Overrides parse tree traversal so as to handle attributes first,
// so POINTER & ALLOCATABLE enable forward references to derived types.
Walk(std::get<std::list<parser::ComponentAttrSpec>>(x.t));
set_allowForwardReferenceToDerivedType(
    GetAttrs().HasAny({Attr::POINTER, Attr::ALLOCATABLE}));
Walk(std::get<parser::DeclarationTypeSpec>(x.t));
set_allowForwardReferenceToDerivedType(false);
if (derivedTypeInfo_.sequence) { // C740
  if (const auto *declType{GetDeclTypeSpec()}) {
    if (!declType->AsIntrinsic() && !declType->IsSequenceType() &&
        !InModuleFile()) {
      if (GetAttrs().test(Attr::POINTER) &&
          context().IsEnabled(common::LanguageFeature::PointerInSeqType)) {
        if (context().ShouldWarn(common::LanguageFeature::PointerInSeqType)) {
          Say("A sequence type data component that is a pointer to a non-sequence type is not standard"_port_en_US);
        }
      } else {
        Say("A sequence type data component must either be of an intrinsic type or a derived sequence type"_err_en_US);
      }
    }
  }
}
Walk(std::get<std::list<parser::ComponentOrFill>>(x.t));
return false;
5008}
5009bool DeclarationVisitor::Pre(const parser::ProcComponentDefStmt &) {
CHECK(!interfaceName_)((!interfaceName_) || (Fortran::common::die("CHECK(" "!interfaceName_"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 5010), false));
return true;
5012}
5013void DeclarationVisitor::Post(const parser::ProcComponentDefStmt &) {
interfaceName_ = nullptr;
5015}
5016bool DeclarationVisitor::Pre(const parser::ProcPointerInit &x) {
if (auto *name{std::get_if<parser::Name>(&x.u)}) {
  return !NameIsKnownOrIntrinsic(*name) && !CheckUseError(*name);
} else {
  const auto &null{DEREF(std::get_if<parser::NullInit>(&x.u))Fortran::common::Deref(std::get_if<parser::NullInit>(&
x.u), "flang/lib/Semantics/resolve-names.cpp", 5020)};
  Walk(null);
  if (auto nullInit{EvaluateExpr(null)}) {
    if (!evaluate::IsNullPointer(*nullInit)) {
      Say(null.v.value().source,
          "Procedure pointer initializer must be a name or intrinsic NULL()"_err_en_US);
    }
  }
  return false;
}
5030}
5031void DeclarationVisitor::Post(const parser::ProcInterface &x) {
if (auto *name{std::get_if<parser::Name>(&x.u)}) {
  interfaceName_ = name;
  NoteInterfaceName(*name);
}
5036}
5037void 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()}) {
  dtDetails = symbol->detailsIf<DerivedTypeDetails>();
}
if (!dtDetails) {
  attrs.set(Attr::EXTERNAL);
}
Symbol &symbol{DeclareProcEntity(name, attrs, procInterface)};
symbol.ReplaceName(name.source);
if (dtDetails) {
  dtDetails->add_component(symbol);
}
if (hasBindCName_ && (IsPointer(symbol) || IsDummy(symbol))) {
  Say(symbol.name(),
      "BIND(C) procedure with NAME= specified can neither have POINTER attribute nor be a dummy procedure"_err_en_US);
}
5060}

5062bool DeclarationVisitor::Pre(const parser::TypeBoundProcedurePart &) {
derivedTypeInfo_.sawContains = true;
return true;
5065}

5067// Resolve binding names from type-bound generics, saved in genericBindings_.
5068void DeclarationVisitor::Post(const parser::TypeBoundProcedurePart &) {
// track specifics seen for the current generic to detect duplicates:
const Symbol *currGeneric{nullptr};
std::set<SourceName> specifics;
for (const auto &[generic, bindingName] : genericBindings_) {
  if (generic != currGeneric) {
7
←
Assuming 'currGeneric' is equal to generic→
8
←
Assuming pointer value is null→
9
←
Taking false branch→
    currGeneric = generic;
    specifics.clear();
  }
  auto [it, inserted]{specifics.insert(bindingName->source)};
  if (!inserted) {
10
←
Assuming the condition is true→
11
←
Taking true branch→
    Say(*bindingName, // C773
        "Binding name '%s' was already specified for generic '%s'"_err_en_US,
        bindingName->source, generic->name())
12
←
Called C++ object pointer is null
        .Attach(*it, "Previous specification of '%s'"_en_US, *it);
    continue;
  }
  auto *symbol{FindInTypeOrParents(*bindingName)};
  if (!symbol) {
    Say(*bindingName, // C772
        "Binding name '%s' not found in this derived type"_err_en_US);
  } else if (!symbol->has<ProcBindingDetails>()) {
    SayWithDecl(*bindingName, *symbol, // C772
        "'%s' is not the name of a specific binding of this type"_err_en_US);
  } else {
    generic->get<GenericDetails>().AddSpecificProc(
        *symbol, bindingName->source);
  }
}
genericBindings_.clear();
5098}

5100void DeclarationVisitor::Post(const parser::ContainsStmt &) {
if (derivedTypeInfo_.sequence) {
  Say("A sequence type may not have a CONTAINS statement"_err_en_US); // C740
}
5104}

5106void DeclarationVisitor::Post(
  const parser::TypeBoundProcedureStmt::WithoutInterface &x) {
if (GetAttrs().test(Attr::DEFERRED)) { // C783
  Say("DEFERRED is only allowed when an interface-name is provided"_err_en_US);
}
for (auto &declaration : x.declarations) {
  auto &bindingName{std::get<parser::Name>(declaration.t)};
  auto &optName{std::get<std::optional<parser::Name>>(declaration.t)};
  const parser::Name &procedureName{optName ? *optName : bindingName};
  Symbol *procedure{FindSymbol(procedureName)};
  if (!procedure) {
    procedure = NoteInterfaceName(procedureName);
  }
  if (procedure) {
    if (auto *s{
            MakeTypeSymbol(bindingName, ProcBindingDetails{*procedure})}) {
      SetPassNameOn(*s);
      if (GetAttrs().test(Attr::DEFERRED)) {
        context().SetError(*s);
      }
    }
  }
}
5129}

5131void DeclarationVisitor::CheckBindings(
  const parser::TypeBoundProcedureStmt::WithoutInterface &tbps) {
CHECK(currScope().IsDerivedType())((currScope().IsDerivedType()) || (Fortran::common::die("CHECK("
 "currScope().IsDerivedType()" ") failed" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 5133), false));
for (auto &declaration : tbps.declarations) {
  auto &bindingName{std::get<parser::Name>(declaration.t)};
  if (Symbol * binding{FindInScope(bindingName)}) {
    if (auto *details{binding->detailsIf<ProcBindingDetails>()}) {
      const Symbol *procedure{FindSubprogram(details->symbol())};
      if (!CanBeTypeBoundProc(procedure)) {
        if (details->symbol().name() != binding->name()) {
          Say(binding->name(),
              "The binding of '%s' ('%s') must be either an accessible "
              "module procedure or an external procedure with "
              "an explicit interface"_err_en_US,
              binding->name(), details->symbol().name());
        } else {
          Say(binding->name(),
              "'%s' must be either an accessible module procedure "
              "or an external procedure with an explicit interface"_err_en_US,
              binding->name());
        }
        context().SetError(*binding);
      }
    }
  }
}
5157}

5159void 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)}) {
  for (auto &bindingName : x.bindingNames) {
    if (auto *s{
            MakeTypeSymbol(bindingName, ProcBindingDetails{*interface})}) {
      SetPassNameOn(*s);
      if (!GetAttrs().test(Attr::DEFERRED)) {
        context().SetError(*s);
      }
    }
  }
}
5175}

5177void DeclarationVisitor::Post(const parser::FinalProcedureStmt &x) {
if (currScope().IsDerivedType() && currScope().symbol()) {
  if (auto *details{currScope().symbol()->detailsIf<DerivedTypeDetails>()}) {
    for (const auto &subrName : x.v) {
      if (const auto *name{ResolveName(subrName)}) {
        auto pair{
            details->finals().emplace(name->source, DEREF(name->symbol)Fortran::common::Deref(name->symbol, "flang/lib/Semantics/resolve-names.cpp"
, 5183))};
        if (!pair.second) { // C787
          Say(name->source,
              "FINAL subroutine '%s' already appeared in this derived type"_err_en_US,
              name->source)
              .Attach(pair.first->first,
                  "earlier appearance of this FINAL subroutine"_en_US);
        }
      }
    }
  }
}
5195}

5197bool DeclarationVisitor::Pre(const parser::TypeBoundGenericStmt &x) {
const auto &accessSpec{std::get<std::optional<parser::AccessSpec>>(x.t)};
const auto &genericSpec{std::get<Indirection<parser::GenericSpec>>(x.t)};
const auto &bindingNames{std::get<std::list<parser::Name>>(x.t)};
auto info{GenericSpecInfo{genericSpec.value()}};
SourceName symbolName{info.symbolName()};
bool isPrivate{accessSpec ? accessSpec->v == parser::AccessSpec::Kind::Private
                          : derivedTypeInfo_.privateBindings};
auto *genericSymbol{FindInScope(symbolName)};
if (genericSymbol) {
  if (!genericSymbol->has<GenericDetails>()) {
    genericSymbol = nullptr; // MakeTypeSymbol will report the error below
  }
} else {
  // look in parent types:
  Symbol *inheritedSymbol{nullptr};
  for (const auto &name : GetAllNames(context(), symbolName)) {
    inheritedSymbol = currScope().FindComponent(SourceName{name});
    if (inheritedSymbol) {
      break;
    }
  }
  if (inheritedSymbol && inheritedSymbol->has<GenericDetails>()) {
    CheckAccessibility(symbolName, isPrivate, *inheritedSymbol); // C771
  }
}
if (genericSymbol) {
  CheckAccessibility(symbolName, isPrivate, *genericSymbol); // C771
} else {
  genericSymbol = MakeTypeSymbol(symbolName, GenericDetails{});
  if (!genericSymbol) {
    return false;
  }
  if (isPrivate) {
    SetExplicitAttr(*genericSymbol, Attr::PRIVATE);
  }
}
for (const parser::Name &bindingName : bindingNames) {
  genericBindings_.emplace(genericSymbol, &bindingName);
}
info.Resolve(genericSymbol);
return false;
5239}

5241// DEC STRUCTUREs are handled thus to allow for nested definitions.
5242bool DeclarationVisitor::Pre(const parser::StructureDef &def) {
const auto &structureStatement{
    std::get<parser::Statement<parser::StructureStmt>>(def.t)};
auto saveDerivedTypeInfo{derivedTypeInfo_};
derivedTypeInfo_ = {};
derivedTypeInfo_.isStructure = true;
derivedTypeInfo_.sequence = true;
Scope *previousStructure{nullptr};
if (saveDerivedTypeInfo.isStructure) {
  previousStructure = &currScope();
  PopScope();
}
const parser::StructureStmt &structStmt{structureStatement.statement};
const auto &name{std::get<std::optional<parser::Name>>(structStmt.t)};
if (!name) {
  // Construct a distinct generated name for an anonymous structure
  auto &mutableName{const_cast<std::optional<parser::Name> &>(name)};
  mutableName.emplace(
      parser::Name{context().GetTempName(currScope()), nullptr});
}
auto &symbol{MakeSymbol(*name, DerivedTypeDetails{})};
symbol.ReplaceName(name->source);
symbol.get<DerivedTypeDetails>().set_sequence(true);
symbol.get<DerivedTypeDetails>().set_isDECStructure(true);
derivedTypeInfo_.type = &symbol;
PushScope(Scope::Kind::DerivedType, &symbol);
const auto &fields{std::get<std::list<parser::StructureField>>(def.t)};
Walk(fields);
PopScope();
// Complete the definition
DerivedTypeSpec derivedTypeSpec{symbol.name(), symbol};
derivedTypeSpec.set_scope(DEREF(symbol.scope())Fortran::common::Deref(symbol.scope(), "flang/lib/Semantics/resolve-names.cpp"
, 5273));
derivedTypeSpec.CookParameters(GetFoldingContext());
derivedTypeSpec.EvaluateParameters(context());
DeclTypeSpec &type{currScope().MakeDerivedType(
    DeclTypeSpec::TypeDerived, std::move(derivedTypeSpec))};
type.derivedTypeSpec().Instantiate(currScope());
// Restore previous structure definition context, if any
derivedTypeInfo_ = saveDerivedTypeInfo;
if (previousStructure) {
  PushScope(*previousStructure);
}
// Handle any entity declarations on the STRUCTURE statement
const auto &decls{std::get<std::list<parser::EntityDecl>>(structStmt.t)};
if (!decls.empty()) {
  BeginDecl();
  SetDeclTypeSpec(type);
  Walk(decls);
  EndDecl();
}
return false;
5293}

5295bool DeclarationVisitor::Pre(const parser::Union::UnionStmt &) {
Say("support for UNION"_todo_en_US); // TODO
return true;
5298}

5300bool DeclarationVisitor::Pre(const parser::StructureField &x) {
if (std::holds_alternative<parser::Statement<parser::DataComponentDefStmt>>(
        x.u)) {
  BeginDecl();
}
return true;
5306}

5308void DeclarationVisitor::Post(const parser::StructureField &x) {
if (std::holds_alternative<parser::Statement<parser::DataComponentDefStmt>>(
        x.u)) {
  EndDecl();
}
5313}

5315bool DeclarationVisitor::Pre(const parser::AllocateStmt &) {
BeginDeclTypeSpec();
return true;
5318}
5319void DeclarationVisitor::Post(const parser::AllocateStmt &) {
EndDeclTypeSpec();
5321}

5323bool DeclarationVisitor::Pre(const parser::StructureConstructor &x) {
auto &parsedType{std::get<parser::DerivedTypeSpec>(x.t)};
const DeclTypeSpec *type{ProcessTypeSpec(parsedType)};
if (!type) {
  return false;
}
const DerivedTypeSpec *spec{type->AsDerived()};
const Scope *typeScope{spec ? spec->scope() : nullptr};
if (!typeScope) {
  return false;
}

// N.B C7102 is implicitly enforced by having inaccessible types not
// being found in resolution.
// More constraints are enforced in expression.cpp so that they
// can apply to structure constructors that have been converted
// from misparsed function references.
for (const auto &component :
    std::get<std::list<parser::ComponentSpec>>(x.t)) {
  // Visit the component spec expression, but not the keyword, since
  // we need to resolve its symbol in the scope of the derived type.
  Walk(std::get<parser::ComponentDataSource>(component.t));
  if (const auto &kw{std::get<std::optional<parser::Keyword>>(component.t)}) {
    FindInTypeOrParents(*typeScope, kw->v);
  }
}
return false;
5350}

5352bool DeclarationVisitor::Pre(const parser::BasedPointerStmt &x) {
for (const parser::BasedPointer &bp : x.v) {
  const parser::ObjectName &pointerName{std::get<0>(bp.t)};
  const parser::ObjectName &pointeeName{std::get<1>(bp.t)};
  auto *pointer{FindSymbol(pointerName)};
  if (!pointer) {
    pointer = &MakeSymbol(pointerName, ObjectEntityDetails{});
  } else if (!ConvertToObjectEntity(*pointer) || IsNamedConstant(*pointer)) {
    SayWithDecl(pointerName, *pointer, "'%s' is not a variable"_err_en_US);
  } else if (pointer->Rank() > 0) {
    SayWithDecl(pointerName, *pointer,
        "Cray pointer '%s' must be a scalar"_err_en_US);
  } else if (pointer->test(Symbol::Flag::CrayPointee)) {
    Say(pointerName,
        "'%s' cannot be a Cray pointer as it is already a Cray pointee"_err_en_US);
  }
  pointer->set(Symbol::Flag::CrayPointer);
  const DeclTypeSpec &pointerType{MakeNumericType(TypeCategory::Integer,
      context().defaultKinds().subscriptIntegerKind())};
  const auto *type{pointer->GetType()};
  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());
  }
  if (ResolveName(pointeeName)) {
    Symbol &pointee{*pointeeName.symbol};
    if (pointee.has<UseDetails>()) {
      Say(pointeeName,
          "'%s' cannot be a Cray pointee as it is use-associated"_err_en_US);
      continue;
    } else if (!ConvertToObjectEntity(pointee) || IsNamedConstant(pointee)) {
      Say(pointeeName, "'%s' is not a variable"_err_en_US);
      continue;
    } else if (pointee.test(Symbol::Flag::CrayPointer)) {
      Say(pointeeName,
          "'%s' cannot be a Cray pointee as it is already a Cray pointer"_err_en_US);
    } else if (pointee.test(Symbol::Flag::CrayPointee)) {
      Say(pointeeName,
          "'%s' was already declared as a Cray pointee"_err_en_US);
    } else {
      pointee.set(Symbol::Flag::CrayPointee);
    }
    if (const auto *pointeeType{pointee.GetType()}) {
      if (const auto *derived{pointeeType->AsDerived()}) {
        if (!derived->typeSymbol().get<DerivedTypeDetails>().sequence()) {
          Say(pointeeName,
              "Type of Cray pointee '%s' is a non-sequence derived type"_err_en_US);
        }
      }
    }
    // process the pointee array-spec, if present
    BeginArraySpec();
    Walk(std::get<std::optional<parser::ArraySpec>>(bp.t));
    const auto &spec{arraySpec()};
    if (!spec.empty()) {
      auto &details{pointee.get<ObjectEntityDetails>()};
      if (details.shape().empty()) {
        details.set_shape(spec);
      } else {
        SayWithDecl(pointeeName, pointee,
            "Array spec was already declared for '%s'"_err_en_US);
      }
    }
    ClearArraySpec();
    currScope().add_crayPointer(pointeeName.source, *pointer);
  }
}
return false;
5422}

5424bool DeclarationVisitor::Pre(const parser::NamelistStmt::Group &x) {
if (!CheckNotInBlock("NAMELIST")) { // C1107
  return false;
}
const auto &groupName{std::get<parser::Name>(x.t)};
auto *groupSymbol{FindInScope(groupName)};
if (!groupSymbol || !groupSymbol->has<NamelistDetails>()) {
  groupSymbol = &MakeSymbol(groupName, NamelistDetails{});
  groupSymbol->ReplaceName(groupName.source);
}
// Name resolution of group items is deferred to FinishNamelists()
// so that host association is handled correctly.
GetDeferredDeclarationState(true)->namelistGroups.emplace_back(&x);
return false;
5438}

5440void DeclarationVisitor::FinishNamelists() {
if (auto *deferred{GetDeferredDeclarationState()}) {
  for (const parser::NamelistStmt::Group *group : deferred->namelistGroups) {
    if (auto *groupSymbol{FindInScope(std::get<parser::Name>(group->t))}) {
      if (auto *details{groupSymbol->detailsIf<NamelistDetails>()}) {
        for (const auto &name : std::get<std::list<parser::Name>>(group->t)) {
          auto *symbol{FindSymbol(name)};
          if (!symbol) {
            symbol = &MakeSymbol(name, ObjectEntityDetails{});
            ApplyImplicitRules(*symbol);
          } else if (!ConvertToObjectEntity(*symbol)) {
            SayWithDecl(name, *symbol, "'%s' is not a variable"_err_en_US);
          }
          symbol->GetUltimate().set(Symbol::Flag::InNamelist);
          details->add_object(*symbol);
        }
      }
    }
  }
  deferred->namelistGroups.clear();
}
5461}

5463bool DeclarationVisitor::Pre(const parser::IoControlSpec &x) {
if (const auto *name{std::get_if<parser::Name>(&x.u)}) {
  auto *symbol{FindSymbol(*name)};
  if (!symbol) {
    Say(*name, "Namelist group '%s' not found"_err_en_US);
  } else if (!symbol->GetUltimate().has<NamelistDetails>()) {
    SayWithDecl(
        *name, *symbol, "'%s' is not the name of a namelist group"_err_en_US);
  }
}
return true;
5474}

5476bool DeclarationVisitor::Pre(const parser::CommonStmt::Block &x) {
CheckNotInBlock("COMMON"); // C1107
return true;
5479}

5481bool DeclarationVisitor::Pre(const parser::CommonBlockObject &) {
BeginArraySpec();
return true;
5484}

5486void DeclarationVisitor::Post(const parser::CommonBlockObject &x) {
const auto &name{std::get<parser::Name>(x.t)};
DeclareObjectEntity(name);
auto pair{specPartState_.commonBlockObjects.insert(name.source)};
if (!pair.second) {
  const SourceName &prev{*pair.first};
  Say2(name.source, "'%s' is already in a COMMON block"_err_en_US, prev,
      "Previous occurrence of '%s' in a COMMON block"_en_US);
}
5495}

5497bool DeclarationVisitor::Pre(const parser::EquivalenceStmt &x) {
// save equivalence sets to be processed after specification part
if (CheckNotInBlock("EQUIVALENCE")) { // C1107
  for (const std::list<parser::EquivalenceObject> &set : x.v) {
    specPartState_.equivalenceSets.push_back(&set);
  }
}
return false; // don't implicitly declare names yet
5505}

5507void DeclarationVisitor::CheckEquivalenceSets() {
EquivalenceSets equivSets{context()};
inEquivalenceStmt_ = true;
for (const auto *set : specPartState_.equivalenceSets) {
  const auto &source{set->front().v.value().source};
  if (set->size() <= 1) { // R871
    Say(source, "Equivalence set must have more than one object"_err_en_US);
  }
  for (const parser::EquivalenceObject &object : *set) {
    const auto &designator{object.v.value()};
    // The designator was not resolved when it was encountered so do it now.
    // AnalyzeExpr causes array sections to be changed to substrings as needed
    Walk(designator);
    if (AnalyzeExpr(context(), designator)) {
      equivSets.AddToSet(designator);
    }
  }
  equivSets.FinishSet(source);
}
inEquivalenceStmt_ = false;
for (auto &set : equivSets.sets()) {
  if (!set.empty()) {
    currScope().add_equivalenceSet(std::move(set));
  }
}
specPartState_.equivalenceSets.clear();
5533}

5535bool DeclarationVisitor::Pre(const parser::SaveStmt &x) {
if (x.v.empty()) {
  specPartState_.saveInfo.saveAll = currStmtSource();
  currScope().set_hasSAVE();
} else {
  for (const parser::SavedEntity &y : x.v) {
    auto kind{std::get<parser::SavedEntity::Kind>(y.t)};
    const auto &name{std::get<parser::Name>(y.t)};
    if (kind == parser::SavedEntity::Kind::Common) {
      MakeCommonBlockSymbol(name);
      AddSaveName(specPartState_.saveInfo.commons, name.source);
    } else {
      HandleAttributeStmt(Attr::SAVE, name);
    }
  }
}
return false;
5552}

5554void DeclarationVisitor::CheckSaveStmts() {
for (const SourceName &name : specPartState_.saveInfo.entities) {
  auto *symbol{FindInScope(name)};
  if (!symbol) {
    // error was reported
  } else if (specPartState_.saveInfo.saveAll) {
    // C889 - note that pgi, ifort, xlf do not enforce this constraint
    Say2(name,
        "Explicit SAVE of '%s' is redundant due to global SAVE statement"_warn_en_US,
        *specPartState_.saveInfo.saveAll, "Global SAVE statement"_en_US);
  } else if (auto msg{CheckSaveAttr(*symbol)}) {
    Say(name, std::move(*msg));
    context().SetError(*symbol);
  } else {
    SetSaveAttr(*symbol);
  }
}
for (const SourceName &name : specPartState_.saveInfo.commons) {
  if (auto *symbol{currScope().FindCommonBlock(name)}) {
    auto &objects{symbol->get<CommonBlockDetails>().objects()};
    if (objects.empty()) {
      if (currScope().kind() != Scope::Kind::BlockConstruct) {
        Say(name,
            "'%s' appears as a COMMON block in a SAVE statement but not in"
            " a COMMON statement"_err_en_US);
      } else { // C1108
        Say(name,
            "SAVE statement in BLOCK construct may not contain a"
            " common block name '%s'"_err_en_US);
      }
    } else {
      for (auto &object : symbol->get<CommonBlockDetails>().objects()) {
        SetSaveAttr(*object);
      }
    }
  }
}
if (specPartState_.saveInfo.saveAll) {
  // Apply SAVE attribute to applicable symbols
  for (auto pair : currScope()) {
    auto &symbol{*pair.second};
    if (!CheckSaveAttr(symbol)) {
      SetSaveAttr(symbol);
    }
  }
}
specPartState_.saveInfo = {};
5601}

5603// If SAVE attribute can't be set on symbol, return error message.
5604std::optional<MessageFixedText> DeclarationVisitor::CheckSaveAttr(
  const Symbol &symbol) {
if (IsDummy(symbol)) {
  return "SAVE attribute may not be applied to dummy argument '%s'"_err_en_US;
} else if (symbol.IsFuncResult()) {
  return "SAVE attribute may not be applied to function result '%s'"_err_en_US;
} else if (symbol.has<ProcEntityDetails>() &&
    !symbol.attrs().test(Attr::POINTER)) {
  return "Procedure '%s' with SAVE attribute must also have POINTER attribute"_err_en_US;
} else if (IsAutomatic(symbol)) {
  return "SAVE attribute may not be applied to automatic data object '%s'"_err_en_US;
} else {
  return std::nullopt;
}
5618}

5620// Record SAVEd names in specPartState_.saveInfo.entities.
5621Attrs DeclarationVisitor::HandleSaveName(const SourceName &name, Attrs attrs) {
if (attrs.test(Attr::SAVE)) {
  AddSaveName(specPartState_.saveInfo.entities, name);
}
return attrs;
5626}

5628// Record a name in a set of those to be saved.
5629void DeclarationVisitor::AddSaveName(
  std::set<SourceName> &set, const SourceName &name) {
auto pair{set.insert(name)};
if (!pair.second) {
  Say2(name, "SAVE attribute was already specified on '%s'"_warn_en_US,
      *pair.first, "Previous specification of SAVE attribute"_en_US);
}
5636}

5638// Set the SAVE attribute on symbol unless it is implicitly saved anyway.
5639void DeclarationVisitor::SetSaveAttr(Symbol &symbol) {
if (!IsSaved(symbol)) {
  SetImplicitAttr(symbol, Attr::SAVE);
}
5643}

5645// Check types of common block objects, now that they are known.
5646void DeclarationVisitor::CheckCommonBlocks() {
// check for empty common blocks
for (const auto &pair : currScope().commonBlocks()) {
  const auto &symbol{*pair.second};
  if (symbol.get<CommonBlockDetails>().objects().empty() &&
      symbol.attrs().test(Attr::BIND_C)) {
    Say(symbol.name(),
        "'%s' appears as a COMMON block in a BIND statement but not in"
        " a COMMON statement"_err_en_US);
  }
}
// check objects in common blocks
for (const auto &name : specPartState_.commonBlockObjects) {
  const auto *symbol{currScope().FindSymbol(name)};
  if (!symbol) {
    continue;
  }
  const auto &attrs{symbol->attrs()};
  if (attrs.test(Attr::ALLOCATABLE)) {
    Say(name,
        "ALLOCATABLE object '%s' may not appear in a COMMON block"_err_en_US);
  } else if (attrs.test(Attr::BIND_C)) {
    Say(name,
        "Variable '%s' with BIND attribute may not appear in a COMMON block"_err_en_US);
  } else if (IsNamedConstant(*symbol)) {
    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()}) {
    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,
            "Derived type '%s' in COMMON block must have the BIND or"
            " SEQUENCE attribute"_err_en_US);
      }
      CheckCommonBlockDerivedType(name, typeSymbol);
    }
  }
}
specPartState_.commonBlockObjects = {};
5696}

5698Symbol &DeclarationVisitor::MakeCommonBlockSymbol(const parser::Name &name) {
return Resolve(name, currScope().MakeCommonBlock(name.source));
5700}
5701Symbol &DeclarationVisitor::MakeCommonBlockSymbol(
  const std::optional<parser::Name> &name) {
if (name) {
  return MakeCommonBlockSymbol(*name);
} else {
  return MakeCommonBlockSymbol(parser::Name{});
}
5708}

5710bool DeclarationVisitor::NameIsKnownOrIntrinsic(const parser::Name &name) {
return FindSymbol(name) || HandleUnrestrictedSpecificIntrinsicFunction(name);
5712}

5714// Check if this derived type can be in a COMMON block.
5715void DeclarationVisitor::CheckCommonBlockDerivedType(
  const SourceName &name, const Symbol &typeSymbol) {
if (const auto *scope{typeSymbol.scope()}) {
  for (const auto &pair : *scope) {
    const Symbol &component{*pair.second};
    if (component.attrs().test(Attr::ALLOCATABLE)) {
      Say2(name,
          "Derived type variable '%s' may not appear in a COMMON block"
          " due to ALLOCATABLE component"_err_en_US,
          component.name(), "Component with ALLOCATABLE attribute"_en_US);
      return;
    }
    const auto *details{component.detailsIf<ObjectEntityDetails>()};
    if (component.test(Symbol::Flag::InDataStmt) ||
        (details && details->init())) {
      Say2(name,
          "Derived type variable '%s' may not appear in a COMMON block due to component with default initialization"_err_en_US,
          component.name(), "Component with default initialization"_en_US);
      return;
    }
    if (details) {
      if (const auto *type{details->type()}) {
        if (const auto *derived{type->AsDerived()}) {
          CheckCommonBlockDerivedType(name, derived->typeSymbol());
        }
      }
    }
  }
}
5744}

5746bool DeclarationVisitor::HandleUnrestrictedSpecificIntrinsicFunction(
  const parser::Name &name) {
if (auto interface{context().intrinsics().IsSpecificIntrinsicFunction(
        name.source.ToString())}) {
  // Unrestricted specific intrinsic function names (e.g., "cos")
  // are acceptable as procedure interfaces.  The presence of the
  // INTRINSIC flag will cause this symbol to have a complete interface
  // recreated for it later on demand, but capturing its result type here
  // will make GetType() return a correct result without having to
  // probe the intrinsics table again.
  Symbol &symbol{
      MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC})};
  CHECK(interface->functionResult.has_value())((interface->functionResult.has_value()) || (Fortran::common
::die("CHECK(" "interface->functionResult.has_value()" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 5758)
, false));
  evaluate::DynamicType dyType{
      DEREF(interface->functionResult->GetTypeAndShape())Fortran::common::Deref(interface->functionResult->GetTypeAndShape
(), "flang/lib/Semantics/resolve-names.cpp", 5760).type()};
  CHECK(common::IsNumericTypeCategory(dyType.category()))((common::IsNumericTypeCategory(dyType.category())) || (Fortran
::common::die("CHECK(" "common::IsNumericTypeCategory(dyType.category())"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 5761), false));
  const DeclTypeSpec &typeSpec{
      MakeNumericType(dyType.category(), dyType.kind())};
  ProcEntityDetails details;
  details.set_type(typeSpec);
  symbol.set_details(std::move(details));
  symbol.set(Symbol::Flag::Function);
  if (interface->IsElemental()) {
    SetExplicitAttr(symbol, Attr::ELEMENTAL);
  }
  if (interface->IsPure()) {
    SetExplicitAttr(symbol, Attr::PURE);
  }
  Resolve(name, symbol);
  return true;
} else {
  return false;
}
5779}

5781// Checks for all locality-specs: LOCAL, LOCAL_INIT, and SHARED
5782bool DeclarationVisitor::PassesSharedLocalityChecks(
  const parser::Name &name, Symbol &symbol) {
if (!IsVariableName(symbol)) {
  SayLocalMustBeVariable(name, symbol); // C1124
  return false;
}
if (symbol.owner() == currScope()) { // C1125 and C1126
  SayAlreadyDeclared(name, symbol);
  return false;
}
return true;
5793}

5795// Checks for locality-specs LOCAL and LOCAL_INIT
5796bool DeclarationVisitor::PassesLocalityChecks(
  const parser::Name &name, Symbol &symbol) {
if (IsAllocatable(symbol)) { // C1128
  SayWithDecl(name, symbol,
      "ALLOCATABLE variable '%s' not allowed in a locality-spec"_err_en_US);
  return false;
}
if (IsOptional(symbol)) { // C1128
  SayWithDecl(name, symbol,
      "OPTIONAL argument '%s' not allowed in a locality-spec"_err_en_US);
  return false;
}
if (IsIntentIn(symbol)) { // C1128
  SayWithDecl(name, symbol,
      "INTENT IN argument '%s' not allowed in a locality-spec"_err_en_US);
  return false;
}
if (IsFinalizable(symbol)) { // C1128
  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 (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;
  }
}
if (IsAssumedSizeArray(symbol)) { // C1128
  SayWithDecl(name, symbol,
      "Assumed size array '%s' not allowed in a locality-spec"_err_en_US);
  return false;
}
if (std::optional<Message> whyNot{WhyNotDefinable(
        name.source, currScope(), DefinabilityFlags{}, symbol)}) {
  SayWithReason(name, symbol,
      "'%s' may not appear in a locality-spec because it is not "
      "definable"_err_en_US,
      std::move(*whyNot));
  return false;
}
return PassesSharedLocalityChecks(name, symbol);
5846}

5848Symbol &DeclarationVisitor::FindOrDeclareEnclosingEntity(
  const parser::Name &name) {
Symbol *prev{FindSymbol(name)};
if (!prev) {
  // Declare the name as an object in the enclosing scope so that
  // the name can't be repurposed there later as something else.
  prev = &MakeSymbol(InclusiveScope(), name.source, Attrs{});
  ConvertToObjectEntity(*prev);
  ApplyImplicitRules(*prev);
}
return *prev;
5859}

5861Symbol *DeclarationVisitor::DeclareLocalEntity(const parser::Name &name) {
Symbol &prev{FindOrDeclareEnclosingEntity(name)};
if (!PassesLocalityChecks(name, prev)) {
  return nullptr;
}
return &MakeHostAssocSymbol(name, prev);
5867}

5869Symbol *DeclarationVisitor::DeclareStatementEntity(
  const parser::DoVariable &doVar,
  const std::optional<parser::IntegerTypeSpec> &type) {
const parser::Name &name{doVar.thing.thing};
const DeclTypeSpec *declTypeSpec{nullptr};
if (auto *prev{FindSymbol(name)}) {
  if (prev->owner() == currScope()) {
    SayAlreadyDeclared(name, *prev);
    return nullptr;
  }
  name.symbol = nullptr;
  declTypeSpec = prev->GetType();
}
Symbol &symbol{DeclareEntity<ObjectEntityDetails>(name, {})};
if (!symbol.has<ObjectEntityDetails>()) {
  return nullptr; // error was reported in DeclareEntity
}
if (type) {
  declTypeSpec = ProcessTypeSpec(*type);
}
if (declTypeSpec) {
  // Subtlety: Don't let a "*length" specifier (if any is pending) affect the
  // declaration of this implied DO loop control variable.
  auto restorer{
      common::ScopedSet(charInfo_.length, std::optional<ParamValue>{})};
  SetType(name, *declTypeSpec);
} else {
  ApplyImplicitRules(symbol);
}
Symbol *result{Resolve(name, &symbol)};
AnalyzeExpr(context(), doVar); // enforce INTEGER type
return result;
5901}

5903// Set the type of an entity or report an error.
5904void DeclarationVisitor::SetType(
  const parser::Name &name, const DeclTypeSpec &type) {
CHECK(name.symbol)((name.symbol) || (Fortran::common::die("CHECK(" "name.symbol"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 5906), false));
auto &symbol{*name.symbol};
if (charInfo_.length) { // Declaration has "*length" (R723)
  auto length{std::move(*charInfo_.length)};
  charInfo_.length.reset();
  if (type.category() == DeclTypeSpec::Character) {
    auto kind{type.characterTypeSpec().kind()};
    // Recurse with correct type.
    SetType(name,
        currScope().MakeCharacterType(std::move(length), std::move(kind)));
    return;
  } else { // C753
    Say(name,
        "A length specifier cannot be used to declare the non-character entity '%s'"_err_en_US);
  }
}
if (auto *proc{symbol.detailsIf<ProcEntityDetails>()}) {
  if (proc->procInterface()) {
    Say(name,
        "'%s' has an explicit interface and may not also have a type"_err_en_US);
    context().SetError(symbol);
    return;
  }
}
auto *prevType{symbol.GetType()};
if (!prevType) {
  symbol.SetType(type);
} else if (symbol.has<UseDetails>()) {
  // error recovery case, redeclaration of use-associated name
} else if (HadForwardRef(symbol)) {
  // error recovery after use of host-associated name
} else if (!symbol.test(Symbol::Flag::Implicit)) {
  SayWithDecl(
      name, symbol, "The type of '%s' has already been declared"_err_en_US);
  context().SetError(symbol);
} else if (type != *prevType) {
  SayWithDecl(name, symbol,
      "The type of '%s' has already been implicitly declared"_err_en_US);
  context().SetError(symbol);
} else {
  symbol.set(Symbol::Flag::Implicit, false);
}
5948}

5950std::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()}) {
    symbol = genDT;
    generic = nullptr;
  }
}
if (!symbol || symbol->has<UnknownDetails>() ||
    (generic && &ultimate->owner() == &outer)) {
  if (allowForwardReferenceToDerivedType()) {
    if (!symbol) {
      symbol = &MakeSymbol(outer, name.source, Attrs{});
      Resolve(name, *symbol);
    } else if (generic) {
      // forward ref to type with later homonymous generic
      symbol = &outer.MakeSymbol(name.source, Attrs{}, UnknownDetails{});
      generic->set_derivedType(*symbol);
      name.symbol = symbol;
    }
    DerivedTypeDetails details;
    details.set_isForwardReferenced(true);
    symbol->set_details(std::move(details));
  } else { // C732
    Say(name, "Derived type '%s' not found"_err_en_US);
    return std::nullopt;
  }
}
if (CheckUseError(name)) {
  return std::nullopt;
}
symbol = &symbol->GetUltimate();
if (symbol->has<DerivedTypeDetails>()) {
  return DerivedTypeSpec{name.source, *symbol};
} else {
  Say(name, "'%s' is not a derived type"_err_en_US);
  return std::nullopt;
}
5992}

5994std::optional<DerivedTypeSpec> DeclarationVisitor::ResolveExtendsType(
  const parser::Name &typeName, const parser::Name *extendsName) {
if (!extendsName) {
  return std::nullopt;
} else if (typeName.source == extendsName->source) {
  Say(extendsName->source,
      "Derived type '%s' cannot extend itself"_err_en_US);
  return std::nullopt;
} else {
  return ResolveDerivedType(*extendsName);
}
6005}

6007Symbol *DeclarationVisitor::NoteInterfaceName(const parser::Name &name) {
// The symbol is checked later by CheckExplicitInterface() and
// CheckBindings().  It can be a forward reference.
if (!NameIsKnownOrIntrinsic(name)) {
  Symbol &symbol{MakeSymbol(InclusiveScope(), name.source, Attrs{})};
  Resolve(name, symbol);
}
return name.symbol;
6015}

6017void DeclarationVisitor::CheckExplicitInterface(const parser::Name &name) {
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());
  }
}
6028}

6030// Create a symbol for a type parameter, component, or procedure binding in
6031// the current derived type scope. Return false on error.
6032Symbol *DeclarationVisitor::MakeTypeSymbol(
  const parser::Name &name, Details &&details) {
return Resolve(name, MakeTypeSymbol(name.source, std::move(details)));
6035}
6036Symbol *DeclarationVisitor::MakeTypeSymbol(
  const SourceName &name, Details &&details) {
Scope &derivedType{currScope()};
CHECK(derivedType.IsDerivedType())((derivedType.IsDerivedType()) || (Fortran::common::die("CHECK("
 "derivedType.IsDerivedType()" ") failed" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 6039), false));
if (auto *symbol{FindInScope(derivedType, name)}) { // C742
  Say2(name,
      "Type parameter, component, or procedure binding '%s'"
      " already defined in this type"_err_en_US,
      *symbol, "Previous definition of '%s'"_en_US);
  return nullptr;
} else {
  auto attrs{GetAttrs()};
  // Apply binding-private-stmt if present and this is a procedure binding
  if (derivedTypeInfo_.privateBindings &&
      !attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE}) &&
      std::holds_alternative<ProcBindingDetails>(details)) {
    attrs.set(Attr::PRIVATE);
  }
  Symbol &result{MakeSymbol(name, attrs, std::move(details))};
  if (result.has<TypeParamDetails>()) {
    derivedType.symbol()->get<DerivedTypeDetails>().add_paramDecl(result);
  }
  return &result;
}
6060}

6062// Return true if it is ok to declare this component in the current scope.
6063// Otherwise, emit an error and return false.
6064bool DeclarationVisitor::OkToAddComponent(
  const parser::Name &name, const Symbol *extends) {
for (const Scope *scope{&currScope()}; scope;) {
  CHECK(scope->IsDerivedType())((scope->IsDerivedType()) || (Fortran::common::die("CHECK("
 "scope->IsDerivedType()" ") failed" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 6067), false));
  if (auto *prev{FindInScope(*scope, name.source)}) {
    std::optional<parser::MessageFixedText> msg;
    if (context().HasError(*prev)) { // don't pile on
    } else if (extends) {
      msg = "Type cannot be extended as it has a component named"
            " '%s'"_err_en_US;
    } else if (CheckAccessibleSymbol(currScope(), *prev)) {
      // inaccessible component -- redeclaration is ok
      msg = "Component '%s' is inaccessibly declared in or as a "
            "parent of this derived type"_warn_en_US;
    } else if (prev->test(Symbol::Flag::ParentComp)) {
      msg = "'%s' is a parent type of this type and so cannot be"
            " a component"_err_en_US;
    } else if (scope == &currScope()) {
      msg = "Component '%s' is already declared in this"
            " derived type"_err_en_US;
    } else {
      msg = "Component '%s' is already declared in a parent of this"
            " derived type"_err_en_US;
    }
    if (msg) {
      Say2(
          name, std::move(*msg), *prev, "Previous declaration of '%s'"_en_US);
      if (msg->severity() == parser::Severity::Error) {
        Resolve(name, *prev);
        return false;
      }
    }
  }
  if (scope == &currScope() && extends) {
    // The parent component has not yet been added to the scope.
    scope = extends->scope();
  } else {
    scope = scope->GetDerivedTypeParent();
  }
}
return true;
6105}

6107ParamValue DeclarationVisitor::GetParamValue(
  const parser::TypeParamValue &x, common::TypeParamAttr attr) {
return common::visit(
    common::visitors{
        [=](const parser::ScalarIntExpr &x) { // C704
          return ParamValue{EvaluateIntExpr(x), attr};
        },
        [=](const parser::Star &) { return ParamValue::Assumed(attr); },
        [=](const parser::TypeParamValue::Deferred &) {
          return ParamValue::Deferred(attr);
        },
    },
    x.u);
6120}

6122// ConstructVisitor implementation

6124void ConstructVisitor::ResolveIndexName(
  const parser::ConcurrentControl &control) {
const parser::Name &name{std::get<parser::Name>(control.t)};
auto *prev{FindSymbol(name)};
if (prev) {
  if (prev->owner().kind() == Scope::Kind::Forall ||
      prev->owner() == currScope()) {
    SayAlreadyDeclared(name, *prev);
    return;
  }
  name.symbol = nullptr;
}
auto &symbol{DeclareObjectEntity(name)};
if (symbol.GetType()) {
  // type came from explicit type-spec
} else if (!prev) {
  ApplyImplicitRules(symbol);
} else {
  const Symbol &prevRoot{prev->GetUltimate()};
  // prev could be host- use- or construct-associated with another symbol
  if (!prevRoot.has<ObjectEntityDetails>() &&
      !prevRoot.has<AssocEntityDetails>()) {
    Say2(name, "Index name '%s' conflicts with existing identifier"_err_en_US,
        *prev, "Previous declaration of '%s'"_en_US);
    context().SetError(symbol);
    return;
  } else {
    if (const auto *type{prevRoot.GetType()}) {
      symbol.SetType(*type);
    }
    if (prevRoot.IsObjectArray()) {
      SayWithDecl(name, *prev, "Index variable '%s' is not scalar"_err_en_US);
      return;
    }
  }
}
EvaluateExpr(parser::Scalar{parser::Integer{common::Clone(name)}});
6161}

6163// We need to make sure that all of the index-names get declared before the
6164// expressions in the loop control are evaluated so that references to the
6165// index-names in the expressions are correctly detected.
6166bool ConstructVisitor::Pre(const parser::ConcurrentHeader &header) {
BeginDeclTypeSpec();
Walk(std::get<std::optional<parser::IntegerTypeSpec>>(header.t));
const auto &controls{
    std::get<std::list<parser::ConcurrentControl>>(header.t)};
for (const auto &control : controls) {
  ResolveIndexName(control);
}
Walk(controls);
Walk(std::get<std::optional<parser::ScalarLogicalExpr>>(header.t));
EndDeclTypeSpec();
return false;
6178}

6180bool ConstructVisitor::Pre(const parser::LocalitySpec::Local &x) {
for (auto &name : x.v) {
  if (auto *symbol{DeclareLocalEntity(name)}) {
    symbol->set(Symbol::Flag::LocalityLocal);
  }
}
return false;
6187}

6189bool ConstructVisitor::Pre(const parser::LocalitySpec::LocalInit &x) {
for (auto &name : x.v) {
  if (auto *symbol{DeclareLocalEntity(name)}) {
    symbol->set(Symbol::Flag::LocalityLocalInit);
  }
}
return false;
6196}

6198bool ConstructVisitor::Pre(const parser::LocalitySpec::Shared &x) {
for (const auto &name : x.v) {
  if (!FindSymbol(name)) {
    Say(name,
        "Variable '%s' with SHARED locality implicitly declared"_warn_en_US);
  }
  Symbol &prev{FindOrDeclareEnclosingEntity(name)};
  if (PassesSharedLocalityChecks(name, prev)) {
    MakeHostAssocSymbol(name, prev).set(Symbol::Flag::LocalityShared);
  }
}
return false;
6210}

6212bool ConstructVisitor::Pre(const parser::AcSpec &x) {
ProcessTypeSpec(x.type);
Walk(x.values);
return false;
6216}

6218// Section 19.4, paragraph 5 says that each ac-do-variable has the scope of the
6219// enclosing ac-implied-do
6220bool ConstructVisitor::Pre(const parser::AcImpliedDo &x) {
auto &values{std::get<std::list<parser::AcValue>>(x.t)};
auto &control{std::get<parser::AcImpliedDoControl>(x.t)};
auto &type{std::get<std::optional<parser::IntegerTypeSpec>>(control.t)};
auto &bounds{std::get<parser::AcImpliedDoControl::Bounds>(control.t)};
// F'2018 has the scope of the implied DO variable covering the entire
// implied DO production (19.4(5)), which seems wrong in cases where the name
// of the implied DO variable appears in one of the bound expressions. Thus
// this extension, which shrinks the scope of the variable to exclude the
// expressions in the bounds.
auto restore{BeginCheckOnIndexUseInOwnBounds(bounds.name)};
Walk(bounds.lower);
Walk(bounds.upper);
Walk(bounds.step);
EndCheckOnIndexUseInOwnBounds(restore);
PushScope(Scope::Kind::ImpliedDos, nullptr);
DeclareStatementEntity(bounds.name, type);
Walk(values);
PopScope();
return false;
6240}

6242bool ConstructVisitor::Pre(const parser::DataImpliedDo &x) {
auto &objects{std::get<std::list<parser::DataIDoObject>>(x.t)};
auto &type{std::get<std::optional<parser::IntegerTypeSpec>>(x.t)};
auto &bounds{std::get<parser::DataImpliedDo::Bounds>(x.t)};
// See comment in Pre(AcImpliedDo) above.
auto restore{BeginCheckOnIndexUseInOwnBounds(bounds.name)};
Walk(bounds.lower);
Walk(bounds.upper);
Walk(bounds.step);
EndCheckOnIndexUseInOwnBounds(restore);
bool pushScope{currScope().kind() != Scope::Kind::ImpliedDos};
if (pushScope) {
  PushScope(Scope::Kind::ImpliedDos, nullptr);
}
DeclareStatementEntity(bounds.name, type);
Walk(objects);
if (pushScope) {
  PopScope();
}
return false;
6262}

6264// Sets InDataStmt flag on a variable (or misidentified function) in a DATA
6265// statement so that the predicate IsInitialized() will be true
6266// during semantic analysis before the symbol's initializer is constructed.
6267bool ConstructVisitor::Pre(const parser::DataIDoObject &x) {
common::visit(
    common::visitors{
        [&](const parser::Scalar<Indirection<parser::Designator>> &y) {
          Walk(y.thing.value());
          const parser::Name &first{parser::GetFirstName(y.thing.value())};
          if (first.symbol) {
            first.symbol->set(Symbol::Flag::InDataStmt);
          }
        },
        [&](const Indirection<parser::DataImpliedDo> &y) { Walk(y.value()); },
    },
    x.u);
return false;
6281}

6283bool ConstructVisitor::Pre(const parser::DataStmtObject &x) {
// Subtle: DATA statements may appear in both the specification and
// execution parts, but should be treated as if in the execution part
// for purposes of implicit variable declaration vs. host association.
// When a name first appears as an object in a DATA statement, it should
// be implicitly declared locally as if it had been assigned.
auto flagRestorer{common::ScopedSet(inSpecificationPart_, false)};
common::visit(common::visitors{
                  [&](const Indirection<parser::Variable> &y) {
                    Walk(y.value());
                    const parser::Name &first{
                        parser::GetFirstName(y.value())};
                    if (first.symbol) {
                      first.symbol->set(Symbol::Flag::InDataStmt);
                    }
                  },
                  [&](const parser::DataImpliedDo &y) {
                    PushScope(Scope::Kind::ImpliedDos, nullptr);
                    Walk(y);
                    PopScope();
                  },
              },
    x.u);
return false;
6307}

6309bool 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)}) {
      const Symbol &ultimate{symbol->GetUltimate()};
      if (ultimate.has<DerivedTypeDetails>()) {
        mutableData.u = elem->ConvertToStructureConstructor(
            DerivedTypeSpec{name->source, ultimate});
      }
    }
  }
}
return true;
6324}

6326bool ConstructVisitor::Pre(const parser::DoConstruct &x) {
if (x.IsDoConcurrent()) {
  PushScope(Scope::Kind::OtherConstruct, nullptr);
}
return true;
6331}
6332void ConstructVisitor::Post(const parser::DoConstruct &x) {
if (x.IsDoConcurrent()) {
  PopScope();
}
6336}

6338bool ConstructVisitor::Pre(const parser::ForallConstruct &) {
PushScope(Scope::Kind::Forall, nullptr);
return true;
6341}
6342void ConstructVisitor::Post(const parser::ForallConstruct &) { PopScope(); }
6343bool ConstructVisitor::Pre(const parser::ForallStmt &) {
PushScope(Scope::Kind::Forall, nullptr);
return true;
6346}
6347void ConstructVisitor::Post(const parser::ForallStmt &) { PopScope(); }

6349bool ConstructVisitor::Pre(const parser::BlockStmt &x) {
CheckDef(x.v);
PushScope(Scope::Kind::BlockConstruct, nullptr);
return false;
6353}
6354bool ConstructVisitor::Pre(const parser::EndBlockStmt &x) {
PopScope();
CheckRef(x.v);
return false;
6358}

6360void ConstructVisitor::Post(const parser::Selector &x) {
GetCurrentAssociation().selector = ResolveSelector(x);
6362}

6364void ConstructVisitor::Post(const parser::AssociateStmt &x) {
CheckDef(x.t);
PushScope(Scope::Kind::OtherConstruct, nullptr);
const auto assocCount{std::get<std::list<parser::Association>>(x.t).size()};
for (auto nthLastAssoc{assocCount}; nthLastAssoc > 0; --nthLastAssoc) {
  SetCurrentAssociation(nthLastAssoc);
  if (auto *symbol{MakeAssocEntity()}) {
    if (ExtractCoarrayRef(GetCurrentAssociation().selector.expr)) { // C1103
      Say("Selector must not be a coindexed object"_err_en_US);
    }
    SetTypeFromAssociation(*symbol);
    SetAttrsFromAssociation(*symbol);
  }
}
PopAssociation(assocCount);
6379}

6381void ConstructVisitor::Post(const parser::EndAssociateStmt &x) {
PopScope();
CheckRef(x.v);
6384}

6386bool ConstructVisitor::Pre(const parser::Association &x) {
PushAssociation();
const auto &name{std::get<parser::Name>(x.t)};
GetCurrentAssociation().name = &name;
return true;
6391}

6393bool ConstructVisitor::Pre(const parser::ChangeTeamStmt &x) {
CheckDef(x.t);
PushScope(Scope::Kind::OtherConstruct, nullptr);
PushAssociation();
return true;
6398}

6400void ConstructVisitor::Post(const parser::CoarrayAssociation &x) {
const auto &decl{std::get<parser::CodimensionDecl>(x.t)};
const auto &name{std::get<parser::Name>(decl.t)};
if (auto *symbol{FindInScope(name)}) {
  const auto &selector{std::get<parser::Selector>(x.t)};
  if (auto sel{ResolveSelector(selector)}) {
    const Symbol *whole{UnwrapWholeSymbolDataRef(sel.expr)};
    if (!whole || whole->Corank() == 0) {
      Say(sel.source, // C1116
          "Selector in coarray association must name a coarray"_err_en_US);
    } else if (auto dynType{sel.expr->GetType()}) {
      if (!symbol->GetType()) {
        symbol->SetType(ToDeclTypeSpec(std::move(*dynType)));
      }
    }
  }
}
6417}

6419void ConstructVisitor::Post(const parser::EndChangeTeamStmt &x) {
PopAssociation();
PopScope();
CheckRef(x.t);
6423}

6425bool ConstructVisitor::Pre(const parser::SelectTypeConstruct &) {
PushAssociation();
return true;
6428}

6430void ConstructVisitor::Post(const parser::SelectTypeConstruct &) {
PopAssociation();
6432}

6434void ConstructVisitor::Post(const parser::SelectTypeStmt &x) {
auto &association{GetCurrentAssociation()};
if (const std::optional<parser::Name> &name{std::get<1>(x.t)}) {
  // This isn't a name in the current scope, it is in each TypeGuardStmt
  MakePlaceholder(*name, MiscDetails::Kind::SelectTypeAssociateName);
  association.name = &*name;
  if (ExtractCoarrayRef(association.selector.expr)) { // C1103
    Say("Selector must not be a coindexed object"_err_en_US);
  }
  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)}) {
    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 (!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
        "Selector is not a named variable: 'associate-name =>' is required"_err_en_US);
    association = {};
  }
}
6473}

6475void ConstructVisitor::Post(const parser::SelectRankStmt &x) {
auto &association{GetCurrentAssociation()};
if (const std::optional<parser::Name> &name{std::get<1>(x.t)}) {
  // This isn't a name in the current scope, it is in each SelectRankCaseStmt
  MakePlaceholder(*name, MiscDetails::Kind::SelectRankAssociateName);
  association.name = &*name;
}
6482}

6484bool ConstructVisitor::Pre(const parser::SelectTypeConstruct::TypeCase &) {
PushScope(Scope::Kind::OtherConstruct, nullptr);
return true;
6487}
6488void ConstructVisitor::Post(const parser::SelectTypeConstruct::TypeCase &) {
PopScope();
6490}

6492bool ConstructVisitor::Pre(const parser::SelectRankConstruct::RankCase &) {
PushScope(Scope::Kind::OtherConstruct, nullptr);
return true;
6495}
6496void ConstructVisitor::Post(const parser::SelectRankConstruct::RankCase &) {
PopScope();
6498}

6500bool ConstructVisitor::Pre(const parser::TypeGuardStmt::Guard &x) {
if (std::holds_alternative<parser::DerivedTypeSpec>(x.u)) {
  // CLASS IS (t)
  SetDeclTypeSpecCategory(DeclTypeSpec::Category::ClassDerived);
}
return true;
6506}

6508void ConstructVisitor::Post(const parser::TypeGuardStmt::Guard &x) {
if (auto *symbol{MakeAssocEntity()}) {
  if (std::holds_alternative<parser::Default>(x.u)) {
    SetTypeFromAssociation(*symbol);
  } else if (const auto *type{GetDeclTypeSpec()}) {
    symbol->SetType(*type);
  }
  SetAttrsFromAssociation(*symbol);
}
6517}

6519void ConstructVisitor::Post(const parser::SelectRankCaseStmt::Rank &x) {
if (auto *symbol{MakeAssocEntity()}) {
  SetTypeFromAssociation(*symbol);
  SetAttrsFromAssociation(*symbol);
  if (const auto *init{std::get_if<parser::ScalarIntConstantExpr>(&x.u)}) {
    if (auto val{EvaluateInt64(context(), *init)}) {
      auto &details{symbol->get<AssocEntityDetails>()};
      details.set_rank(*val);
    }
  }
}
6530}

6532bool ConstructVisitor::Pre(const parser::SelectRankConstruct &) {
PushAssociation();
return true;
6535}

6537void ConstructVisitor::Post(const parser::SelectRankConstruct &) {
PopAssociation();
6539}

6541bool ConstructVisitor::CheckDef(const std::optional<parser::Name> &x) {
if (x) {
  MakeSymbol(*x, MiscDetails{MiscDetails::Kind::ConstructName});
}
return true;
6546}

6548void ConstructVisitor::CheckRef(const std::optional<parser::Name> &x) {
if (x) {
  // Just add an occurrence of this name; checking is done in ValidateLabels
  FindSymbol(*x);
}
6553}

6555// Make a symbol for the associating entity of the current association.
6556Symbol *ConstructVisitor::MakeAssocEntity() {
Symbol *symbol{nullptr};
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)}) {
  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{});
}
return symbol;
6578}

6580// Set the type of symbol based on the current association selector.
6581void ConstructVisitor::SetTypeFromAssociation(Symbol &symbol) {
auto &details{symbol.get<AssocEntityDetails>()};
const MaybeExpr *pexpr{&details.expr()};
if (!*pexpr) {
  pexpr = &GetCurrentAssociation().selector.expr;
}
if (*pexpr) {
  const SomeExpr &expr{**pexpr};
  if (std::optional<evaluate::DynamicType> type{expr.GetType()}) {
    if (const auto *charExpr{
            evaluate::UnwrapExpr<evaluate::Expr<evaluate::SomeCharacter>>(
                expr)}) {
      symbol.SetType(ToDeclTypeSpec(std::move(*type),
          FoldExpr(common::visit(
              [](const auto &kindChar) { return kindChar.LEN(); },
              charExpr->u))));
    } else {
      symbol.SetType(ToDeclTypeSpec(std::move(*type)));
    }
  } else {
    // BOZ literals, procedure designators, &c. are not acceptable
    Say(symbol.name(), "Associate name '%s' must have a type"_err_en_US);
  }
}
6605}

6607// If current selector is a variable, set some of its attributes on symbol.
6608void ConstructVisitor::SetAttrsFromAssociation(Symbol &symbol) {
Attrs attrs{evaluate::GetAttrs(GetCurrentAssociation().selector.expr)};
symbol.attrs() |= attrs &
    Attrs{Attr::TARGET, Attr::ASYNCHRONOUS, Attr::VOLATILE, Attr::CONTIGUOUS};
if (attrs.test(Attr::POINTER)) {
  SetImplicitAttr(symbol, Attr::TARGET);
}
6615}

6617ConstructVisitor::Selector ConstructVisitor::ResolveSelector(
  const parser::Selector &x) {
return common::visit(common::visitors{
                         [&](const parser::Expr &expr) {
                           return Selector{expr.source, EvaluateExpr(x)};
                         },
                         [&](const parser::Variable &var) {
                           return Selector{var.GetSource(), EvaluateExpr(x)};
                         },
                     },
    x.u);
6628}

6630// Set the current association to the nth to the last association on the
6631// association stack.  The top of the stack is at n = 1.  This allows access
6632// to the interior of a list of associations at the top of the stack.
6633void ConstructVisitor::SetCurrentAssociation(std::size_t n) {
CHECK(n > 0 && n <= associationStack_.size())((n > 0 && n <= associationStack_.size()) || (Fortran
::common::die("CHECK(" "n > 0 && n <= associationStack_.size()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 6634), false));
currentAssociation_ = &associationStack_[associationStack_.size() - n];
6636}

6638ConstructVisitor::Association &ConstructVisitor::GetCurrentAssociation() {
CHECK(currentAssociation_)((currentAssociation_) || (Fortran::common::die("CHECK(" "currentAssociation_"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 6639), false));
return *currentAssociation_;
6641}

6643void ConstructVisitor::PushAssociation() {
associationStack_.emplace_back(Association{});
currentAssociation_ = &associationStack_.back();
6646}

6648void ConstructVisitor::PopAssociation(std::size_t count) {
CHECK(count > 0 && count <= associationStack_.size())((count > 0 && count <= associationStack_.size(
)) || (Fortran::common::die("CHECK(" "count > 0 && count <= associationStack_.size()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 6649), false));
associationStack_.resize(associationStack_.size() - count);
currentAssociation_ =
    associationStack_.empty() ? nullptr : &associationStack_.back();
6653}

6655const DeclTypeSpec &ConstructVisitor::ToDeclTypeSpec(
  evaluate::DynamicType &&type) {
switch (type.category()) {
  SWITCH_COVERS_ALL_CASES
case common::TypeCategory::Integer:
case common::TypeCategory::Real:
case common::TypeCategory::Complex:
  return context().MakeNumericType(type.category(), type.kind());
case common::TypeCategory::Logical:
  return context().MakeLogicalType(type.kind());
case common::TypeCategory::Derived:
  if (type.IsAssumedType()) {
    return currScope().MakeTypeStarType();
  } else if (type.IsUnlimitedPolymorphic()) {
    return currScope().MakeClassStarType();
  } else {
    return currScope().MakeDerivedType(
        type.IsPolymorphic() ? DeclTypeSpec::ClassDerived
                             : DeclTypeSpec::TypeDerived,
        common::Clone(type.GetDerivedTypeSpec())

    );
  }
case common::TypeCategory::Character:
  CRASH_NO_CASEFortran::common::die("no case" " at " "flang/lib/Semantics/resolve-names.cpp"
 "(%d)", 6679);
}
6681}

6683const DeclTypeSpec &ConstructVisitor::ToDeclTypeSpec(
  evaluate::DynamicType &&type, MaybeSubscriptIntExpr &&length) {
CHECK(type.category() == common::TypeCategory::Character)((type.category() == common::TypeCategory::Character) || (Fortran
::common::die("CHECK(" "type.category() == common::TypeCategory::Character"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 6685), false));
if (length) {
  return currScope().MakeCharacterType(
      ParamValue{SomeIntExpr{*std::move(length)}, common::TypeParamAttr::Len},
      KindExpr{type.kind()});
} else {
  return currScope().MakeCharacterType(
      ParamValue::Deferred(common::TypeParamAttr::Len),
      KindExpr{type.kind()});
}
6695}

6697// ResolveNamesVisitor implementation

6699bool ResolveNamesVisitor::Pre(const parser::FunctionReference &x) {
HandleCall(Symbol::Flag::Function, x.v);
return false;
6702}
6703bool ResolveNamesVisitor::Pre(const parser::CallStmt &x) {
HandleCall(Symbol::Flag::Subroutine, x.v);
return false;
6706}

6708bool ResolveNamesVisitor::Pre(const parser::ImportStmt &x) {
auto &scope{currScope()};
// Check C896 and C899: where IMPORT statements are allowed
switch (scope.kind()) {
case Scope::Kind::Module:
  if (scope.IsModule()) {
    Say("IMPORT is not allowed in a module scoping unit"_err_en_US);
    return false;
  } else if (x.kind == common::ImportKind::None) {
    Say("IMPORT,NONE is not allowed in a submodule scoping unit"_err_en_US);
    return false;
  }
  break;
case Scope::Kind::MainProgram:
  Say("IMPORT is not allowed in a main program scoping unit"_err_en_US);
  return false;
case Scope::Kind::Subprogram:
  if (scope.parent().IsGlobal()) {
    Say("IMPORT is not allowed in an external subprogram scoping unit"_err_en_US);
    return false;
  }
  break;
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 (FindSymbol(scope.parent(), name)) {
    scope.add_importName(name.source);
  } else {
    Say(name, "'%s' not found in host scope"_err_en_US);
  }
}
prevImportStmt_ = currStmtSource();
return false;
6747}

6749const parser::Name *DeclarationVisitor::ResolveStructureComponent(
  const parser::StructureComponent &x) {
return FindComponent(ResolveDataRef(x.base), x.component);
6752}

6754const parser::Name *DeclarationVisitor::ResolveDesignator(
  const parser::Designator &x) {
return common::visit(
    common::visitors{
        [&](const parser::DataRef &x) { return ResolveDataRef(x); },
        [&](const parser::Substring &x) {
          Walk(std::get<parser::SubstringRange>(x.t).t);
          return ResolveDataRef(std::get<parser::DataRef>(x.t));
        },
    },
    x.u);
6765}

6767const parser::Name *DeclarationVisitor::ResolveDataRef(
  const parser::DataRef &x) {
return common::visit(
    common::visitors{
        [=](const parser::Name &y) { return ResolveName(y); },
        [=](const Indirection<parser::StructureComponent> &y) {
          return ResolveStructureComponent(y.value());
        },
        [&](const Indirection<parser::ArrayElement> &y) {
          Walk(y.value().subscripts);
          const parser::Name *name{ResolveDataRef(y.value().base)};
          if (name && name->symbol) {
            if (!IsProcedure(*name->symbol)) {
              ConvertToObjectEntity(*name->symbol);
            } else if (!context().HasError(*name->symbol)) {
              SayWithDecl(*name, *name->symbol,
                  "Cannot reference function '%s' as data"_err_en_US);
            }
          }
          return name;
        },
        [&](const Indirection<parser::CoindexedNamedObject> &y) {
          Walk(y.value().imageSelector);
          return ResolveDataRef(y.value().base);
        },
    },
    x.u);
6794}

6796// If implicit types are allowed, ensure name is in the symbol table.
6797// Otherwise, report an error if it hasn't been declared.
6798const parser::Name *DeclarationVisitor::ResolveName(const parser::Name &name) {
FindSymbol(name);
if (CheckForHostAssociatedImplicit(name)) {
  NotePossibleBadForwardRef(name);
  return &name;
}
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) ||
      (!symbol->GetType() && FindCommonBlockContaining(*symbol))) {
    CheckEntryDummyUse(name.source, symbol);
    ConvertToObjectEntity(*symbol);
    ApplyImplicitRules(*symbol);
  }
  if (checkIndexUseInOwnBounds_ &&
      *checkIndexUseInOwnBounds_ == name.source && !InModuleFile()) {
    Say(name,
        "Implied DO index '%s' uses an object of the same name in its bounds expressions"_port_en_US,
        name.source);
  }
  return &name;
}
if (isImplicitNoneType()) {
  Say(name, "No explicit type declared for '%s'"_err_en_US);
  return nullptr;
}
// Create the symbol then ensure it is accessible
if (checkIndexUseInOwnBounds_ && *checkIndexUseInOwnBounds_ == name.source) {
  Say(name,
      "Implied DO index '%s' uses itself in its own bounds expressions"_err_en_US,
      name.source);
}
MakeSymbol(InclusiveScope(), name.source, Attrs{});
auto *symbol{FindSymbol(name)};
if (!symbol) {
  Say(name,
      "'%s' from host scoping unit is not accessible due to IMPORT"_err_en_US);
  return nullptr;
}
ConvertToObjectEntity(*symbol);
ApplyImplicitRules(*symbol);
NotePossibleBadForwardRef(name);
return &name;
6847}

6849// A specification expression may refer to a symbol in the host procedure that
6850// is implicitly typed. Because specification parts are processed before
6851// execution parts, this may be the first time we see the symbol. It can't be a
6852// local in the current scope (because it's in a specification expression) so
6853// either it is implicitly declared in the host procedure or it is an error.
6854// We create a symbol in the host assuming it is the former; if that proves to
6855// be wrong we report an error later in CheckDeclarations().
6856bool DeclarationVisitor::CheckForHostAssociatedImplicit(
  const parser::Name &name) {
if (!inSpecificationPart_) {
  return false;
}
if (name.symbol) {
  ApplyImplicitRules(*name.symbol, true);
}
Symbol *hostSymbol;
Scope *host{GetHostProcedure()};
if (!host || isImplicitNoneType(*host)) {
  return false;
}
if (!name.symbol) {
  hostSymbol = &MakeSymbol(*host, name.source, Attrs{});
  ConvertToObjectEntity(*hostSymbol);
  ApplyImplicitRules(*hostSymbol);
  hostSymbol->set(Symbol::Flag::ImplicitOrError);
} else if (name.symbol->test(Symbol::Flag::ImplicitOrError)) {
  hostSymbol = name.symbol;
} else {
  return false;
}
Symbol &symbol{MakeHostAssocSymbol(name, *hostSymbol)};
if (isImplicitNoneType()) {
  symbol.get<HostAssocDetails>().implicitOrExplicitTypeError = true;
} else {
  symbol.get<HostAssocDetails>().implicitOrSpecExprError = true;
}
return true;
6886}

6888bool DeclarationVisitor::IsUplevelReference(const Symbol &symbol) {
const Scope &symbolUnit{GetProgramUnitContaining(symbol)};
if (symbolUnit == GetProgramUnitContaining(currScope())) {
  return false;
} else {
  Scope::Kind kind{symbolUnit.kind()};
  return kind == Scope::Kind::Subprogram || kind == Scope::Kind::MainProgram;
}
6896}

6898// base is a part-ref of a derived type; find the named component in its type.
6899// Also handles intrinsic type parameter inquiries (%kind, %len) and
6900// COMPLEX component references (%re, %im).
6901const parser::Name *DeclarationVisitor::FindComponent(
  const parser::Name *base, const parser::Name &component) {
if (!base || !base->symbol) {
  return nullptr;
}
if (auto *misc{base->symbol->detailsIf<MiscDetails>()}) {
  if (component.source == "kind") {
    if (misc->kind() == MiscDetails::Kind::ComplexPartRe ||
        misc->kind() == MiscDetails::Kind::ComplexPartIm ||
        misc->kind() == MiscDetails::Kind::KindParamInquiry ||
        misc->kind() == MiscDetails::Kind::LenParamInquiry) {
      // x%{re,im,kind,len}%kind
      MakePlaceholder(component, MiscDetails::Kind::KindParamInquiry);
      return &component;
    }
  }
}
CheckEntryDummyUse(base->source, base->symbol);
auto &symbol{base->symbol->GetUltimate()};
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()}) {
  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()}) {
  derived->Instantiate(currScope()); // in case of forward referenced type
  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);
    }
  }
  return nullptr;
}
if (symbol.test(Symbol::Flag::Implicit)) {
  Say(*base,
      "'%s' is not an object of derived type; it is implicitly typed"_err_en_US);
} else {
  SayWithDecl(
      *base, symbol, "'%s' is not an object of derived type"_err_en_US);
}
return nullptr;
6972}

6974void DeclarationVisitor::Initialization(const parser::Name &name,
  const parser::Initialization &init, bool inComponentDecl) {
// Traversal of the initializer was deferred to here so that the
// symbol being declared can be available for use in the expression, e.g.:
//   real, parameter :: x = tiny(x)
if (!name.symbol) {
  return;
}
Symbol &ultimate{name.symbol->GetUltimate()};
// TODO: check C762 - all bounds and type parameters of component
// are colons or constant expressions if component is initialized
common::visit(
    common::visitors{
        [&](const parser::ConstantExpr &expr) {
          NonPointerInitialization(name, expr);
        },
        [&](const parser::NullInit &null) { // => NULL()
          Walk(null);
          if (auto nullInit{EvaluateExpr(null)}) {
            if (!evaluate::IsNullPointer(*nullInit)) { // C813
              Say(null.v.value().source,
                  "Pointer initializer must be intrinsic NULL()"_err_en_US);
            } else if (IsPointer(ultimate)) {
              if (auto *object{ultimate.detailsIf<ObjectEntityDetails>()}) {
                object->set_init(std::move(*nullInit));
              } else if (auto *procPtr{
                             ultimate.detailsIf<ProcEntityDetails>()}) {
                procPtr->set_init(nullptr);
              }
            } else {
              Say(name,
                  "Non-pointer component '%s' initialized with null pointer"_err_en_US);
            }
          }
        },
        [&](const parser::InitialDataTarget &) {
          // Defer analysis to the end of the specification part
          // so that forward references and attribute checks like SAVE
          // work better.
          ultimate.set(Symbol::Flag::InDataStmt);
        },
        [&](const std::list<Indirection<parser::DataStmtValue>> &values) {
          // Handled later in data-to-inits conversion
          ultimate.set(Symbol::Flag::InDataStmt);
          Walk(values);
        },
    },
    init.u);
7022}

7024void DeclarationVisitor::PointerInitialization(
  const parser::Name &name, const parser::InitialDataTarget &target) {
if (name.symbol) {
  Symbol &ultimate{name.symbol->GetUltimate()};
  if (!context().HasError(ultimate)) {
    if (IsPointer(ultimate)) {
      if (auto *details{ultimate.detailsIf<ObjectEntityDetails>()}) {
        CHECK(!details->init())((!details->init()) || (Fortran::common::die("CHECK(" "!details->init()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 7031), false));
        Walk(target);
        if (MaybeExpr expr{EvaluateExpr(target)}) {
          // Validation is done in declaration checking.
          details->set_init(std::move(*expr));
        }
      }
    } else {
      Say(name,
          "'%s' is not a pointer but is initialized like one"_err_en_US);
      context().SetError(ultimate);
    }
  }
}
7045}
7046void DeclarationVisitor::PointerInitialization(
  const parser::Name &name, const parser::ProcPointerInit &target) {
if (name.symbol) {
  Symbol &ultimate{name.symbol->GetUltimate()};
  if (!context().HasError(ultimate)) {
    if (IsProcedurePointer(ultimate)) {
      auto &details{ultimate.get<ProcEntityDetails>()};
      CHECK(!details.init())((!details.init()) || (Fortran::common::die("CHECK(" "!details.init()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 7053), false));
      if (const auto *targetName{std::get_if<parser::Name>(&target.u)}) {
        Walk(target);
        if (!CheckUseError(*targetName) && targetName->symbol) {
          // Validation is done in declaration checking.
          details.set_init(*targetName->symbol);
        }
      } else { // explicit NULL
        details.set_init(nullptr);
      }
    } else {
      Say(name,
          "'%s' is not a procedure pointer but is initialized "
          "like one"_err_en_US);
      context().SetError(ultimate);
    }
  }
}
7071}

7073void DeclarationVisitor::NonPointerInitialization(
  const parser::Name &name, const parser::ConstantExpr &expr) {
if (name.symbol) {
  Symbol &ultimate{name.symbol->GetUltimate()};
  if (!context().HasError(ultimate) && !context().HasError(name.symbol)) {
    if (IsPointer(ultimate)) {
      Say(name,
          "'%s' is a pointer but is not initialized like one"_err_en_US);
    } else if (auto *details{ultimate.detailsIf<ObjectEntityDetails>()}) {
      CHECK(!details->init())((!details->init()) || (Fortran::common::die("CHECK(" "!details->init()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 7082), false));
      if (IsAllocatable(ultimate)) {
        Say(name, "Allocatable object '%s' cannot be initialized"_err_en_US);
        return;
      }
      Walk(expr);
      if (ultimate.owner().IsParameterizedDerivedType()) {
        // Save the expression for per-instantiation analysis.
        details->set_unanalyzedPDTComponentInit(&expr.thing.value());
      } else {
        if (MaybeExpr folded{EvaluateNonPointerInitializer(
                ultimate, expr, expr.thing.value().source)}) {
          details->set_init(std::move(*folded));
        }
      }
    } else {
      Say(name, "'%s' is not an object that can be initialized"_err_en_US);
    }
  }
}
7102}

7104void 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 (IsProcedure(*symbol)) {
              SetProcFlag(name, *symbol, procFlag);
            }
          }
        },
    },
    std::get<parser::ProcedureDesignator>(call.t).u);
Walk(std::get<std::list<parser::ActualArgSpec>>(call.t));
7121}

7123void ResolveNamesVisitor::HandleProcedureName(
  Symbol::Flag flag, const parser::Name &name) {
CHECK(flag == Symbol::Flag::Function || flag == Symbol::Flag::Subroutine)((flag == Symbol::Flag::Function || flag == Symbol::Flag::Subroutine
) || (Fortran::common::die("CHECK(" "flag == Symbol::Flag::Function || flag == Symbol::Flag::Subroutine"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 7125), false));
auto *symbol{FindSymbol(NonDerivedTypeScope(), name)};
if (!symbol) {
  if (IsIntrinsic(name.source, flag)) {
    symbol =
        &MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC});
  } else {
    symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
  }
  Resolve(name, *symbol);
  if (!symbol->attrs().test(Attr::INTRINSIC)) {
    if (CheckImplicitNoneExternal(name.source, *symbol)) {
      MakeExternal(*symbol);
    }
  }
  CheckEntryDummyUse(name.source, symbol);
  ConvertToProcEntity(*symbol);
  SetProcFlag(name, *symbol, flag);
} else if (CheckUseError(name)) {
  // error was reported
} else {
  auto &nonUltimateSymbol{*symbol};
  symbol = &Resolve(name, symbol)->GetUltimate();
  CheckEntryDummyUse(name.source, symbol);
  bool convertedToProcEntity{ConvertToProcEntity(*symbol)};
  if (convertedToProcEntity && !symbol->attrs().test(Attr::EXTERNAL) &&
      IsIntrinsic(symbol->name(), flag) && !IsDummy(*symbol)) {
    AcquireIntrinsicProcedureFlags(*symbol);
  }
  if (!SetProcFlag(name, *symbol, flag)) {
    return; // reported error
  }
  if (!symbol->has<GenericDetails>()) {
    CheckImplicitNoneExternal(name.source, *symbol);
  }
  if (IsProcedure(*symbol) || symbol->has<DerivedTypeDetails>() ||
      symbol->has<AssocEntityDetails>()) {
    // Symbols with DerivedTypeDetails and AssocEntityDetails are accepted
    // here as procedure-designators because this means the related
    // FunctionReference are mis-parsed structure constructors or array
    // references that will be fixed later when analyzing expressions.
  } else if (symbol->has<ObjectEntityDetails>()) {
    // Symbols with ObjectEntityDetails are also accepted because this can be
    // a mis-parsed array references that will be fixed later. Ensure that if
    // this is a symbol from a host procedure, a symbol with HostAssocDetails
    // is created for the current scope.
    // Operate on non ultimate symbol so that HostAssocDetails are also
    // created for symbols used associated in the host procedure.
    if (IsUplevelReference(nonUltimateSymbol)) {
      MakeHostAssocSymbol(name, nonUltimateSymbol);
    }
  } else if (symbol->test(Symbol::Flag::Implicit)) {
    Say(name,
        "Use of '%s' as a procedure conflicts with its implicit definition"_err_en_US);
  } else {
    SayWithDecl(name, *symbol,
        "Use of '%s' as a procedure conflicts with its declaration"_err_en_US);
  }
}
7184}

7186bool ResolveNamesVisitor::CheckImplicitNoneExternal(
  const SourceName &name, const Symbol &symbol) {
if (isImplicitNoneExternal() && !symbol.attrs().test(Attr::EXTERNAL) &&
    !symbol.attrs().test(Attr::INTRINSIC) && !symbol.HasExplicitInterface()) {
  Say(name,
      "'%s' is an external procedure without the EXTERNAL"
      " attribute in a scope with IMPLICIT NONE(EXTERNAL)"_err_en_US);
  return false;
}
return true;
7196}

7198// Variant of HandleProcedureName() for use while skimming the executable
7199// part of a subprogram to catch calls to dummy procedures that are part
7200// of the subprogram's interface, and to mark as procedures any symbols
7201// that might otherwise have been miscategorized as objects.
7202void ResolveNamesVisitor::NoteExecutablePartCall(
  Symbol::Flag flag, const parser::Call &call) {
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)}) {
    Symbol::Flag other{flag == Symbol::Flag::Subroutine
            ? Symbol::Flag::Function
            : Symbol::Flag::Subroutine};
    if (!symbol->test(other)) {
      ConvertToProcEntity(*symbol);
      if (symbol->has<ProcEntityDetails>()) {
        symbol->set(flag);
        if (IsDummy(*symbol)) {
          SetImplicitAttr(*symbol, Attr::EXTERNAL);
        }
        ApplyImplicitRules(*symbol);
      }
    }
  }
}
7225}

7227static bool IsLocallyImplicitGlobalSymbol(
  const Symbol &symbol, const parser::Name &localName) {
return symbol.owner().IsGlobal() &&
    (!symbol.scope() ||
        !symbol.scope()->sourceRange().Contains(localName.source));
7232}

7234static bool TypesMismatchIfNonNull(
  const DeclTypeSpec *type1, const DeclTypeSpec *type2) {
return type1 && type2 && *type1 != *type2;
7237}

7239// Check and set the Function or Subroutine flag on symbol; false on error.
7240bool ResolveNamesVisitor::SetProcFlag(
  const parser::Name &name, Symbol &symbol, Symbol::Flag flag) {
if (symbol.test(Symbol::Flag::Function) && flag == Symbol::Flag::Subroutine) {
  SayWithDecl(
      name, symbol, "Cannot call function '%s' like a subroutine"_err_en_US);
  return false;
} else if (symbol.test(Symbol::Flag::Subroutine) &&
    flag == Symbol::Flag::Function) {
  SayWithDecl(
      name, symbol, "Cannot call subroutine '%s' like a function"_err_en_US);
  return false;
} else if (flag == Symbol::Flag::Function &&
    IsLocallyImplicitGlobalSymbol(symbol, name) &&
    TypesMismatchIfNonNull(symbol.GetType(), GetImplicitType(symbol))) {
  SayWithDecl(name, symbol,
      "Implicit declaration of function '%s' has a different result type than in previous declaration"_err_en_US);
  return false;
} else if (symbol.has<ProcEntityDetails>()) {
  symbol.set(flag); // in case it hasn't been set yet
  if (flag == Symbol::Flag::Function) {
    ApplyImplicitRules(symbol);
  }
  if (symbol.attrs().test(Attr::INTRINSIC)) {
    AcquireIntrinsicProcedureFlags(symbol);
  }
} else if (symbol.GetType() && flag == Symbol::Flag::Subroutine) {
  SayWithDecl(
      name, symbol, "Cannot call function '%s' like a subroutine"_err_en_US);
} else if (symbol.attrs().test(Attr::INTRINSIC)) {
  AcquireIntrinsicProcedureFlags(symbol);
}
return true;
7272}

7274bool ModuleVisitor::Pre(const parser::AccessStmt &x) {
Attr accessAttr{AccessSpecToAttr(std::get<parser::AccessSpec>(x.t))};
if (!currScope().IsModule()) { // C869
  Say(currStmtSource().value(),
      "%s statement may only appear in the specification part of a module"_err_en_US,
      EnumToString(accessAttr));
  return false;
}
const auto &accessIds{std::get<std::list<parser::AccessId>>(x.t)};
if (accessIds.empty()) {
  if (prevAccessStmt_) { // C869
    Say("The default accessibility of this module has already been declared"_err_en_US)
        .Attach(*prevAccessStmt_, "Previous declaration"_en_US);
  }
  prevAccessStmt_ = currStmtSource();
  defaultAccess_ = accessAttr;
} else {
  for (const auto &accessId : accessIds) {
    GenericSpecInfo info{accessId.v.value()};
    auto *symbol{FindInScope(info.symbolName())};
    if (!symbol && !info.kind().IsName()) {
      symbol = &MakeSymbol(info.symbolName(), Attrs{}, GenericDetails{});
    }
    info.Resolve(&SetAccess(info.symbolName(), accessAttr, symbol));
  }
}
return false;
7301}

7303// Set the access specification for this symbol.
7304Symbol &ModuleVisitor::SetAccess(
  const SourceName &name, Attr attr, Symbol *symbol) {
if (!symbol) {
  symbol = &MakeSymbol(name);
}
Attrs &attrs{symbol->attrs()};
if (attrs.HasAny({Attr::PUBLIC, Attr::PRIVATE})) {
  // PUBLIC/PRIVATE already set: make it a fatal error if it changed
  Attr prev = attrs.test(Attr::PUBLIC) ? Attr::PUBLIC : Attr::PRIVATE;
  Say(name,
      WithSeverity(
          "The accessibility of '%s' has already been specified as %s"_warn_en_US,
          attr != prev ? parser::Severity::Error : parser::Severity::Warning),
      MakeOpName(name), EnumToString(prev));
} else {
  attrs.set(attr);
}
return *symbol;
7322}

7324static bool NeedsExplicitType(const Symbol &symbol) {
if (symbol.has<UnknownDetails>()) {
  return true;
} else if (const auto *details{symbol.detailsIf<EntityDetails>()}) {
  return !details->type();
} else if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
  return !details->type();
} else if (const auto *details{symbol.detailsIf<ProcEntityDetails>()}) {
  return !details->procInterface() && !details->type();
} else {
  return false;
}
7336}

7338bool ResolveNamesVisitor::Pre(const parser::SpecificationPart &x) {
const auto &[accDecls, ompDecls, compilerDirectives, useStmts, importStmts,
    implicitPart, decls] = x.t;
auto flagRestorer{common::ScopedSet(inSpecificationPart_, true)};
auto stateRestorer{
    common::ScopedSet(specPartState_, SpecificationPartState{})};
Walk(accDecls);
Walk(ompDecls);
Walk(compilerDirectives);
Walk(useStmts);
ClearUseRenames();
ClearUseOnly();
ClearExplicitIntrinsicUses();
Walk(importStmts);
Walk(implicitPart);
for (const auto &decl : decls) {
  if (const auto *spec{
          std::get_if<parser::SpecificationConstruct>(&decl.u)}) {
    PreSpecificationConstruct(*spec);
  }
}
Walk(decls);
FinishSpecificationPart(decls);
return false;
7362}

7364// Initial processing on specification constructs, before visiting them.
7365void ResolveNamesVisitor::PreSpecificationConstruct(
  const parser::SpecificationConstruct &spec) {
common::visit(
    common::visitors{
        [&](const parser::Statement<Indirection<parser::GenericStmt>> &y) {
          CreateGeneric(std::get<parser::GenericSpec>(y.statement.value().t));
        },
        [&](const Indirection<parser::InterfaceBlock> &y) {
          const auto &stmt{std::get<parser::Statement<parser::InterfaceStmt>>(
              y.value().t)};
          if (const auto *spec{parser::Unwrap<parser::GenericSpec>(stmt)}) {
            CreateGeneric(*spec);
          }
        },
        [&](const parser::Statement<parser::OtherSpecificationStmt> &y) {
          if (const auto *commonStmt{parser::Unwrap<parser::CommonStmt>(y)}) {
            CreateCommonBlockSymbols(*commonStmt);
          }
        },
        [&](const auto &) {},
    },
    spec.u);
7387}

7389void ResolveNamesVisitor::CreateCommonBlockSymbols(
  const parser::CommonStmt &commonStmt) {
for (const parser::CommonStmt::Block &block : commonStmt.blocks) {
  const auto &[name, objects] = block.t;
  Symbol &commonBlock{MakeCommonBlockSymbol(name)};
  for (const auto &object : objects) {
    Symbol &obj{DeclareObjectEntity(std::get<parser::Name>(object.t))};
    if (auto *details{obj.detailsIf<ObjectEntityDetails>()}) {
      details->set_commonBlock(commonBlock);
      commonBlock.get<CommonBlockDetails>().add_object(obj);
    }
  }
}
7402}

7404void ResolveNamesVisitor::CreateGeneric(const parser::GenericSpec &x) {
auto info{GenericSpecInfo{x}};
SourceName symbolName{info.symbolName()};
if (IsLogicalConstant(context(), symbolName)) {
  Say(symbolName,
      "Logical constant '%s' may not be used as a defined operator"_err_en_US);
  return;
}
GenericDetails genericDetails;
Symbol *existing{nullptr};
// Check all variants of names, e.g. "operator(.ne.)" for "operator(/=)"
for (const std::string &n : GetAllNames(context(), symbolName)) {
  existing = currScope().FindSymbol(SourceName{n});
  if (existing) {
    break;
  }
}
if (existing) {
  Symbol &ultimate{existing->GetUltimate()};
  if (auto *existingGeneric{ultimate.detailsIf<GenericDetails>()}) {
    if (const auto *existingUse{existing->detailsIf<UseDetails>()}) {
      // Create a local copy of a use associated generic so that
      // it can be locally extended without corrupting the original.
      genericDetails.CopyFrom(*existingGeneric);
      if (existingGeneric->specific()) {
        genericDetails.set_specific(*existingGeneric->specific());
      }
      AddGenericUse(genericDetails, existing->name(), existingUse->symbol());
    } else if (&existing->owner() == &currScope()) {
      if (existing == &ultimate) {
        // Extending an extant generic in the same scope
        info.Resolve(existing);
        return;
      } else {
        // Host association of a generic is handled elsewhere
        CHECK(existing->has<HostAssocDetails>())((existing->has<HostAssocDetails>()) || (Fortran::common
::die("CHECK(" "existing->has<HostAssocDetails>()" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 7439)
, false));
      }
    }
  } else if (ultimate.has<SubprogramDetails>() ||
      ultimate.has<SubprogramNameDetails>()) {
    genericDetails.set_specific(*existing);
  } else if (ultimate.has<DerivedTypeDetails>()) {
    genericDetails.set_derivedType(*existing);
  } else if (&existing->owner() == &currScope()) {
    SayAlreadyDeclared(symbolName, *existing);
    return;
  }
  if (&existing->owner() == &currScope()) {
    EraseSymbol(*existing);
  }
}
info.Resolve(&MakeSymbol(symbolName, Attrs{}, std::move(genericDetails)));
7456}

7458void ResolveNamesVisitor::FinishSpecificationPart(
  const std::list<parser::DeclarationConstruct> &decls) {
badStmtFuncFound_ = false;
funcResultStack().CompleteFunctionResultType();
CheckImports();
bool inModule{currScope().kind() == Scope::Kind::Module};
for (auto &pair : currScope()) {
  auto &symbol{*pair.second};
  if (NeedsExplicitType(symbol)) {
    ApplyImplicitRules(symbol);
  }
  if (IsDummy(symbol) && isImplicitNoneType() &&
      symbol.test(Symbol::Flag::Implicit) && !context().HasError(symbol)) {
    Say(symbol.name(),
        "No explicit type declared for dummy argument '%s'"_err_en_US);
    context().SetError(symbol);
  }
  if (symbol.has<GenericDetails>()) {
    CheckGenericProcedures(symbol);
  }
  if (inModule && symbol.attrs().test(Attr::EXTERNAL) &&
      !symbol.test(Symbol::Flag::Function) &&
      !symbol.test(Symbol::Flag::Subroutine)) {
    // in a module, external proc without return type is subroutine
    symbol.set(
        symbol.GetType() ? Symbol::Flag::Function : Symbol::Flag::Subroutine);
  }
  if (!symbol.has<HostAssocDetails>()) {
    CheckPossibleBadForwardRef(symbol);
  }
}
currScope().InstantiateDerivedTypes();
for (const auto &decl : decls) {
  if (const auto *statement{std::get_if<
          parser::Statement<common::Indirection<parser::StmtFunctionStmt>>>(
          &decl.u)}) {
    AnalyzeStmtFunctionStmt(statement->statement.value());
  }
}
// TODO: what about instantiations in BLOCK?
CheckSaveStmts();
CheckCommonBlocks();
if (!inInterfaceBlock()) {
  // TODO: warn for the case where the EQUIVALENCE statement is in a
  // procedure declaration in an interface block
  CheckEquivalenceSets();
}
7505}

7507// Analyze the bodies of statement functions now that the symbols in this
7508// specification part have been fully declared and implicitly typed.
7509// (Statement function references are not allowed in specification
7510// expressions, so it's safe to defer processing their definitions.)
7511void ResolveNamesVisitor::AnalyzeStmtFunctionStmt(
  const parser::StmtFunctionStmt &stmtFunc) {
const auto &name{std::get<parser::Name>(stmtFunc.t)};
Symbol *symbol{name.symbol};
auto *details{symbol ? symbol->detailsIf<SubprogramDetails>() : nullptr};
if (!details || !symbol->scope()) {
  return;
}
// Resolve the symbols on the RHS of the statement function.
PushScope(*symbol->scope());
const auto &parsedExpr{std::get<parser::Scalar<parser::Expr>>(stmtFunc.t)};
Walk(parsedExpr);
PopScope();
if (auto expr{AnalyzeExpr(context(), stmtFunc)}) {
  if (auto type{evaluate::DynamicType::From(*symbol)}) {
    if (auto converted{evaluate::ConvertToType(*type, std::move(*expr))}) {
      details->set_stmtFunction(std::move(*converted));
    } else {
      Say(name.source,
          "Defining expression of statement function '%s' cannot be converted to its result type %s"_err_en_US,
          name.source, type->AsFortran());
    }
  } else {
    details->set_stmtFunction(std::move(*expr));
  }
}
if (!details->stmtFunction()) {
  context().SetError(*symbol);
}
7540}

7542void ResolveNamesVisitor::CheckImports() {
auto &scope{currScope()};
switch (scope.GetImportKind()) {
case common::ImportKind::None:
  break;
case common::ImportKind::All:
  // C8102: all entities in host must not be hidden
  for (const auto &pair : scope.parent()) {
    auto &name{pair.first};
    std::optional<SourceName> scopeName{scope.GetName()};
    if (!scopeName || name != *scopeName) {
      CheckImport(prevImportStmt_.value(), name);
    }
  }
  break;
case common::ImportKind::Default:
case common::ImportKind::Only:
  // C8102: entities named in IMPORT must not be hidden
  for (auto &name : scope.importNames()) {
    CheckImport(name, name);
  }
  break;
}
7565}

7567void ResolveNamesVisitor::CheckImport(
  const SourceName &location, const SourceName &name) {
if (auto *symbol{FindInScope(name)}) {
  const Symbol &ultimate{symbol->GetUltimate()};
  if (&ultimate.owner() == &currScope()) {
    Say(location, "'%s' from host is not accessible"_err_en_US, name)
        .Attach(symbol->name(), "'%s' is hidden by this entity"_en_US,
            symbol->name());
  }
}
7577}

7579bool ResolveNamesVisitor::Pre(const parser::ImplicitStmt &x) {
return CheckNotInBlock("IMPLICIT") && // C1107
    ImplicitRulesVisitor::Pre(x);
7582}

7584void ResolveNamesVisitor::Post(const parser::PointerObject &x) {
common::visit(common::visitors{
                  [&](const parser::Name &x) { ResolveName(x); },
                  [&](const parser::StructureComponent &x) {
                    ResolveStructureComponent(x);
                  },
              },
    x.u);
7592}
7593void ResolveNamesVisitor::Post(const parser::AllocateObject &x) {
common::visit(common::visitors{
                  [&](const parser::Name &x) { ResolveName(x); },
                  [&](const parser::StructureComponent &x) {
                    ResolveStructureComponent(x);
                  },
              },
    x.u);
7601}

7603bool 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 (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 &&
        symbol->GetUltimate().has<ObjectEntityDetails>() &&
        IsUplevelReference(*symbol)) {
      MakeHostAssocSymbol(*name, *symbol);
    }
    return false;
  }
}
Walk(expr);
return false;
7624}
7625void ResolveNamesVisitor::Post(const parser::Designator &x) {
ResolveDesignator(x);
7627}
7628void ResolveNamesVisitor::Post(const parser::SubstringInquiry &x) {
Walk(std::get<parser::SubstringRange>(x.v.t).t);
ResolveDataRef(std::get<parser::DataRef>(x.v.t));
7631}

7633void ResolveNamesVisitor::Post(const parser::ProcComponentRef &x) {
ResolveStructureComponent(x.v.thing);
7635}
7636void ResolveNamesVisitor::Post(const parser::TypeGuardStmt &x) {
DeclTypeSpecVisitor::Post(x);
ConstructVisitor::Post(x);
7639}
7640bool ResolveNamesVisitor::Pre(const parser::StmtFunctionStmt &x) {
CheckNotInBlock("STATEMENT FUNCTION"); // C1107
if (HandleStmtFunction(x)) {
  return false;
} else {
  // This is an array element assignment: resolve names of indices
  const auto &names{std::get<std::list<parser::Name>>(x.t)};
  for (auto &name : names) {
    ResolveName(name);
  }
  return true;
}
7652}

7654bool ResolveNamesVisitor::Pre(const parser::DefinedOpName &x) {
const parser::Name &name{x.v};
if (FindSymbol(name)) {
  // OK
} else if (IsLogicalConstant(context(), name.source)) {
  Say(name,
      "Logical constant '%s' may not be used as a defined operator"_err_en_US);
} else {
  // Resolved later in expression semantics
  MakePlaceholder(name, MiscDetails::Kind::TypeBoundDefinedOp);
}
return false;
7666}

7668void ResolveNamesVisitor::Post(const parser::AssignStmt &x) {
if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
  CheckEntryDummyUse(name->source, name->symbol);
  ConvertToObjectEntity(DEREF(name->symbol)Fortran::common::Deref(name->symbol, "flang/lib/Semantics/resolve-names.cpp"
, 7671));
}
7673}
7674void ResolveNamesVisitor::Post(const parser::AssignedGotoStmt &x) {
if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
  CheckEntryDummyUse(name->source, name->symbol);
  ConvertToObjectEntity(DEREF(name->symbol)Fortran::common::Deref(name->symbol, "flang/lib/Semantics/resolve-names.cpp"
, 7677));
}
7679}

7681bool ResolveNamesVisitor::Pre(const parser::ProgramUnit &x) {
if (std::holds_alternative<common::Indirection<parser::CompilerDirective>>(
        x.u)) {
  // TODO: global directives
  return true;
}
auto root{ProgramTree::Build(x)};
SetScope(topScope_);
ResolveSpecificationParts(root);
FinishSpecificationParts(root);
ResolveExecutionParts(root);
ResolveAccParts(context(), x);
ResolveOmpParts(context(), x);
return false;
7695}

7697// References to procedures need to record that their symbols are known
7698// to be procedures, so that they don't get converted to objects by default.
7699class ExecutionPartSkimmer {
7700public:
explicit ExecutionPartSkimmer(ResolveNamesVisitor &resolver)
    : resolver_{resolver} {}

void Walk(const parser::ExecutionPart *exec) {
  if (exec) {
    parser::Walk(*exec, *this);
  }
}

template <typename A> bool Pre(const A &) { return true; }
template <typename A> void Post(const A &) {}
void Post(const parser::FunctionReference &fr) {
  resolver_.NoteExecutablePartCall(Symbol::Flag::Function, fr.v);
}
void Post(const parser::CallStmt &cs) {
  resolver_.NoteExecutablePartCall(Symbol::Flag::Subroutine, cs.v);
}

7719private:
ResolveNamesVisitor &resolver_;
7721};

7723// Build the scope tree and resolve names in the specification parts of this
7724// node and its children
7725void ResolveNamesVisitor::ResolveSpecificationParts(ProgramTree &node) {
if (node.isSpecificationPartResolved()) {
  return; // been here already
}
node.set_isSpecificationPartResolved();
if (!BeginScopeForNode(node)) {
  return; // an error prevented scope from being created
}
Scope &scope{currScope()};
node.set_scope(scope);
AddSubpNames(node);
common::visit(
    [&](const auto *x) {
      if (x) {
        Walk(*x);
      }
    },
    node.stmt());
Walk(node.spec());
// 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 (auto *details{symbol->detailsIf<SubprogramDetails>()}) {
    if (details->isFunction()) {
      ConvertToObjectEntity(const_cast<Symbol &>(details->result()));
    }
  }
}
if (node.IsModule()) {
  ApplyDefaultAccess();
}
for (auto &child : node.children()) {
  ResolveSpecificationParts(child);
}
ExecutionPartSkimmer{*this}.Walk(node.exec());
EndScopeForNode(node);
// Ensure that every object entity has a type.
for (auto &pair : *node.scope()) {
  ApplyImplicitRules(*pair.second);
}
7771}

7773// Add SubprogramNameDetails symbols for module and internal subprograms and
7774// their ENTRY statements.
7775void ResolveNamesVisitor::AddSubpNames(ProgramTree &node) {
auto kind{
    node.IsModule() ? SubprogramKind::Module : SubprogramKind::Internal};
for (auto &child : node.children()) {
  auto &symbol{MakeSymbol(child.name(), SubprogramNameDetails{kind, child})};
  if (child.HasModulePrefix()) {
    SetExplicitAttr(symbol, Attr::MODULE);
  }
  auto childKind{child.GetKind()};
  if (childKind == ProgramTree::Kind::Function) {
    symbol.set(Symbol::Flag::Function);
  } else if (childKind == ProgramTree::Kind::Subroutine) {
    symbol.set(Symbol::Flag::Subroutine);
  } else {
    continue; // make ENTRY symbols only where valid
  }
  for (const auto &entryStmt : child.entryStmts()) {
    SubprogramNameDetails details{kind, child};
    auto &symbol{
        MakeSymbol(std::get<parser::Name>(entryStmt->t), std::move(details))};
    symbol.set(child.GetSubpFlag());
    if (child.HasModulePrefix()) {
      SetExplicitAttr(symbol, Attr::MODULE);
    }
  }
}
for (const auto &generic : node.genericSpecs()) {
  if (const auto *name{std::get_if<parser::Name>(&generic->u)}) {
    if (currScope().find(name->source) != currScope().end()) {
      // If this scope has both a generic interface and a contained
      // subprogram with the same name, create the generic's symbol
      // now so that any other generics of the same name that are pulled
      // into scope later via USE association will properly merge instead
      // of raising a bogus error due a conflict with the subprogram.
      CreateGeneric(*generic);
    }
  }
}
7813}

7815// Push a new scope for this node or return false on error.
7816bool ResolveNamesVisitor::BeginScopeForNode(const ProgramTree &node) {
switch (node.GetKind()) {
  SWITCH_COVERS_ALL_CASES
case ProgramTree::Kind::Program:
  PushScope(Scope::Kind::MainProgram,
      &MakeSymbol(node.name(), MainProgramDetails{}));
  return true;
case ProgramTree::Kind::Function:
case ProgramTree::Kind::Subroutine:
  return BeginSubprogram(node.name(), node.GetSubpFlag(),
      node.HasModulePrefix(), node.bindingSpec(), &node.entryStmts());
case ProgramTree::Kind::MpSubprogram:
  return BeginMpSubprogram(node.name());
case ProgramTree::Kind::Module:
  BeginModule(node.name(), false);
  return true;
case ProgramTree::Kind::Submodule:
  return BeginSubmodule(node.name(), node.GetParentId());
case ProgramTree::Kind::BlockData:
  PushBlockDataScope(node.name());
  return true;
}
7838}

7840void ResolveNamesVisitor::EndScopeForNode(const ProgramTree &node) {
std::optional<parser::CharBlock> stmtSource;
const std::optional<parser::LanguageBindingSpec> *binding{nullptr};
common::visit(
    common::visitors{
        [&](const parser::Statement<parser::FunctionStmt> *stmt) {
          if (stmt) {
            stmtSource = stmt->source;
            if (const auto &maybeSuffix{
                    std::get<std::optional<parser::Suffix>>(
                        stmt->statement.t)}) {
              binding = &maybeSuffix->binding;
            }
          }
        },
        [&](const parser::Statement<parser::SubroutineStmt> *stmt) {
          if (stmt) {
            stmtSource = stmt->source;
            binding = &std::get<std::optional<parser::LanguageBindingSpec>>(
                stmt->statement.t);
          }
        },
        [](const auto *) {},
    },
    node.stmt());
EndSubprogram(stmtSource, binding, &node.entryStmts());
7866}

7868// Some analyses and checks, such as the processing of initializers of
7869// pointers, are deferred until all of the pertinent specification parts
7870// have been visited.  This deferred processing enables the use of forward
7871// references in these circumstances.
7872class DeferredCheckVisitor {
7873public:
explicit DeferredCheckVisitor(ResolveNamesVisitor &resolver)
    : resolver_{resolver} {}

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 (scope->IsDerivedType()) {
        resolver_.PushScope(*scope);
        pushedScope_ = true;
      }
    }
  }
}
void Post(const parser::EndTypeStmt &) {
  if (pushedScope_) {
    resolver_.PopScope();
    pushedScope_ = false;
  }
}

void Post(const parser::ProcInterface &pi) {
  if (const auto *name{std::get_if<parser::Name>(&pi.u)}) {
    resolver_.CheckExplicitInterface(*name);
  }
}
bool Pre(const parser::EntityDecl &decl) {
  Init(std::get<parser::Name>(decl.t),
      std::get<std::optional<parser::Initialization>>(decl.t));
  return false;
}
bool Pre(const parser::ComponentDecl &decl) {
  Init(std::get<parser::Name>(decl.t),
      std::get<std::optional<parser::Initialization>>(decl.t));
  return false;
}
bool Pre(const parser::ProcDecl &decl) {
  if (const auto &init{
          std::get<std::optional<parser::ProcPointerInit>>(decl.t)}) {
    resolver_.PointerInitialization(std::get<parser::Name>(decl.t), *init);
  }
  return false;
}
void Post(const parser::TypeBoundProcedureStmt::WithInterface &tbps) {
  resolver_.CheckExplicitInterface(tbps.interfaceName);
}
void Post(const parser::TypeBoundProcedureStmt::WithoutInterface &tbps) {
  if (pushedScope_) {
    resolver_.CheckBindings(tbps);
  }
}
bool Pre(const parser::StmtFunctionStmt &stmtFunc) { return false; }

7932private:
void Init(const parser::Name &name,
    const std::optional<parser::Initialization> &init) {
  if (init) {
    if (const auto *target{
            std::get_if<parser::InitialDataTarget>(&init->u)}) {
      resolver_.PointerInitialization(name, *target);
    }
  }
}

ResolveNamesVisitor &resolver_;
bool pushedScope_{false};
7945};

7947// Perform checks and completions that need to happen after all of
7948// the specification parts but before any of the execution parts.
7949void ResolveNamesVisitor::FinishSpecificationParts(const ProgramTree &node) {
if (!node.scope()) {
  return; // error occurred creating scope
}
SetScope(*node.scope());
// The initializers of pointers, the default initializers of pointer
// components, non-deferred type-bound procedure bindings have not
// yet been traversed.
// We do that now, when any (formerly) forward references that appear
// in those initializers will resolve to the right symbols without
// incurring spurious errors with IMPLICIT NONE.
DeferredCheckVisitor{*this}.Walk(node.spec());
DeferredCheckVisitor{*this}.Walk(node.exec()); // for BLOCK
for (Scope &childScope : currScope().children()) {
  if (childScope.IsParameterizedDerivedTypeInstantiation()) {
    FinishDerivedTypeInstantiation(childScope);
  }
}
for (const auto &child : node.children()) {
  FinishSpecificationParts(child);
}
7970}

7972// Duplicate and fold component object pointer default initializer designators
7973// using the actual type parameter values of each particular instantiation.
7974// Validation is done later in declaration checking.
7975void ResolveNamesVisitor::FinishDerivedTypeInstantiation(Scope &scope) {
CHECK(scope.IsDerivedType() && !scope.symbol())((scope.IsDerivedType() && !scope.symbol()) || (Fortran
::common::die("CHECK(" "scope.IsDerivedType() && !scope.symbol()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 7976), false));
if (DerivedTypeSpec * spec{scope.derivedTypeSpec()}) {
  spec->Instantiate(currScope());
  const Symbol &origTypeSymbol{spec->typeSymbol()};
  if (const Scope * origTypeScope{origTypeSymbol.scope()}) {
    CHECK(origTypeScope->IsDerivedType() &&((origTypeScope->IsDerivedType() && origTypeScope->
symbol() == &origTypeSymbol) || (Fortran::common::die("CHECK("
 "origTypeScope->IsDerivedType() && origTypeScope->symbol() == &origTypeSymbol"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 7982), false))
        origTypeScope->symbol() == &origTypeSymbol)((origTypeScope->IsDerivedType() && origTypeScope->
symbol() == &origTypeSymbol) || (Fortran::common::die("CHECK("
 "origTypeScope->IsDerivedType() && origTypeScope->symbol() == &origTypeSymbol"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 7982), false));
    auto &foldingContext{GetFoldingContext()};
    auto restorer{foldingContext.WithPDTInstance(*spec)};
    for (auto &pair : scope) {
      Symbol &comp{*pair.second};
      const Symbol &origComp{DEREF(FindInScope(*origTypeScope, comp.name()))Fortran::common::Deref(FindInScope(*origTypeScope, comp.name(
)), "flang/lib/Semantics/resolve-names.cpp", 7987)};
      if (IsPointer(comp)) {
        if (auto *details{comp.detailsIf<ObjectEntityDetails>()}) {
          auto origDetails{origComp.get<ObjectEntityDetails>()};
          if (const MaybeExpr & init{origDetails.init()}) {
            SomeExpr newInit{*init};
            MaybeExpr folded{
                evaluate::Fold(foldingContext, std::move(newInit))};
            details->set_init(std::move(folded));
          }
        }
      }
    }
  }
}
8002}

8004// Resolve names in the execution part of this node and its children
8005void ResolveNamesVisitor::ResolveExecutionParts(const ProgramTree &node) {
if (!node.scope()) {
  return; // error occurred creating scope
}
SetScope(*node.scope());
if (const auto *exec{node.exec()}) {
  Walk(*exec);
}
FinishNamelists();
PopScope(); // converts unclassified entities into objects
for (const auto &child : node.children()) {
  ResolveExecutionParts(child);
}
8018}

8020void ResolveNamesVisitor::Post(const parser::Program &) {
// ensure that all temps were deallocated
CHECK(!attrs_)((!attrs_) || (Fortran::common::die("CHECK(" "!attrs_" ") failed"
 " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)", 8022)
, false));
CHECK(!GetDeclTypeSpec())((!GetDeclTypeSpec()) || (Fortran::common::die("CHECK(" "!GetDeclTypeSpec()"
 ") failed" " at " "flang/lib/Semantics/resolve-names.cpp" "(%d)"
, 8023), false));
8024}

8026// A singleton instance of the scope -> IMPLICIT rules mapping is
8027// shared by all instances of ResolveNamesVisitor and accessed by this
8028// pointer when the visitors (other than the top-level original) are
8029// constructed.
8030static ImplicitRulesMap *sharedImplicitRulesMap{nullptr};

8032bool ResolveNames(
  SemanticsContext &context, const parser::Program &program, Scope &top) {
ImplicitRulesMap implicitRulesMap;
auto restorer{common::ScopedSet(sharedImplicitRulesMap, &implicitRulesMap)};
ResolveNamesVisitor{context, implicitRulesMap, top}.Walk(program);
return !context.AnyFatalError();
8038}

8040// Processes a module (but not internal) function when it is referenced
8041// in a specification expression in a sibling procedure.
8042void ResolveSpecificationParts(
  SemanticsContext &context, const Symbol &subprogram) {
auto originalLocation{context.location()};
ImplicitRulesMap implicitRulesMap;
bool localImplicitRulesMap{false};
if (!sharedImplicitRulesMap) {
  sharedImplicitRulesMap = &implicitRulesMap;
  localImplicitRulesMap = true;
}
ResolveNamesVisitor visitor{
    context, *sharedImplicitRulesMap, context.globalScope()};
const auto &details{subprogram.get<SubprogramNameDetails>()};
ProgramTree &node{details.node()};
const Scope &moduleScope{subprogram.owner()};
if (localImplicitRulesMap) {
  visitor.BeginScope(const_cast<Scope &>(moduleScope));
} else {
  visitor.SetScope(const_cast<Scope &>(moduleScope));
}
visitor.ResolveSpecificationParts(node);
context.set_location(std::move(originalLocation));
if (localImplicitRulesMap) {
  sharedImplicitRulesMap = nullptr;
}
8066}

8068} // namespace Fortran::semantics

←

/build/source/flang/include/flang/Parser/parse-tree-visitor.h

1//===-- include/flang/Parser/parse-tree-visitor.h ---------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8 
9#ifndef FORTRAN_PARSER_PARSE_TREE_VISITOR_H_
10#define FORTRAN_PARSER_PARSE_TREE_VISITOR_H_
11 
12#include "parse-tree.h"
13#include "flang/Common/visit.h"
14#include <cstddef>
15#include <optional>
16#include <tuple>
17#include <utility>
18#include <variant>
19 
20/// Parse tree visitor
21/// Call Walk(x, visitor) to visit x and, by default, each node under x.
22/// If x is non-const, the visitor member functions can modify the tree.
23///
24/// visitor.Pre(x) is called before visiting x and its children are not
25/// visited if it returns false.
26///
27/// visitor.Post(x) is called after visiting x.
28 
29namespace Fortran::parser {
30 
31// Default case for visitation of non-class data members, strings, and
32// any other non-decomposable values.
33template <typename A, typename V>
34std::enable_if_t<!std::is_class_v<A> || std::is_same_v<std::string, A> ||
35    std::is_same_v<CharBlock, A>>
36Walk(const A &x, V &visitor) {
37  if (visitor.Pre(x)) {
38    visitor.Post(x);
39  }
40}
41template <typename A, typename M>
42std::enable_if_t<!std::is_class_v<A> || std::is_same_v<std::string, A> ||
43    std::is_same_v<CharBlock, A>>
44Walk(A &x, M &mutator) {
45  if (mutator.Pre(x)) {
46    mutator.Post(x);
47  }
48}
49 
50template <typename V> void Walk(const format::ControlEditDesc &, V &);
51template <typename M> void Walk(format::ControlEditDesc &, M &);
52template <typename V> void Walk(const format::DerivedTypeDataEditDesc &, V &);
53template <typename M> void Walk(format::DerivedTypeDataEditDesc &, M &);
54template <typename V> void Walk(const format::FormatItem &, V &);
55template <typename M> void Walk(format::FormatItem &, M &);
56template <typename V> void Walk(const format::FormatSpecification &, V &);
57template <typename M> void Walk(format::FormatSpecification &, M &);
58template <typename V> void Walk(const format::IntrinsicTypeDataEditDesc &, V &);
59template <typename M> void Walk(format::IntrinsicTypeDataEditDesc &, M &);
60 
61// Traversal of needed STL template classes (optional, list, tuple, variant)
62template <typename T, typename V>
63void Walk(const std::optional<T> &x, V &visitor) {
64  if (x) {
2
←
Assuming the condition is true→
3
←
Taking true branch→
65    Walk(*x, visitor);
4
←
Calling 'Walk<Fortran::parser::TypeBoundProcedurePart, Fortran::semantics::ResolveNamesVisitor>'→
66  }
67}
68template <typename T, typename M> void Walk(std::optional<T> &x, M &mutator) {
69  if (x) {
70    Walk(*x, mutator);
71  }
72}
73// For most lists, just traverse the elements; but when a list constitutes
74// a Block (i.e., std::list<ExecutionPartConstruct>), also invoke the
75// visitor/mutator on the list itself.
76template <typename T, typename V> void Walk(const std::list<T> &x, V &visitor) {
77  for (const auto &elem : x) {
78    Walk(elem, visitor);
79  }
80}
81template <typename T, typename M> void Walk(std::list<T> &x, M &mutator) {
82  for (auto &elem : x) {
83    Walk(elem, mutator);
84  }
85}
86template <typename V> void Walk(const Block &x, V &visitor) {
87  if (visitor.Pre(x)) {
88    for (const auto &elem : x) {
89      Walk(elem, visitor);
90    }
91    visitor.Post(x);
92  }
93}
94template <typename M> void Walk(Block &x, M &mutator) {
95  if (mutator.Pre(x)) {
96    for (auto &elem : x) {
97      Walk(elem, mutator);
98    }
99    mutator.Post(x);
100  }
101}
102template <std::size_t I = 0, typename Func, typename T>
103void ForEachInTuple(const T &tuple, Func func) {
104  func(std::get<I>(tuple));
105  if constexpr (I + 1 < std::tuple_size_v<T>) {
106    ForEachInTuple<I + 1>(tuple, func);
107  }
108}
109template <typename V, typename... A>
110void Walk(const std::tuple<A...> &x, V &visitor) {
111  if (sizeof...(A) > 0) {
112    if (visitor.Pre(x)) {
113      ForEachInTuple(x, [&](const auto &y) { Walk(y, visitor); });
114      visitor.Post(x);
115    }
116  }
117}
118template <std::size_t I = 0, typename Func, typename T>
119void ForEachInTuple(T &tuple, Func func) {
120  func(std::get<I>(tuple));
121  if constexpr (I + 1 < std::tuple_size_v<T>) {
122    ForEachInTuple<I + 1>(tuple, func);
123  }
124}
125template <typename M, typename... A>
126void Walk(std::tuple<A...> &x, M &mutator) {
127  if (sizeof...(A) > 0) {
128    if (mutator.Pre(x)) {
129      ForEachInTuple(x, [&](auto &y) { Walk(y, mutator); });
130      mutator.Post(x);
131    }
132  }
133}
134template <typename V, typename... A>
135void Walk(const std::variant<A...> &x, V &visitor) {
136  if (visitor.Pre(x)) {
137    common::visit([&](const auto &y) { Walk(y, visitor); }, x);
138    visitor.Post(x);
139  }
140}
141template <typename M, typename... A>
142void Walk(std::variant<A...> &x, M &mutator) {
143  if (mutator.Pre(x)) {
144    common::visit([&](auto &y) { Walk(y, mutator); }, x);
145    mutator.Post(x);
146  }
147}
148template <typename A, typename B, typename V>
149void Walk(const std::pair<A, B> &x, V &visitor) {
150  if (visitor.Pre(x)) {
151    Walk(x.first, visitor);
152    Walk(x.second, visitor);
153  }
154}
155template <typename A, typename B, typename M>
156void Walk(std::pair<A, B> &x, M &mutator) {
157  if (mutator.Pre(x)) {
158    Walk(x.first, mutator);
159    Walk(x.second, mutator);
160  }
161}
162 
163// Trait-determined traversal of empty, tuple, union, wrapper,
164// and constraint-checking classes.
165template <typename A, typename V>
166std::enable_if_t<EmptyTrait<A>> Walk(const A &x, V &visitor) {
167  if (visitor.Pre(x)) {
168    visitor.Post(x);
169  }
170}
171template <typename A, typename M>
172std::enable_if_t<EmptyTrait<A>> Walk(A &x, M &mutator) {
173  if (mutator.Pre(x)) {
174    mutator.Post(x);
175  }
176}
177 
178template <typename A, typename V>
179std::enable_if_t<TupleTrait<A>> Walk(const A &x, V &visitor) {
180  if (visitor.Pre(x)) {
5
←
Taking true branch→
181    Walk(x.t, visitor);
182    visitor.Post(x);
6
←
Calling 'DeclarationVisitor::Post'→
183  }
184}
185template <typename A, typename M>
186std::enable_if_t<TupleTrait<A>> Walk(A &x, M &mutator) {
187  if (mutator.Pre(x)) {
188    Walk(x.t, mutator);
189    mutator.Post(x);
190  }
191}
192 
193template <typename A, typename V>
194std::enable_if_t<UnionTrait<A>> Walk(const A &x, V &visitor) {
195  if (visitor.Pre(x)) {
196    Walk(x.u, visitor);
197    visitor.Post(x);
198  }
199}
200template <typename A, typename M>
201std::enable_if_t<UnionTrait<A>> Walk(A &x, M &mutator) {
202  if (mutator.Pre(x)) {
203    Walk(x.u, mutator);
204    mutator.Post(x);
205  }
206}
207 
208template <typename A, typename V>
209std::enable_if_t<WrapperTrait<A>> Walk(const A &x, V &visitor) {
210  if (visitor.Pre(x)) {
211    Walk(x.v, visitor);
212    visitor.Post(x);
213  }
214}
215template <typename A, typename M>
216std::enable_if_t<WrapperTrait<A>> Walk(A &x, M &mutator) {
217  if (mutator.Pre(x)) {
218    Walk(x.v, mutator);
219    mutator.Post(x);
220  }
221}
222 
223template <typename A, typename V>
224std::enable_if_t<ConstraintTrait<A>> Walk(const A &x, V &visitor) {
225  if (visitor.Pre(x)) {
226    Walk(x.thing, visitor);
227    visitor.Post(x);
228  }
229}
230template <typename A, typename M>
231std::enable_if_t<ConstraintTrait<A>> Walk(A &x, M &mutator) {
232  if (mutator.Pre(x)) {
233    Walk(x.thing, mutator);
234    mutator.Post(x);
235  }
236}
237 
238template <typename T, typename V>
239void Walk(const common::Indirection<T> &x, V &visitor) {
240  Walk(x.value(), visitor);
241}
242template <typename T, typename M>
243void Walk(common::Indirection<T> &x, M &mutator) {
244  Walk(x.value(), mutator);
245}
246 
247template <typename T, typename V> void Walk(const Statement<T> &x, V &visitor) {
248  if (visitor.Pre(x)) {
249    // N.B. The label, if any, is not visited.
250    Walk(x.source, visitor);
251    Walk(x.statement, visitor);
252    visitor.Post(x);
253  }
254}
255template <typename T, typename M> void Walk(Statement<T> &x, M &mutator) {
256  if (mutator.Pre(x)) {
257    // N.B. The label, if any, is not visited.
258    Walk(x.source, mutator);
259    Walk(x.statement, mutator);
260    mutator.Post(x);
261  }
262}
263 
264template <typename T, typename V>
265void Walk(const UnlabeledStatement<T> &x, V &visitor) {
266  if (visitor.Pre(x)) {
267    Walk(x.source, visitor);
268    Walk(x.statement, visitor);
269    visitor.Post(x);
270  }
271}
272template <typename T, typename M>
273void Walk(UnlabeledStatement<T> &x, M &mutator) {
274  if (mutator.Pre(x)) {
275    Walk(x.source, mutator);
276    Walk(x.statement, mutator);
277    mutator.Post(x);
278  }
279}
280 
281template <typename V> void Walk(const Name &x, V &visitor) {
282  if (visitor.Pre(x)) {
283    Walk(x.source, visitor);
284    visitor.Post(x);
285  }
286}
287template <typename M> void Walk(Name &x, M &mutator) {
288  if (mutator.Pre(x)) {
289    Walk(x.source, mutator);
290    mutator.Post(x);
291  }
292}
293 
294template <typename V> void Walk(const AcSpec &x, V &visitor) {
295  if (visitor.Pre(x)) {
296    Walk(x.type, visitor);
297    Walk(x.values, visitor);
298    visitor.Post(x);
299  }
300}
301template <typename M> void Walk(AcSpec &x, M &mutator) {
302  if (mutator.Pre(x)) {
303    Walk(x.type, mutator);
304    Walk(x.values, mutator);
305    mutator.Post(x);
306  }
307}
308template <typename V> void Walk(const ArrayElement &x, V &visitor) {
309  if (visitor.Pre(x)) {
310    Walk(x.base, visitor);
311    Walk(x.subscripts, visitor);
312    visitor.Post(x);
313  }
314}
315template <typename M> void Walk(ArrayElement &x, M &mutator) {
316  if (mutator.Pre(x)) {
317    Walk(x.base, mutator);
318    Walk(x.subscripts, mutator);
319    mutator.Post(x);
320  }
321}
322template <typename V>
323void Walk(const CharSelector::LengthAndKind &x, V &visitor) {
324  if (visitor.Pre(x)) {
325    Walk(x.length, visitor);
326    Walk(x.kind, visitor);
327    visitor.Post(x);
328  }
329}
330template <typename M> void Walk(CharSelector::LengthAndKind &x, M &mutator) {
331  if (mutator.Pre(x)) {
332    Walk(x.length, mutator);
333    Walk(x.kind, mutator);
334    mutator.Post(x);
335  }
336}
337template <typename V> void Walk(const CaseValueRange::Range &x, V &visitor) {
338  if (visitor.Pre(x)) {
339    Walk(x.lower, visitor);
340    Walk(x.upper, visitor);
341    visitor.Post(x);
342  }
343}
344template <typename M> void Walk(CaseValueRange::Range &x, M &mutator) {
345  if (mutator.Pre(x)) {
346    Walk(x.lower, mutator);
347    Walk(x.upper, mutator);
348    mutator.Post(x);
349  }
350}
351template <typename V> void Walk(const CoindexedNamedObject &x, V &visitor) {
352  if (visitor.Pre(x)) {
353    Walk(x.base, visitor);
354    Walk(x.imageSelector, visitor);
355    visitor.Post(x);
356  }
357}
358template <typename M> void Walk(CoindexedNamedObject &x, M &mutator) {
359  if (mutator.Pre(x)) {
360    Walk(x.base, mutator);
361    Walk(x.imageSelector, mutator);
362    mutator.Post(x);
363  }
364}
365template <typename V>
366void Walk(const DeclarationTypeSpec::Class &x, V &visitor) {
367  if (visitor.Pre(x)) {
368    Walk(x.derived, visitor);
369    visitor.Post(x);
370  }
371}
372template <typename M> void Walk(DeclarationTypeSpec::Class &x, M &mutator) {
373  if (mutator.Pre(x)) {
374    Walk(x.derived, mutator);
375    mutator.Post(x);
376  }
377}
378template <typename V>
379void Walk(const DeclarationTypeSpec::Type &x, V &visitor) {
380  if (visitor.Pre(x)) {
381    Walk(x.derived, visitor);
382    visitor.Post(x);
383  }
384}
385template <typename M> void Walk(DeclarationTypeSpec::Type &x, M &mutator) {
386  if (mutator.Pre(x)) {
387    Walk(x.derived, mutator);
388    mutator.Post(x);
389  }
390}
391template <typename V> void Walk(const ImportStmt &x, V &visitor) {
392  if (visitor.Pre(x)) {
393    Walk(x.names, visitor);
394    visitor.Post(x);
395  }
396}
397template <typename M> void Walk(ImportStmt &x, M &mutator) {
398  if (mutator.Pre(x)) {
399    Walk(x.names, mutator);
400    mutator.Post(x);
401  }
402}
403template <typename V>
404void Walk(const IntrinsicTypeSpec::Character &x, V &visitor) {
405  if (visitor.Pre(x)) {
406    Walk(x.selector, visitor);
407    visitor.Post(x);
408  }
409}
410template <typename M> void Walk(IntrinsicTypeSpec::Character &x, M &mutator) {
411  if (mutator.Pre(x)) {
412    Walk(x.selector, mutator);
413    mutator.Post(x);
414  }
415}
416template <typename V>
417void Walk(const IntrinsicTypeSpec::Complex &x, V &visitor) {
418  if (visitor.Pre(x)) {
419    Walk(x.kind, visitor);
420    visitor.Post(x);
421  }
422}
423template <typename M> void Walk(IntrinsicTypeSpec::Complex &x, M &mutator) {
424  if (mutator.Pre(x)) {
425    Walk(x.kind, mutator);
426    mutator.Post(x);
427  }
428}
429template <typename V>
430void Walk(const IntrinsicTypeSpec::Logical &x, V &visitor) {
431  if (visitor.Pre(x)) {
432    Walk(x.kind, visitor);
433    visitor.Post(x);
434  }
435}
436template <typename M> void Walk(IntrinsicTypeSpec::Logical &x, M &mutator) {
437  if (mutator.Pre(x)) {
438    Walk(x.kind, mutator);
439    mutator.Post(x);
440  }
441}
442template <typename V> void Walk(const IntrinsicTypeSpec::Real &x, V &visitor) {
443  if (visitor.Pre(x)) {
444    Walk(x.kind, visitor);
445    visitor.Post(x);
446  }
447}
448template <typename M> void Walk(IntrinsicTypeSpec::Real &x, M &mutator) {
449  if (mutator.Pre(x)) {
450    Walk(x.kind, mutator);
451    mutator.Post(x);
452  }
453}
454template <typename A, typename B, typename V>
455void Walk(const LoopBounds<A, B> &x, V &visitor) {
456  if (visitor.Pre(x)) {
457    Walk(x.name, visitor);
458    Walk(x.lower, visitor);
459    Walk(x.upper, visitor);
460    Walk(x.step, visitor);
461    visitor.Post(x);
462  }
463}
464template <typename A, typename B, typename M>
465void Walk(LoopBounds<A, B> &x, M &mutator) {
466  if (mutator.Pre(x)) {
467    Walk(x.name, mutator);
468    Walk(x.lower, mutator);
469    Walk(x.upper, mutator);
470    Walk(x.step, mutator);
471    mutator.Post(x);
472  }
473}
474template <typename V> void Walk(const CommonStmt &x, V &visitor) {
475  if (visitor.Pre(x)) {
476    Walk(x.blocks, visitor);
477    visitor.Post(x);
478  }
479}
480template <typename M> void Walk(CommonStmt &x, M &mutator) {
481  if (mutator.Pre(x)) {
482    Walk(x.blocks, mutator);
483    mutator.Post(x);
484  }
485}
486template <typename V> void Walk(const Expr &x, V &visitor) {
487  if (visitor.Pre(x)) {
488    Walk(x.source, visitor);
489    Walk(x.u, visitor);
490    visitor.Post(x);
491  }
492}
493template <typename M> void Walk(Expr &x, M &mutator) {
494  if (mutator.Pre(x)) {
495    Walk(x.source, mutator);
496    Walk(x.u, mutator);
497    mutator.Post(x);
498  }
499}
500template <typename V> void Walk(const Designator &x, V &visitor) {
501  if (visitor.Pre(x)) {
502    Walk(x.source, visitor);
503    Walk(x.u, visitor);
504    visitor.Post(x);
505  }
506}
507template <typename M> void Walk(Designator &x, M &mutator) {
508  if (mutator.Pre(x)) {
509    Walk(x.source, mutator);
510    Walk(x.u, mutator);
511    mutator.Post(x);
512  }
513}
514template <typename V> void Walk(const Call &x, V &visitor) {
515  if (visitor.Pre(x)) {
516    Walk(x.source, visitor);
517    Walk(x.t, visitor);
518    visitor.Post(x);
519  }
520}
521template <typename M> void Walk(Call &x, M &mutator) {
522  if (mutator.Pre(x)) {
523    Walk(x.source, mutator);
524    Walk(x.t, mutator);
525    mutator.Post(x);
526  }
527}
528template <typename V> void Walk(const PartRef &x, V &visitor) {
529  if (visitor.Pre(x)) {
530    Walk(x.name, visitor);
531    Walk(x.subscripts, visitor);
532    Walk(x.imageSelector, visitor);
533    visitor.Post(x);
534  }
535}
536template <typename M> void Walk(PartRef &x, M &mutator) {
537  if (mutator.Pre(x)) {
538    Walk(x.name, mutator);
539    Walk(x.subscripts, mutator);
540    Walk(x.imageSelector, mutator);
541    mutator.Post(x);
542  }
543}
544template <typename V> void Walk(const ReadStmt &x, V &visitor) {
545  if (visitor.Pre(x)) {
546    Walk(x.iounit, visitor);
547    Walk(x.format, visitor);
548    Walk(x.controls, visitor);
549    Walk(x.items, visitor);
550    visitor.Post(x);
551  }
552}
553template <typename M> void Walk(ReadStmt &x, M &mutator) {
554  if (mutator.Pre(x)) {
555    Walk(x.iounit, mutator);
556    Walk(x.format, mutator);
557    Walk(x.controls, mutator);
558    Walk(x.items, mutator);
559    mutator.Post(x);
560  }
561}
562template <typename V> void Walk(const SignedIntLiteralConstant &x, V &visitor) {
563  if (visitor.Pre(x)) {
564    Walk(x.source, visitor);
565    Walk(x.t, visitor);
566    visitor.Post(x);
567  }
568}
569template <typename M> void Walk(SignedIntLiteralConstant &x, M &mutator) {
570  if (mutator.Pre(x)) {
571    Walk(x.source, mutator);
572    Walk(x.t, mutator);
573    mutator.Post(x);
574  }
575}
576template <typename V> void Walk(const RealLiteralConstant &x, V &visitor) {
577  if (visitor.Pre(x)) {
578    Walk(x.real, visitor);
579    Walk(x.kind, visitor);
580    visitor.Post(x);
581  }
582}
583template <typename M> void Walk(RealLiteralConstant &x, M &mutator) {
584  if (mutator.Pre(x)) {
585    Walk(x.real, mutator);
586    Walk(x.kind, mutator);
587    mutator.Post(x);
588  }
589}
590template <typename V>
591void Walk(const RealLiteralConstant::Real &x, V &visitor) {
592  if (visitor.Pre(x)) {
593    Walk(x.source, visitor);
594    visitor.Post(x);
595  }
596}
597template <typename M> void Walk(RealLiteralConstant::Real &x, M &mutator) {
598  if (mutator.Pre(x)) {
599    Walk(x.source, mutator);
600    mutator.Post(x);
601  }
602}
603template <typename V> void Walk(const StructureComponent &x, V &visitor) {
604  if (visitor.Pre(x)) {
605    Walk(x.base, visitor);
606    Walk(x.component, visitor);
607    visitor.Post(x);
608  }
609}
610template <typename M> void Walk(StructureComponent &x, M &mutator) {
611  if (mutator.Pre(x)) {
612    Walk(x.base, mutator);
613    Walk(x.component, mutator);
614    mutator.Post(x);
615  }
616}
617template <typename V> void Walk(const Suffix &x, V &visitor) {
618  if (visitor.Pre(x)) {
619    Walk(x.binding, visitor);
620    Walk(x.resultName, visitor);
621    visitor.Post(x);
622  }
623}
624template <typename M> void Walk(Suffix &x, M &mutator) {
625  if (mutator.Pre(x)) {
626    Walk(x.binding, mutator);
627    Walk(x.resultName, mutator);
628    mutator.Post(x);
629  }
630}
631template <typename V>
632void Walk(const TypeBoundProcedureStmt::WithInterface &x, V &visitor) {
633  if (visitor.Pre(x)) {
634    Walk(x.interfaceName, visitor);
635    Walk(x.attributes, visitor);
636    Walk(x.bindingNames, visitor);
637    visitor.Post(x);
638  }
639}
640template <typename M>
641void Walk(TypeBoundProcedureStmt::WithInterface &x, M &mutator) {
642  if (mutator.Pre(x)) {
643    Walk(x.interfaceName, mutator);
644    Walk(x.attributes, mutator);
645    Walk(x.bindingNames, mutator);
646    mutator.Post(x);
647  }
648}
649template <typename V>
650void Walk(const TypeBoundProcedureStmt::WithoutInterface &x, V &visitor) {
651  if (visitor.Pre(x)) {
652    Walk(x.attributes, visitor);
653    Walk(x.declarations, visitor);
654    visitor.Post(x);
655  }
656}
657template <typename M>
658void Walk(TypeBoundProcedureStmt::WithoutInterface &x, M &mutator) {
659  if (mutator.Pre(x)) {
660    Walk(x.attributes, mutator);
661    Walk(x.declarations, mutator);
662    mutator.Post(x);
663  }
664}
665template <typename V> void Walk(const UseStmt &x, V &visitor) {
666  if (visitor.Pre(x)) {
667    Walk(x.nature, visitor);
668    Walk(x.moduleName, visitor);
669    Walk(x.u, visitor);
670    visitor.Post(x);
671  }
672}
673template <typename M> void Walk(UseStmt &x, M &mutator) {
674  if (mutator.Pre(x)) {
675    Walk(x.nature, mutator);
676    Walk(x.moduleName, mutator);
677    Walk(x.u, mutator);
678    mutator.Post(x);
679  }
680}
681template <typename V> void Walk(const WriteStmt &x, V &visitor) {
682  if (visitor.Pre(x)) {
683    Walk(x.iounit, visitor);
684    Walk(x.format, visitor);
685    Walk(x.controls, visitor);
686    Walk(x.items, visitor);
687    visitor.Post(x);
688  }
689}
690template <typename M> void Walk(WriteStmt &x, M &mutator) {
691  if (mutator.Pre(x)) {
692    Walk(x.iounit, mutator);
693    Walk(x.format, mutator);
694    Walk(x.controls, mutator);
695    Walk(x.items, mutator);
696    mutator.Post(x);
697  }
698}
699template <typename V> void Walk(const format::ControlEditDesc &x, V &visitor) {
700  if (visitor.Pre(x)) {
701    Walk(x.kind, visitor);
702    visitor.Post(x);
703  }
704}
705template <typename M> void Walk(format::ControlEditDesc &x, M &mutator) {
706  if (mutator.Pre(x)) {
707    Walk(x.kind, mutator);
708    mutator.Post(x);
709  }
710}
711template <typename V>
712void Walk(const format::DerivedTypeDataEditDesc &x, V &visitor) {
713  if (visitor.Pre(x)) {
714    Walk(x.type, visitor);
715    Walk(x.parameters, visitor);
716    visitor.Post(x);
717  }
718}
719template <typename M>
720void Walk(format::DerivedTypeDataEditDesc &x, M &mutator) {
721  if (mutator.Pre(x)) {
722    Walk(x.type, mutator);
723    Walk(x.parameters, mutator);
724    mutator.Post(x);
725  }
726}
727template <typename V> void Walk(const format::FormatItem &x, V &visitor) {
728  if (visitor.Pre(x)) {
729    Walk(x.repeatCount, visitor);
730    Walk(x.u, visitor);
731    visitor.Post(x);
732  }
733}
734template <typename M> void Walk(format::FormatItem &x, M &mutator) {
735  if (mutator.Pre(x)) {
736    Walk(x.repeatCount, mutator);
737    Walk(x.u, mutator);
738    mutator.Post(x);
739  }
740}
741template <typename V>
742void Walk(const format::FormatSpecification &x, V &visitor) {
743  if (visitor.Pre(x)) {
744    Walk(x.items, visitor);
745    Walk(x.unlimitedItems, visitor);
746    visitor.Post(x);
747  }
748}
749template <typename M> void Walk(format::FormatSpecification &x, M &mutator) {
750  if (mutator.Pre(x)) {
751    Walk(x.items, mutator);
752    Walk(x.unlimitedItems, mutator);
753    mutator.Post(x);
754  }
755}
756template <typename V>
757void Walk(const format::IntrinsicTypeDataEditDesc &x, V &visitor) {
758  if (visitor.Pre(x)) {
759    Walk(x.kind, visitor);
760    Walk(x.width, visitor);
761    Walk(x.digits, visitor);
762    Walk(x.exponentWidth, visitor);
763    visitor.Post(x);
764  }
765}
766template <typename M>
767void Walk(format::IntrinsicTypeDataEditDesc &x, M &mutator) {
768  if (mutator.Pre(x)) {
769    Walk(x.kind, mutator);
770    Walk(x.width, mutator);
771    Walk(x.digits, mutator);
772    Walk(x.exponentWidth, mutator);
773    mutator.Post(x);
774  }
775}
776template <typename V> void Walk(const CompilerDirective &x, V &visitor) {
777  if (visitor.Pre(x)) {
778    Walk(x.source, visitor);
779    Walk(x.u, visitor);
780    visitor.Post(x);
781  }
782}
783template <typename M> void Walk(CompilerDirective &x, M &mutator) {
784  if (mutator.Pre(x)) {
785    Walk(x.source, mutator);
786    Walk(x.u, mutator);
787    mutator.Post(x);
788  }
789}
790template <typename V>
791void Walk(const OmpLinearClause::WithModifier &x, V &visitor) {
792  if (visitor.Pre(x)) {
793    Walk(x.modifier, visitor);
794    Walk(x.names, visitor);
795    Walk(x.step, visitor);
796    visitor.Post(x);
797  }
798}
799template <typename M> void Walk(OmpLinearClause::WithModifier &x, M &mutator) {
800  if (mutator.Pre(x)) {
801    Walk(x.modifier, mutator);
802    Walk(x.names, mutator);
803    Walk(x.step, mutator);
804    mutator.Post(x);
805  }
806}
807template <typename V>
808void Walk(const OmpLinearClause::WithoutModifier &x, V &visitor) {
809  if (visitor.Pre(x)) {
810    Walk(x.names, visitor);
811    Walk(x.step, visitor);
812    visitor.Post(x);
813  }
814}
815template <typename M>
816void Walk(OmpLinearClause::WithoutModifier &x, M &mutator) {
817  if (mutator.Pre(x)) {
818    Walk(x.names, mutator);
819    Walk(x.step, mutator);
820    mutator.Post(x);
821  }
822}
823} // namespace Fortran::parser
824#endif // FORTRAN_PARSER_PARSE_TREE_VISITOR_H_