mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-26 15:56:07 +00:00
eb4ad0e3e3
Binding labels start as expressions but they have to evaluate to constant character of default kind, so they can be represented as an std::string. Leading and trailing blanks have to be removed, so the folded expression isn't exactly right anyway. So all BIND(C) symbols now have a string binding label, either the default or user-supplied one. This is recorded in the .mod file. Add WithBindName mix-in for details classes that can have a binding label so that they are all consistent. Add GetBindName() and SetBindName() member functions to Symbol. Add tests that verifies that leading and trailing blanks are ignored in binding labels and that the default label is folded to lower case. Differential Revision: https://reviews.llvm.org/D99208
679 lines
20 KiB
C++
679 lines
20 KiB
C++
//===-- lib/Semantics/symbol.cpp ------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "flang/Semantics/symbol.h"
|
|
#include "flang/Common/idioms.h"
|
|
#include "flang/Evaluate/expression.h"
|
|
#include "flang/Semantics/scope.h"
|
|
#include "flang/Semantics/semantics.h"
|
|
#include "flang/Semantics/tools.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <string>
|
|
#include <type_traits>
|
|
|
|
namespace Fortran::semantics {
|
|
|
|
template <typename T>
|
|
static void DumpOptional(llvm::raw_ostream &os, const char *label, const T &x) {
|
|
if (x) {
|
|
os << ' ' << label << ':' << *x;
|
|
}
|
|
}
|
|
template <typename T>
|
|
static void DumpExpr(llvm::raw_ostream &os, const char *label,
|
|
const std::optional<evaluate::Expr<T>> &x) {
|
|
if (x) {
|
|
x->AsFortran(os << ' ' << label << ':');
|
|
}
|
|
}
|
|
|
|
static void DumpBool(llvm::raw_ostream &os, const char *label, bool x) {
|
|
if (x) {
|
|
os << ' ' << label;
|
|
}
|
|
}
|
|
|
|
static void DumpSymbolVector(llvm::raw_ostream &os, const SymbolVector &list) {
|
|
char sep{' '};
|
|
for (const Symbol &elem : list) {
|
|
os << sep << elem.name();
|
|
sep = ',';
|
|
}
|
|
}
|
|
|
|
static void DumpType(llvm::raw_ostream &os, const Symbol &symbol) {
|
|
if (const auto *type{symbol.GetType()}) {
|
|
os << *type << ' ';
|
|
}
|
|
}
|
|
static void DumpType(llvm::raw_ostream &os, const DeclTypeSpec *type) {
|
|
if (type) {
|
|
os << ' ' << *type;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
static void DumpList(llvm::raw_ostream &os, const char *label, const T &list) {
|
|
if (!list.empty()) {
|
|
os << ' ' << label << ':';
|
|
char sep{' '};
|
|
for (const auto &elem : list) {
|
|
os << sep << elem;
|
|
sep = ',';
|
|
}
|
|
}
|
|
}
|
|
|
|
const Scope *ModuleDetails::parent() const {
|
|
return isSubmodule_ && scope_ ? &scope_->parent() : nullptr;
|
|
}
|
|
const Scope *ModuleDetails::ancestor() const {
|
|
return isSubmodule_ && scope_ ? FindModuleContaining(*scope_) : nullptr;
|
|
}
|
|
void ModuleDetails::set_scope(const Scope *scope) {
|
|
CHECK(!scope_);
|
|
bool scopeIsSubmodule{scope->parent().kind() == Scope::Kind::Module};
|
|
CHECK(isSubmodule_ == scopeIsSubmodule);
|
|
scope_ = scope;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(
|
|
llvm::raw_ostream &os, const SubprogramDetails &x) {
|
|
DumpBool(os, "isInterface", x.isInterface_);
|
|
DumpOptional(os, "bindName", x.bindName());
|
|
if (x.result_) {
|
|
DumpType(os << " result:", x.result());
|
|
os << x.result_->name();
|
|
if (!x.result_->attrs().empty()) {
|
|
os << ", " << x.result_->attrs();
|
|
}
|
|
}
|
|
if (x.entryScope_) {
|
|
os << " entry";
|
|
if (x.entryScope_->symbol()) {
|
|
os << " in " << x.entryScope_->symbol()->name();
|
|
}
|
|
}
|
|
char sep{'('};
|
|
os << ' ';
|
|
for (const Symbol *arg : x.dummyArgs_) {
|
|
os << sep;
|
|
sep = ',';
|
|
if (arg) {
|
|
DumpType(os, *arg);
|
|
os << arg->name();
|
|
} else {
|
|
os << '*';
|
|
}
|
|
}
|
|
os << (sep == '(' ? "()" : ")");
|
|
if (x.stmtFunction_) {
|
|
os << " -> " << x.stmtFunction_->AsFortran();
|
|
}
|
|
return os;
|
|
}
|
|
|
|
void EntityDetails::set_type(const DeclTypeSpec &type) {
|
|
CHECK(!type_);
|
|
type_ = &type;
|
|
}
|
|
|
|
void AssocEntityDetails::set_rank(int rank) { rank_ = rank; }
|
|
void EntityDetails::ReplaceType(const DeclTypeSpec &type) { type_ = &type; }
|
|
|
|
void ObjectEntityDetails::set_shape(const ArraySpec &shape) {
|
|
CHECK(shape_.empty());
|
|
for (const auto &shapeSpec : shape) {
|
|
shape_.push_back(shapeSpec);
|
|
}
|
|
}
|
|
void ObjectEntityDetails::set_coshape(const ArraySpec &coshape) {
|
|
CHECK(coshape_.empty());
|
|
for (const auto &shapeSpec : coshape) {
|
|
coshape_.push_back(shapeSpec);
|
|
}
|
|
}
|
|
|
|
ProcEntityDetails::ProcEntityDetails(EntityDetails &&d) : EntityDetails(d) {
|
|
if (type()) {
|
|
interface_.set_type(*type());
|
|
}
|
|
}
|
|
|
|
UseErrorDetails::UseErrorDetails(const UseDetails &useDetails) {
|
|
add_occurrence(useDetails.location(), *GetUsedModule(useDetails).scope());
|
|
}
|
|
UseErrorDetails &UseErrorDetails::add_occurrence(
|
|
const SourceName &location, const Scope &module) {
|
|
occurrences_.push_back(std::make_pair(location, &module));
|
|
return *this;
|
|
}
|
|
|
|
void GenericDetails::AddSpecificProc(
|
|
const Symbol &proc, SourceName bindingName) {
|
|
specificProcs_.push_back(proc);
|
|
bindingNames_.push_back(bindingName);
|
|
}
|
|
void GenericDetails::set_specific(Symbol &specific) {
|
|
CHECK(!specific_);
|
|
CHECK(!derivedType_);
|
|
specific_ = &specific;
|
|
}
|
|
void GenericDetails::set_derivedType(Symbol &derivedType) {
|
|
CHECK(!specific_);
|
|
CHECK(!derivedType_);
|
|
derivedType_ = &derivedType;
|
|
}
|
|
void GenericDetails::AddUse(const Symbol &use) {
|
|
CHECK(use.has<UseDetails>());
|
|
uses_.push_back(use);
|
|
}
|
|
|
|
const Symbol *GenericDetails::CheckSpecific() const {
|
|
return const_cast<GenericDetails *>(this)->CheckSpecific();
|
|
}
|
|
Symbol *GenericDetails::CheckSpecific() {
|
|
if (specific_) {
|
|
for (const Symbol &proc : specificProcs_) {
|
|
if (&proc == specific_) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
return specific_;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
void GenericDetails::CopyFrom(const GenericDetails &from) {
|
|
CHECK(specificProcs_.size() == bindingNames_.size());
|
|
CHECK(from.specificProcs_.size() == from.bindingNames_.size());
|
|
kind_ = from.kind_;
|
|
if (from.derivedType_) {
|
|
CHECK(!derivedType_ || derivedType_ == from.derivedType_);
|
|
derivedType_ = from.derivedType_;
|
|
}
|
|
for (std::size_t i{0}; i < from.specificProcs_.size(); ++i) {
|
|
if (std::find_if(specificProcs_.begin(), specificProcs_.end(),
|
|
[&](const Symbol &mySymbol) {
|
|
return &mySymbol == &*from.specificProcs_[i];
|
|
}) == specificProcs_.end()) {
|
|
specificProcs_.push_back(from.specificProcs_[i]);
|
|
bindingNames_.push_back(from.bindingNames_[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// The name of the kind of details for this symbol.
|
|
// This is primarily for debugging.
|
|
std::string DetailsToString(const Details &details) {
|
|
return std::visit(
|
|
common::visitors{
|
|
[](const UnknownDetails &) { return "Unknown"; },
|
|
[](const MainProgramDetails &) { return "MainProgram"; },
|
|
[](const ModuleDetails &) { return "Module"; },
|
|
[](const SubprogramDetails &) { return "Subprogram"; },
|
|
[](const SubprogramNameDetails &) { return "SubprogramName"; },
|
|
[](const EntityDetails &) { return "Entity"; },
|
|
[](const ObjectEntityDetails &) { return "ObjectEntity"; },
|
|
[](const ProcEntityDetails &) { return "ProcEntity"; },
|
|
[](const DerivedTypeDetails &) { return "DerivedType"; },
|
|
[](const UseDetails &) { return "Use"; },
|
|
[](const UseErrorDetails &) { return "UseError"; },
|
|
[](const HostAssocDetails &) { return "HostAssoc"; },
|
|
[](const GenericDetails &) { return "Generic"; },
|
|
[](const ProcBindingDetails &) { return "ProcBinding"; },
|
|
[](const NamelistDetails &) { return "Namelist"; },
|
|
[](const CommonBlockDetails &) { return "CommonBlockDetails"; },
|
|
[](const TypeParamDetails &) { return "TypeParam"; },
|
|
[](const MiscDetails &) { return "Misc"; },
|
|
[](const AssocEntityDetails &) { return "AssocEntity"; },
|
|
},
|
|
details);
|
|
}
|
|
|
|
const std::string Symbol::GetDetailsName() const {
|
|
return DetailsToString(details_);
|
|
}
|
|
|
|
void Symbol::set_details(Details &&details) {
|
|
CHECK(CanReplaceDetails(details));
|
|
details_ = std::move(details);
|
|
}
|
|
|
|
bool Symbol::CanReplaceDetails(const Details &details) const {
|
|
if (has<UnknownDetails>()) {
|
|
return true; // can always replace UnknownDetails
|
|
} else {
|
|
return std::visit(
|
|
common::visitors{
|
|
[](const UseErrorDetails &) { return true; },
|
|
[&](const ObjectEntityDetails &) { return has<EntityDetails>(); },
|
|
[&](const ProcEntityDetails &) { return has<EntityDetails>(); },
|
|
[&](const SubprogramDetails &) {
|
|
return has<SubprogramNameDetails>() || has<EntityDetails>();
|
|
},
|
|
[&](const DerivedTypeDetails &) {
|
|
const auto *derived{this->detailsIf<DerivedTypeDetails>()};
|
|
return derived && derived->isForwardReferenced();
|
|
},
|
|
[&](const UseDetails &x) {
|
|
const auto *use{this->detailsIf<UseDetails>()};
|
|
return use && use->symbol() == x.symbol();
|
|
},
|
|
[](const auto &) { return false; },
|
|
},
|
|
details);
|
|
}
|
|
}
|
|
|
|
// Usually a symbol's name is the first occurrence in the source, but sometimes
|
|
// we want to replace it with one at a different location (but same characters).
|
|
void Symbol::ReplaceName(const SourceName &name) {
|
|
CHECK(name == name_);
|
|
name_ = name;
|
|
}
|
|
|
|
void Symbol::SetType(const DeclTypeSpec &type) {
|
|
std::visit(common::visitors{
|
|
[&](EntityDetails &x) { x.set_type(type); },
|
|
[&](ObjectEntityDetails &x) { x.set_type(type); },
|
|
[&](AssocEntityDetails &x) { x.set_type(type); },
|
|
[&](ProcEntityDetails &x) { x.interface().set_type(type); },
|
|
[&](TypeParamDetails &x) { x.set_type(type); },
|
|
[](auto &) {},
|
|
},
|
|
details_);
|
|
}
|
|
|
|
template <typename T>
|
|
constexpr bool HasBindName{std::is_convertible_v<T, const WithBindName *>};
|
|
|
|
const std::string *Symbol::GetBindName() const {
|
|
return std::visit(
|
|
[&](auto &x) -> const std::string * {
|
|
if constexpr (HasBindName<decltype(&x)>) {
|
|
return x.bindName();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
},
|
|
details_);
|
|
}
|
|
|
|
void Symbol::SetBindName(std::string &&name) {
|
|
std::visit(
|
|
[&](auto &x) {
|
|
if constexpr (HasBindName<decltype(&x)>) {
|
|
x.set_bindName(std::move(name));
|
|
} else {
|
|
DIE("bind name not allowed on this kind of symbol");
|
|
}
|
|
},
|
|
details_);
|
|
}
|
|
|
|
bool Symbol::IsFuncResult() const {
|
|
return std::visit(
|
|
common::visitors{[](const EntityDetails &x) { return x.isFuncResult(); },
|
|
[](const ObjectEntityDetails &x) { return x.isFuncResult(); },
|
|
[](const ProcEntityDetails &x) { return x.isFuncResult(); },
|
|
[](const HostAssocDetails &x) { return x.symbol().IsFuncResult(); },
|
|
[](const auto &) { return false; }},
|
|
details_);
|
|
}
|
|
|
|
bool Symbol::IsObjectArray() const {
|
|
const auto *details{std::get_if<ObjectEntityDetails>(&details_)};
|
|
return details && details->IsArray();
|
|
}
|
|
|
|
bool Symbol::IsSubprogram() const {
|
|
return std::visit(
|
|
common::visitors{
|
|
[](const SubprogramDetails &) { return true; },
|
|
[](const SubprogramNameDetails &) { return true; },
|
|
[](const GenericDetails &) { return true; },
|
|
[](const UseDetails &x) { return x.symbol().IsSubprogram(); },
|
|
[](const auto &) { return false; },
|
|
},
|
|
details_);
|
|
}
|
|
|
|
bool Symbol::IsFromModFile() const {
|
|
return test(Flag::ModFile) ||
|
|
(!owner_->IsGlobal() && owner_->symbol()->IsFromModFile());
|
|
}
|
|
|
|
ObjectEntityDetails::ObjectEntityDetails(EntityDetails &&d)
|
|
: EntityDetails(d) {}
|
|
|
|
llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const EntityDetails &x) {
|
|
DumpBool(os, "dummy", x.isDummy());
|
|
DumpBool(os, "funcResult", x.isFuncResult());
|
|
if (x.type()) {
|
|
os << " type: " << *x.type();
|
|
}
|
|
DumpOptional(os, "bindName", x.bindName());
|
|
return os;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(
|
|
llvm::raw_ostream &os, const ObjectEntityDetails &x) {
|
|
os << *static_cast<const EntityDetails *>(&x);
|
|
DumpList(os, "shape", x.shape());
|
|
DumpList(os, "coshape", x.coshape());
|
|
DumpExpr(os, "init", x.init_);
|
|
return os;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(
|
|
llvm::raw_ostream &os, const AssocEntityDetails &x) {
|
|
os << *static_cast<const EntityDetails *>(&x);
|
|
if (auto assocRank{x.rank()}) {
|
|
os << " rank: " << *assocRank;
|
|
}
|
|
DumpExpr(os, "expr", x.expr());
|
|
return os;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(
|
|
llvm::raw_ostream &os, const ProcEntityDetails &x) {
|
|
if (auto *symbol{x.interface_.symbol()}) {
|
|
os << ' ' << symbol->name();
|
|
} else {
|
|
DumpType(os, x.interface_.type());
|
|
}
|
|
DumpOptional(os, "bindName", x.bindName());
|
|
DumpOptional(os, "passName", x.passName());
|
|
if (x.init()) {
|
|
if (const Symbol * target{*x.init()}) {
|
|
os << " => " << target->name();
|
|
} else {
|
|
os << " => NULL()";
|
|
}
|
|
}
|
|
return os;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(
|
|
llvm::raw_ostream &os, const DerivedTypeDetails &x) {
|
|
DumpBool(os, "sequence", x.sequence_);
|
|
DumpList(os, "components", x.componentNames_);
|
|
return os;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const GenericDetails &x) {
|
|
os << ' ' << x.kind().ToString();
|
|
DumpBool(os, "(specific)", x.specific() != nullptr);
|
|
DumpBool(os, "(derivedType)", x.derivedType() != nullptr);
|
|
if (const auto &uses{x.uses()}; !uses.empty()) {
|
|
os << " (uses:";
|
|
char sep{' '};
|
|
for (const Symbol &use : uses) {
|
|
const Symbol &ultimate{use.GetUltimate()};
|
|
os << sep << ultimate.name() << "->"
|
|
<< ultimate.owner().GetName().value();
|
|
sep = ',';
|
|
}
|
|
os << ')';
|
|
}
|
|
os << " procs:";
|
|
DumpSymbolVector(os, x.specificProcs());
|
|
return os;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Details &details) {
|
|
os << DetailsToString(details);
|
|
std::visit( //
|
|
common::visitors{
|
|
[&](const UnknownDetails &) {},
|
|
[&](const MainProgramDetails &) {},
|
|
[&](const ModuleDetails &x) {
|
|
if (x.isSubmodule()) {
|
|
os << " (";
|
|
if (x.ancestor()) {
|
|
auto ancestor{x.ancestor()->GetName().value()};
|
|
os << ancestor;
|
|
if (x.parent()) {
|
|
auto parent{x.parent()->GetName().value()};
|
|
if (ancestor != parent) {
|
|
os << ':' << parent;
|
|
}
|
|
}
|
|
}
|
|
os << ")";
|
|
}
|
|
},
|
|
[&](const SubprogramNameDetails &x) {
|
|
os << ' ' << EnumToString(x.kind());
|
|
},
|
|
[&](const UseDetails &x) {
|
|
os << " from " << x.symbol().name() << " in "
|
|
<< GetUsedModule(x).name();
|
|
},
|
|
[&](const UseErrorDetails &x) {
|
|
os << " uses:";
|
|
char sep{':'};
|
|
for (const auto &[location, module] : x.occurrences()) {
|
|
os << sep << " from " << module->GetName().value() << " at "
|
|
<< location;
|
|
sep = ',';
|
|
}
|
|
},
|
|
[](const HostAssocDetails &) {},
|
|
[&](const ProcBindingDetails &x) {
|
|
os << " => " << x.symbol().name();
|
|
DumpOptional(os, "passName", x.passName());
|
|
},
|
|
[&](const NamelistDetails &x) {
|
|
os << ':';
|
|
DumpSymbolVector(os, x.objects());
|
|
},
|
|
[&](const CommonBlockDetails &x) {
|
|
DumpOptional(os, "bindName", x.bindName());
|
|
if (x.alignment()) {
|
|
os << " alignment=" << x.alignment();
|
|
}
|
|
os << ':';
|
|
for (const auto &object : x.objects()) {
|
|
os << ' ' << object->name();
|
|
}
|
|
},
|
|
[&](const TypeParamDetails &x) {
|
|
DumpOptional(os, "type", x.type());
|
|
os << ' ' << common::EnumToString(x.attr());
|
|
DumpExpr(os, "init", x.init());
|
|
},
|
|
[&](const MiscDetails &x) {
|
|
os << ' ' << MiscDetails::EnumToString(x.kind());
|
|
},
|
|
[&](const auto &x) { os << x; },
|
|
},
|
|
details);
|
|
return os;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(llvm::raw_ostream &o, Symbol::Flag flag) {
|
|
return o << Symbol::EnumToString(flag);
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(
|
|
llvm::raw_ostream &o, const Symbol::Flags &flags) {
|
|
std::size_t n{flags.count()};
|
|
std::size_t seen{0};
|
|
for (std::size_t j{0}; seen < n; ++j) {
|
|
Symbol::Flag flag{static_cast<Symbol::Flag>(j)};
|
|
if (flags.test(flag)) {
|
|
if (seen++ > 0) {
|
|
o << ", ";
|
|
}
|
|
o << flag;
|
|
}
|
|
}
|
|
return o;
|
|
}
|
|
|
|
llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Symbol &symbol) {
|
|
os << symbol.name();
|
|
if (!symbol.attrs().empty()) {
|
|
os << ", " << symbol.attrs();
|
|
}
|
|
if (!symbol.flags().empty()) {
|
|
os << " (" << symbol.flags() << ')';
|
|
}
|
|
if (symbol.size_) {
|
|
os << " size=" << symbol.size_ << " offset=" << symbol.offset_;
|
|
}
|
|
os << ": " << symbol.details_;
|
|
return os;
|
|
}
|
|
|
|
// Output a unique name for a scope by qualifying it with the names of
|
|
// parent scopes. For scopes without corresponding symbols, use the kind
|
|
// with an index (e.g. Block1, Block2, etc.).
|
|
static void DumpUniqueName(llvm::raw_ostream &os, const Scope &scope) {
|
|
if (!scope.IsGlobal()) {
|
|
DumpUniqueName(os, scope.parent());
|
|
os << '/';
|
|
if (auto *scopeSymbol{scope.symbol()};
|
|
scopeSymbol && !scopeSymbol->name().empty()) {
|
|
os << scopeSymbol->name();
|
|
} else {
|
|
int index{1};
|
|
for (auto &child : scope.parent().children()) {
|
|
if (child == scope) {
|
|
break;
|
|
}
|
|
if (child.kind() == scope.kind()) {
|
|
++index;
|
|
}
|
|
}
|
|
os << Scope::EnumToString(scope.kind()) << index;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Dump a symbol for UnparseWithSymbols. This will be used for tests so the
|
|
// format should be reasonably stable.
|
|
llvm::raw_ostream &DumpForUnparse(
|
|
llvm::raw_ostream &os, const Symbol &symbol, bool isDef) {
|
|
DumpUniqueName(os, symbol.owner());
|
|
os << '/' << symbol.name();
|
|
if (isDef) {
|
|
if (!symbol.attrs().empty()) {
|
|
os << ' ' << symbol.attrs();
|
|
}
|
|
if (!symbol.flags().empty()) {
|
|
os << " (" << symbol.flags() << ')';
|
|
}
|
|
os << ' ' << symbol.GetDetailsName();
|
|
DumpType(os, symbol.GetType());
|
|
}
|
|
return os;
|
|
}
|
|
|
|
const DerivedTypeSpec *Symbol::GetParentTypeSpec(const Scope *scope) const {
|
|
if (const Symbol * parentComponent{GetParentComponent(scope)}) {
|
|
const auto &object{parentComponent->get<ObjectEntityDetails>()};
|
|
return &object.type()->derivedTypeSpec();
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
const Symbol *Symbol::GetParentComponent(const Scope *scope) const {
|
|
if (const auto *dtDetails{detailsIf<DerivedTypeDetails>()}) {
|
|
if (const Scope * localScope{scope ? scope : scope_}) {
|
|
return dtDetails->GetParentComponent(DEREF(localScope));
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void DerivedTypeDetails::add_component(const Symbol &symbol) {
|
|
if (symbol.test(Symbol::Flag::ParentComp)) {
|
|
CHECK(componentNames_.empty());
|
|
}
|
|
componentNames_.push_back(symbol.name());
|
|
}
|
|
|
|
const Symbol *DerivedTypeDetails::GetParentComponent(const Scope &scope) const {
|
|
if (auto extends{GetParentComponentName()}) {
|
|
if (auto iter{scope.find(*extends)}; iter != scope.cend()) {
|
|
if (const Symbol & symbol{*iter->second};
|
|
symbol.test(Symbol::Flag::ParentComp)) {
|
|
return &symbol;
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const Symbol *DerivedTypeDetails::GetFinalForRank(int rank) const {
|
|
for (const auto &pair : finals_) {
|
|
const Symbol &symbol{*pair.second};
|
|
if (const auto *details{symbol.detailsIf<SubprogramDetails>()}) {
|
|
if (details->dummyArgs().size() == 1) {
|
|
if (const Symbol * arg{details->dummyArgs().at(0)}) {
|
|
if (const auto *object{arg->detailsIf<ObjectEntityDetails>()}) {
|
|
if (rank == object->shape().Rank() || object->IsAssumedRank() ||
|
|
symbol.attrs().test(Attr::ELEMENTAL)) {
|
|
return &symbol;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void TypeParamDetails::set_type(const DeclTypeSpec &type) {
|
|
CHECK(!type_);
|
|
type_ = &type;
|
|
}
|
|
|
|
bool GenericKind::IsIntrinsicOperator() const {
|
|
return Is(OtherKind::Concat) || Has<common::LogicalOperator>() ||
|
|
Has<common::NumericOperator>() || Has<common::RelationalOperator>();
|
|
}
|
|
|
|
bool GenericKind::IsOperator() const {
|
|
return IsDefinedOperator() || IsIntrinsicOperator();
|
|
}
|
|
|
|
std::string GenericKind::ToString() const {
|
|
return std::visit(
|
|
common::visitors {
|
|
[](const OtherKind &x) { return EnumToString(x); },
|
|
[](const DefinedIo &x) { return EnumToString(x); },
|
|
#if !__clang__ && __GNUC__ == 7 && __GNUC_MINOR__ == 2
|
|
[](const common::NumericOperator &x) {
|
|
return common::EnumToString(x);
|
|
},
|
|
[](const common::LogicalOperator &x) {
|
|
return common::EnumToString(x);
|
|
},
|
|
[](const common::RelationalOperator &x) {
|
|
return common::EnumToString(x);
|
|
},
|
|
#else
|
|
[](const auto &x) { return common::EnumToString(x); },
|
|
#endif
|
|
},
|
|
u);
|
|
}
|
|
|
|
bool GenericKind::Is(GenericKind::OtherKind x) const {
|
|
const OtherKind *y{std::get_if<OtherKind>(&u)};
|
|
return y && *y == x;
|
|
}
|
|
|
|
} // namespace Fortran::semantics
|