Classes
class	ActualArgument
struct	Add
struct	AllTraverse
class	AnyTraverse
class	ArgumentAnalyzer
struct	ArgumentVerifier
struct	ArrayAndMask
class	ArrayConstantBoundChanger
class	ArrayConstructor
class	ArrayConstructor< SomeDerived >
class	ArrayConstructor< Type< TypeCategory::Character > >
class	ArrayConstructorContext
class	ArrayConstructorFolder
struct	ArrayConstructorValue
class	ArrayConstructorValues
class	ArrayRef
class	AsConstantHelper
class	Assignment
struct	BaseObject
struct	CallCharacteristics
class	CharacterUtils
struct	CheckConformanceFlags
class	CheckSpecificationExprHelper
class	CoarrayRef
struct	CollectCudaSymbolsHelper
struct	CollectRankOneBoundProvenanceSymbolsHelper
struct	CollectSymbolsHelper
class	CollectUsedSymbolValuesHelper
struct	ComplexComponent
struct	ComplexConstructor
class	ComplexPart
struct	ComplexPartExtractor
class	Component
struct	ComponentCompare
struct	Concat
class	ConditionalExpr
class	Constant
class	Constant< SomeDerived >
class	Constant< Type< TypeCategory::Character > >
class	ConstantBase
class	ConstantBounds
struct	ConstantObjectPointer
struct	Convert
class	CopyInOutExplicitInterface
class	CountAccumulator
struct	CudaMatchingDistance
struct	DataRef
class	DescriptorInquiry
class	Designator
class	DesignatorFolder
struct	Divide
class	DynamicType
struct	DynamicTypeWithLength
class	Expr
class	Expr< SomeCharacter >
class	Expr< SomeDerived >
class	Expr< SomeKind< CAT > >
class	Expr< SomeType >
class	Expr< Type< TypeCategory::Character > >
class	Expr< Type< TypeCategory::Complex > >
class	Expr< Type< TypeCategory::Integer > >
class	Expr< Type< TypeCategory::Logical > >
class	Expr< Type< TypeCategory::Real > >
class	Expr< Type< TypeCategory::Unsigned > >
class	ExpressionAnalyzer
class	ExpressionBase
struct	ExtractCoindexedObjectHelper
struct	ExtractFromExprDesignatorHelper
struct	Extremum
class	FindImpureCallHelper
class	Folder
class	FolderFactory
class	FoldingContext
class	FunctionRef
struct	FuncTypeAnalyzer
struct	FuncTypeAnalyzer< FuncPointer< HostTR, HostTA... > >
struct	GenericAssignmentWrapper
struct	GenericExprWrapper
class	GetConstantArrayBoundHelper
struct	GetLastSymbolHelper
class	GetLowerBoundHelper
class	GetShapeHelper
struct	GetSymbolVectorHelper
struct	HasConstantHelper
struct	HasStructureComponentHelper
struct	HasVectorSubscriptHelper
struct	HostRuntimeFunction
struct	HostRuntimeLibrary
struct	HostRuntimeLibrary< HostT, LibraryVersion::Libm >
struct	HostRuntimeLibrary< std::complex< HostT >, LibraryVersion::Libm >
class	ImpliedDo
struct	ImpliedDoIndex
class	InexactLiteralConversionFlagClearer
class	InitialImage
struct	IntrinsicInterface
struct	IntTypeVisitor
struct	IsActuallyConstantHelper
struct	IsAvailable
	Define pgmath description. More...
struct	IsAvailable< T, decltype((void) T::table, void())>
class	IsConstantExprHelper
class	IsContiguousHelper
struct	IsErrorExprHelper
class	IsInitialDataTargetHelper
struct	IsNullAllocatableHelper
struct	IsNullPointerHelper
struct	IsVariableHelper
class	LocationHelper
struct	LogicalOperation
class	MaxvalMinvalAccumulator
struct	Multiply
class	NamedEntity
struct	Negate
class	Norm2Accumulator
struct	Not
struct	NullPointer
class	NumericStorageSizeWarningVisitor
class	OffsetSymbol
class	Operation
class	OperationAccumulator
struct	OperatorSpelling
struct	Parentheses
struct	Parentheses< SomeDerived >
struct	Power
struct	ProcedureDesignator
class	ProcedureRef
class	ProductAccumulator
class	RankOneBoundElement
struct	RealToIntPower
class	Relational
class	Relational< SomeType >
struct	Rounding
struct	SameKindExprsHelper
class	ScalarConstantExpander
class	SelectedIntKindVisitor
class	SelectedLogicalKindVisitor
class	SelectedRealKindVisitor
struct	SetExprHelper
struct	SetLength
struct	SetTraverse
struct	SmallestUInt
struct	SmallestUInt< false, false, false, true >
struct	SmallestUInt< false, false, true, true >
struct	SmallestUInt< false, true, true, true >
struct	SmallestUInt< true, true, true, true >
struct	SomeKind
class	SomeKind< TypeCategory::Derived >
struct	SomeType
struct	SpecificCall
struct	SpecificIntrinsic
struct	SpecificIntrinsicFunctionInterface
struct	SpecificIntrinsicInterface
class	StaticDataObject
class	StmtFunctionChecker
class	StructureConstructor
struct	Subscript
class	Substring
struct	Subtract
class	SumAccumulator
class	SuspiciousRealLiteralFinder
class	Symbol
class	TargetCharacteristics
class	TrackInexactLiteralConversion
class	Traverse
class	Triplet
class	Type
class	Type< TypeCategory::Character >
class	Type< TypeCategory::Complex >
class	Type< TypeCategory::Integer >
class	Type< TypeCategory::Logical >
class	Type< TypeCategory::Real >
class	Type< TypeCategory::Unsigned >
struct	TypeBase
struct	TypeKind
struct	TypeKind< common::TypeCategory::Character, 1 >
struct	TypeKind< common::TypeCategory::Character, 2 >
struct	TypeKind< common::TypeCategory::Character, 4 >
struct	TypeKind< common::TypeCategory::Complex, KIND >
struct	TypeKind< common::TypeCategory::Integer, KIND >
struct	TypeKind< common::TypeCategory::Logical, KIND >
struct	TypeKind< common::TypeCategory::Real, KIND >
struct	TypeKind< common::TypeCategory::Unsigned, KIND >
struct	TypeOfHelper
class	TypeParamInquiry
struct	TypeVector
struct	TypeVectorStorage
struct	TypeVectorStorage<>
class	UnsafeToCopyVisitor
struct	ValueWithRealFlags
struct	VariableFinder

Typedefs
using	SymbolRef = common::Reference<const Symbol>
using	ActualArguments = std::vector<std::optional<ActualArgument>>
using	IntrinsicProcedure = std::string
using	Chevrons = std::vector<Expr<SomeType>>
template<int BITS>
using	HostUnsignedInt
using	ConstantSubscripts = std::vector<ConstantSubscript>
using	StructureConstructorValues
template<typename A>
using	ResultType = typename std::decay_t<A>::Result
using	CategoryExpression = common::MapTemplate<Expr, SomeCategory>
using	BOZLiteralConstant = typename LargestReal::Scalar::Word
using	TypelessExpression
using	HostRuntimeWrapper
using	ExtentType = SubscriptInteger
using	ExtentExpr = Expr<ExtentType>
using	MaybeExtentExpr = std::optional<ExtentExpr>
using	Shape = std::vector<MaybeExtentExpr>
template<typename A, int N = 2>
using	SameExprs = std::array<Expr<A>, N>
template<TypeCategory CAT, int N = 2>
using	SameKindExprs
using	ConvertRealOperandsResult
using	SubscriptInteger = Type<TypeCategory::Integer>
using	CInteger = Type<TypeCategory::Integer>
using	LargestInt = Type<TypeCategory::Integer>
using	LogicalResult = Type<TypeCategory::Logical>
using	LargestReal = Type<TypeCategory::Real>
using	Ascii = Type<TypeCategory::Character>
using	IndirectSubscriptIntegerExpr
template<TypeCategory CATEGORY>
using	CategoryTypes = std::tuple<Type<CATEGORY>>
using	IntegerTypes = CategoryTypes<TypeCategory::Integer>
using	RealTypes = CategoryTypes<TypeCategory::Real>
using	ComplexTypes = CategoryTypes<TypeCategory::Complex>
using	CharacterTypes = CategoryTypes<TypeCategory::Character>
using	LogicalTypes = CategoryTypes<TypeCategory::Logical>
using	UnsignedTypes = CategoryTypes<TypeCategory::Unsigned>
using	FloatingTypes = common::CombineTuples<RealTypes, ComplexTypes>
using	NumericTypes
using	RelationalTypes
using	AllIntrinsicTypes
using	LengthlessIntrinsicTypes
using	NumericCategoryTypes
using	AllIntrinsicCategoryTypes
using	SomeInteger = SomeKind<TypeCategory::Integer>
using	SomeReal = SomeKind<TypeCategory::Real>
using	SomeComplex = SomeKind<TypeCategory::Complex>
using	SomeCharacter = SomeKind<TypeCategory::Character>
using	SomeLogical = SomeKind<TypeCategory::Logical>
using	SomeUnsigned = SomeKind<TypeCategory::Unsigned>
using	SomeDerived = SomeKind<TypeCategory::Derived>
using	SomeCategory
using	AllTypes
template<typename T>
using	Scalar = typename std::decay_t<T>::Scalar
template<typename CONST>
using	TypeOf = typename TypeOfHelper<CONST>::type
using	IntegerKindTypes
using	UnsignedKindTypes
using	LogicalKindTypes
using	RealKindTypes
using	ComplexKindTypes
using	CharacterKindTypes
using	AllIntrinsicKindTypes
using	SymbolVector = std::vector<SymbolRef>
template<typename TR, typename... TArgs>
using	ScalarFunc = std::function<Scalar<TR>(const Scalar<TArgs> &...)>
template<typename TR, typename... TArgs>
using	ScalarFuncWithContext
template<typename TR, typename... TA>
using	FuncPointer = TR (*)(TA...)
using	HostRuntimeMap = common::StaticMultimapView<HostRuntimeFunction>
using	ArgumentVerifierFunc
	Structure to register intrinsic argument checks that must be performed.
using	CategorySet = common::EnumSet<TypeCategory, 8>
using	SetOfDerivedTypePairs
using	ActualArgumentRef = common::Reference<const ActualArgument>
using	ConstantSubscript
using	ConstantSubscript

Enumerations
enum class	WhichLocation { Findloc , Maxloc , Minloc }
enum class	Precedence { DefinedBinary , Or , And , Equivalence , Not , Relational , Additive , Negate , Multiplicative , Power , DefinedUnary , Top }
enum class	LibraryVersion { Libm , LibmExtensions , PgmathFast , PgmathRelaxed , PgmathPrecise }

Functions
template<typename A>
bool	IsConstantExpr (const A &, const FoldingContext *=nullptr)
template bool	IsConstantExpr (const Expr< SomeType > &, const FoldingContext *)
template bool	IsConstantExpr (const Expr< SomeInteger > &, const FoldingContext *)
template bool	IsConstantExpr (const Expr< SubscriptInteger > &, const FoldingContext *)
template bool	IsConstantExpr (const StructureConstructor &, const FoldingContext *)
template<typename A>
bool	IsScopeInvariantExpr (const A &, const FoldingContext *=nullptr)
template bool	IsScopeInvariantExpr (const Expr< SomeType > &, const FoldingContext *)
template bool	IsScopeInvariantExpr (const Expr< SomeInteger > &, const FoldingContext *)
template bool	IsScopeInvariantExpr (const Expr< SubscriptInteger > &, const FoldingContext *)
template<typename A>
bool	IsActuallyConstant (const A &)
template bool	IsActuallyConstant (const Expr< SomeType > &)
template bool	IsActuallyConstant (const Expr< SomeInteger > &)
template bool	IsActuallyConstant (const Expr< SubscriptInteger > &)
template bool	IsActuallyConstant (const std::optional< Expr< SubscriptInteger > > &)
bool	IsInitialDataTarget (const Expr< SomeType > &, parser::ContextualMessages =nullptr, const FoldingContext =nullptr)
bool	IsInitialProcedureTarget (const Symbol &)
bool	IsInitialProcedureTarget (const ProcedureDesignator &)
bool	IsInitialProcedureTarget (const Expr< SomeType > &)
void	CheckRealWidening (const Expr< SomeType > &, const DynamicType &toType, FoldingContext &)
void	CheckRealWidening (const Expr< SomeType > &, const std::optional< DynamicType > &, FoldingContext &)
std::optional< Expr< SomeType > >	NonPointerInitializationExpr (const Symbol &, Expr< SomeType > &&, FoldingContext &, const semantics::Scope *instantiation=nullptr)
template<typename A>
void	CheckSpecificationExpr (const A &, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const Expr< SomeType > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const Expr< SomeInteger > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const Expr< SubscriptInteger > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const std::optional< Expr< SomeType > > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const std::optional< Expr< SomeInteger > > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const std::optional< Expr< SubscriptInteger > > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template<typename A>
std::optional< bool >	IsContiguous (const A &, FoldingContext &, bool namedConstantSectionsAreContiguous=true, bool firstDimensionStride1=false)
template std::optional< bool >	IsContiguous (const Expr< SomeType > &, FoldingContext &, bool namedConstantSectionsAreContiguous, bool firstDimensionStride1)
template std::optional< bool >	IsContiguous (const ActualArgument &, FoldingContext &, bool namedConstantSectionsAreContiguous, bool firstDimensionStride1)
template std::optional< bool >	IsContiguous (const ArrayRef &, FoldingContext &, bool namedConstantSectionsAreContiguous, bool firstDimensionStride1)
template std::optional< bool >	IsContiguous (const Substring &, FoldingContext &, bool namedConstantSectionsAreContiguous, bool firstDimensionStride1)
template std::optional< bool >	IsContiguous (const Component &, FoldingContext &, bool namedConstantSectionsAreContiguous, bool firstDimensionStride1)
template std::optional< bool >	IsContiguous (const ComplexPart &, FoldingContext &, bool namedConstantSectionsAreContiguous, bool firstDimensionStride1)
template std::optional< bool >	IsContiguous (const CoarrayRef &, FoldingContext &, bool namedConstantSectionsAreContiguous, bool firstDimensionStride1)
template std::optional< bool >	IsContiguous (const Symbol &, FoldingContext &, bool namedConstantSectionsAreContiguous, bool firstDimensionStride1)
template<typename A>
bool	IsSimplyContiguous (const A &x, FoldingContext &context, bool namedConstantSectionsAreContiguous=true)
template<typename A>
bool	IsErrorExpr (const A &)
template bool	IsErrorExpr (const Expr< SomeType > &)
std::optional< parser::Message >	CheckStatementFunction (const Symbol &, const Expr< SomeType > &, FoldingContext &)
bool	IsNamedConstantDesignator (const Expr< SomeType > &)
bool	AnyNamedConstantActualArguments (const ActualArguments &)
void	FoldNamedConstantActualArguments (FoldingContext &, ActualArguments &)
std::optional< bool >	ActualArgNeedsCopy (const ActualArgument , const characteristics::DummyArgument , FoldingContext &, bool forCopyOut)
semantics::UnorderedSymbolSet	CollectUsedSymbolValues (semantics::SemanticsContext &, const Expr< SomeType > &, bool isDefinition=false)
semantics::UnorderedSymbolSet	CollectUsedSymbolValues (semantics::SemanticsContext &, const ProcedureRef &)
semantics::UnorderedSymbolSet	CollectUsedSymbolValues (semantics::SemanticsContext &, const Assignment &)
Ordering	Compare (const value::CharacterValue &x, const value::CharacterValue &y)
int	GetRank (const ConstantSubscripts &s)
std::optional< uint64_t >	TotalElementCount (const ConstantSubscripts &shape)
std::optional< std::vector< int > >	ValidateDimensionOrder (int rank, const std::vector< int > &order)
bool	HasNegativeExtent (const ConstantSubscripts &)
Constant< SubscriptInteger >	MakeSubscriptIntConstant (int64_t v)
Constant< CInteger >	MakeCIntegerConstant (int32_t v)
Constant< LogicalResult >	MakeLogicalResultConstant (bool v)
template<typename T, typename CharT, typename = std::enable_if_t<std::is_same_v<T, Type<TypeCategory::Character>>>>
Constant< T >	MakeConstant (int kind, const std::basic_string< CharT > &v)
template<typename T, typename CharT, typename = std::enable_if_t<std::is_same_v<T, Type<TypeCategory::Character>>>>
Constant< T >	MakeConstant (int kind, std::basic_string< CharT > &&v)
template<typename T, typename = std::enable_if_t<std::is_same_v<T, Type<TypeCategory::Integer>>>>
Constant< T >	MakeConstant (int kind, int64_t v)
template<typename T>
Expr< T >	MakeConstantExpr (int kind, const Scalar< T > &v)
template<typename T>
Expr< T >	MakeConstantExpr (int kind, Scalar< T > &&v)
template<typename T>
Expr< T >	MakeConstantExpr (int kind, const Constant< T > &c)
template<typename T>
Expr< T >	MakeConstantExpr (int kind, Constant< T > &&c)
template<typename T, typename = std::enable_if_t<std::is_same_v<T, Type<TypeCategory::Character>>>>
Expr< T >	MakeConstantExpr (int kind, const std::string &v)
template<typename T, typename = std::enable_if_t<std::is_same_v<T, Type<TypeCategory::Integer>>>>
Expr< T >	MakeConstantExpr (int kind, int64_t v)
template<typename T, typename = std::enable_if_t<std::is_same_v<T, Type<TypeCategory::Unsigned>>>>
Expr< T >	MakeConstantExpr (int kind, uint64_t v)
template<typename T, typename = std::enable_if_t<std::is_same_v<T, Type<TypeCategory::Logical>>>>
Expr< T >	MakeConstantExpr (int kind, bool v)
template<typename T>
Expr< T >	MakeZeroExpr (int kind)
Expr< SubscriptInteger >	MakeSubscriptIntExpr (int64_t v)
Expr< SubscriptInteger >	MakeSubscriptIntExpr (const Scalar< SubscriptInteger > &v)
Expr< SubscriptInteger >	MakeSubscriptIntExpr (Scalar< SubscriptInteger > &&v)
Expr< CInteger >	MakeCIntegerExpr (int32_t v)
Expr< LogicalResult >	MakeLogicalResultExpr (bool v)
Expr< Ascii >	MakeAsciiExpr (const std::string &v)
Expr< Ascii >	MakeAsciiExpr (std::string &&v)
std::optional< Expr< SomeType > >	OffsetToDesignator (FoldingContext &, const Symbol &, ConstantSubscript offset, std::size_t)
std::optional< Expr< SomeType > >	OffsetToDesignator (FoldingContext &, const OffsetSymbol &)
template<typename T>
Expr< T >	Fold (FoldingContext &context, Expr< T > &&expr)
characteristics::TypeAndShape	Fold (FoldingContext &, characteristics::TypeAndShape &&)
template<typename A>
std::optional< A >	Fold (FoldingContext &context, std::optional< A > &&x)
template<typename T, typename EXPR>
auto	UnwrapConstantValue (EXPR &expr) -> common::Constify< Constant< T >, EXPR > *
template<typename T, typename EXPR>
auto	UnwrapConstantValue (int kind, EXPR &expr) -> common::Constify< Constant< T >, EXPR > *
template<typename T, typename EXPR>
constexpr auto	GetScalarConstantValue (const EXPR &expr) -> std::optional< Scalar< T > >
template<typename T, typename EXPR>
constexpr auto	GetScalarConstantValue (int kind, const EXPR &expr) -> std::optional< Scalar< T > >
std::optional< std::int64_t >	ToInt64 (const Expr< Type< TypeCategory::Integer > > &expr)
std::optional< std::int64_t >	ToInt64 (const Expr< Type< TypeCategory::Unsigned > > &expr)
std::optional< std::int64_t >	ToInt64 (const Expr< SomeInteger > &)
std::optional< std::int64_t >	ToInt64 (const Expr< SomeUnsigned > &)
std::optional< std::int64_t >	ToInt64 (const Expr< SomeType > &)
std::optional< std::int64_t >	ToInt64 (const ActualArgument &)
std::optional< bool >	ToLogical (const Expr< LogicalResult > &expr)
template<typename A>
std::optional< std::int64_t >	ToInt64 (const std::optional< A > &x)
template<typename A>
std::optional< std::int64_t >	ToInt64 (A *p)
void	FoldConditionalArg (FoldingContext &context, std::optional< ActualArgument > &arg)
template<typename A>
auto	operator<< (llvm::raw_ostream &o, const A &x) -> decltype(x.AsFortran(o))
template<typename A, bool COPYABLE>
auto	operator<< (llvm::raw_ostream &o, const Fortran::common::Indirection< A, COPYABLE > &x) -> decltype(o<< x.value())
template<typename A>
auto	operator<< (llvm::raw_ostream &o, const std::optional< A > &x) -> decltype(o<< *x)
template<typename SCALAR>
void	StoreSerialValues (char dst, llvm::ArrayRef< SCALAR > values, size_t elementSize, bool changed=nullptr)
template<typename SCALAR>
void	LoadSerialValues (int kind, const char *src, llvm::MutableArrayRef< SCALAR > values, size_t stride)
std::optional< HostRuntimeWrapper >	GetHostRuntimeWrapper (const std::string &name, DynamicType resultType, const std::vector< DynamicType > &argTypes)
bool	CheckAndRearrangeArguments (ActualArguments &, parser::ContextualMessages &, const char *const dummyKeywords[], std::size_t trailingOptionals=0)
	ENUM_CLASS (IntrinsicClass, atomicSubroutine, collectiveSubroutine, elementalFunction, elementalSubroutine, inquiryFunction, pureSubroutine, simpleSubroutine, simpleElementalSubroutine, impureFunction, impureSubroutine, transformationalFunction, noClass) class IntrinsicProcTable
bool	AcceptsIntentOutAllocatableCoarray (const std::string &)
Constant< ExtentType >	MakeExtentConstant (int64_t v)
Constant< ExtentType >	MakeExtentConstant (const value::IntegerValue &v)
ExtentExpr	MakeExtentExpr (int64_t v)
ExtentExpr	MakeExtentExpr (const value::IntegerValue &v)
bool	IsImpliedShape (const Symbol &)
bool	IsExplicitShape (const Symbol &)
std::optional< ExtentExpr >	AsExtentArrayExpr (const Shape &)
std::optional< Constant< ExtentType > >	AsConstantShape (FoldingContext &, const Shape &)
Constant< ExtentType >	AsConstantShape (const ConstantSubscripts &)
ConstantSubscripts	AsConstantExtents (const Constant< ExtentType > &)
std::optional< ConstantSubscripts >	AsConstantExtents (FoldingContext &, const Shape &)
std::optional< ConstantSubscripts >	AsConstantExtents (FoldingContext &foldingContext, const std::optional< Shape > &maybeShape)
Shape	AsShape (const ConstantSubscripts &)
std::optional< Shape >	AsShape (const std::optional< ConstantSubscripts > &)
int	GetRank (const Shape &s)
Shape	Fold (FoldingContext &, Shape &&)
std::optional< Shape >	Fold (FoldingContext &, std::optional< Shape > &&)
template<typename A>
std::optional< Shape >	GetShape (FoldingContext &, const A &, bool invariantOnly=true)
template<typename A>
std::optional< Shape >	GetShape (FoldingContext *, const A &, bool invariantOnly=true)
template<typename A>
std::optional< Shape >	GetShape (const A &, bool invariantOnly=true)
ExtentExpr	GetRawLowerBound (const NamedEntity &, int dimension, bool invariantOnly=true)
ExtentExpr	GetRawLowerBound (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetLBOUND (const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetLBOUND (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetRawUpperBound (const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetRawUpperBound (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetUBOUND (const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetUBOUND (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	ComputeUpperBound (ExtentExpr &&lower, MaybeExtentExpr &&extent)
MaybeExtentExpr	ComputeUpperBound (FoldingContext &, ExtentExpr &&lower, MaybeExtentExpr &&extent)
Shape	GetRawLowerBounds (const NamedEntity &, bool invariantOnly=true)
Shape	GetRawLowerBounds (FoldingContext &, const NamedEntity &, bool invariantOnly=true)
Shape	GetLBOUNDs (const NamedEntity &, bool invariantOnly=true)
Shape	GetLBOUNDs (FoldingContext &, const NamedEntity &, bool invariantOnly=true)
Shape	GetUBOUNDs (const NamedEntity &, bool invariantOnly=true)
Shape	GetUBOUNDs (FoldingContext &, const NamedEntity &, bool invariantOnly=true)
MaybeExtentExpr	GetExtent (const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetExtent (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetExtent (const Subscript &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetExtent (FoldingContext &, const Subscript &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetLCOBOUND (const Symbol &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetUCOBOUND (const Symbol &, int dimension, bool invariantOnly=true)
Shape	GetLCOBOUNDs (const Symbol &, bool invariantOnly=true)
Shape	GetUCOBOUNDs (const Symbol &, bool invariantOnly=true)
ExtentExpr	CountTrips (ExtentExpr &&lower, ExtentExpr &&upper, ExtentExpr &&stride)
ExtentExpr	CountTrips (const ExtentExpr &lower, const ExtentExpr &upper, const ExtentExpr &stride)
MaybeExtentExpr	CountTrips (MaybeExtentExpr &&lower, MaybeExtentExpr &&upper, MaybeExtentExpr &&stride)
MaybeExtentExpr	GetSize (Shape &&)
ConstantSubscript	GetSize (const ConstantSubscripts &)
MaybeExtentExpr	GetSize (const std::optional< Shape > &maybeShape)
bool	ContainsAnyImpliedDoIndex (const ExtentExpr &)
template<typename T>
bool	ContainsUntaggedRankOneBoundElement (const Expr< T > &)
template bool	ContainsUntaggedRankOneBoundElement (const Expr< SomeType > &)
template bool	ContainsUntaggedRankOneBoundElement (const Expr< SomeInteger > &)
template bool	ContainsUntaggedRankOneBoundElement (const Expr< SubscriptInteger > &)
template<typename A>
std::optional< Constant< ExtentType > >	GetConstantShape (FoldingContext &context, const A &x)
template<typename A>
std::optional< ConstantSubscripts >	GetConstantExtents (FoldingContext &context, const A &x)
template<typename A>
std::optional< Shape >	GetContextFreeShape (FoldingContext &context, const A &x)
std::optional< bool >	CheckConformance (parser::ContextualMessages &, const Shape &left, const Shape &right, CheckConformanceFlags::Flags flags=CheckConformanceFlags::None, const char leftIs="left operand", const char rightIs="right operand")
bool	IncrementSubscripts (ConstantSubscripts &, const ConstantSubscripts &extents)
	ENUM_CLASS (IeeeFeature, Denormal, Divide, Flags, Halting, Inf, Io, NaN, Rounding, Sqrt, Standard, Subnormal, UnderflowControl) using IeeeFeatures
template<typename A>
bool	IsVariable (const A &x)
int	GetCorank (const ActualArgument &)
template<typename A>
int	GetCorank (const A &)
template<typename T>
int	GetCorank (const Designator< T > &designator)
template<typename T>
int	GetCorank (const Expr< T > &expr)
template<typename A>
int	GetCorank (const std::optional< A > &x)
template<typename A>
int	GetCorank (const A *x)
template<typename A>
bool	IsCoarray (const A &x)
template<typename A>
common::IfNoLvalue< Expr< ResultType< A > >, A >	AsExpr (A &&x)
template<typename T, typename U = typename Relational<T>::Result>
Expr< U >	AsExpr (Relational< T > &&x)
template<typename T>
Expr< T >	AsExpr (Expr< T > &&x)
template<TypeCategory CATEGORY>
Expr< SomeKind< CATEGORY > >	AsCategoryExpr (Expr< SomeKind< CATEGORY > > &&x)
template<typename A>
common::IfNoLvalue< Expr< SomeType >, A >	AsGenericExpr (A &&x)
Expr< SomeType >	AsGenericExpr (Expr< SomeType > &&x)
std::optional< Expr< SomeType > >	AsGenericExpr (DataRef &&)
std::optional< Expr< SomeType > >	AsGenericExpr (const Symbol &)
template<typename A>
std::optional< Expr< SomeType > >	AsGenericExpr (std::optional< A > &&x)
template<typename A>
common::IfNoLvalue< Expr< SomeKind< ResultType< A >::category > >, A >	AsCategoryExpr (A &&x)
Expr< SomeType >	Parenthesize (Expr< SomeType > &&)
template<typename A>
constexpr bool	IsNumericCategoryExpr ()
template<typename A, typename B>
auto	UnwrapExpr (B &x) -> common::Constify< A, B > *
template<typename A, typename B>
const A *	UnwrapExpr (const std::optional< B > &x)
template<typename A, typename B>
A *	UnwrapExpr (std::optional< B > &x)
template<typename A, typename B>
const A *	UnwrapExpr (const B *x)
template<typename A, typename B>
A *	UnwrapExpr (B *x)
template<typename A, typename B>
auto	UnwrapExpr (int kind, B &x)
template<typename A, typename B>
auto	UnwrapConvertedExpr (B &x) -> common::Constify< A, B > *
template<typename A>
const ProcedureRef *	UnwrapProcedureRef (const A &)
const ProcedureRef *	UnwrapProcedureRef (const ProcedureRef &proc)
template<typename T>
const ProcedureRef *	UnwrapProcedureRef (const FunctionRef< T > &func)
template<typename T>
const ProcedureRef *	UnwrapProcedureRef (const Expr< T > &expr)
template<typename A>
const Symbol *	ExtractBareLenParameter (const A &expr)
template<typename A>
common::IfNoLvalue< std::optional< DataRef >, A >	ExtractDataRef (const A &x, bool intoSubstring, bool intoComplexPart)
std::optional< DataRef >	ExtractSubstringBase (const Substring &)
std::optional< DataRef >	ExtractDataRef (const Substring &x, bool intoSubstring=false, bool intoComplexPart=false)
std::optional< DataRef >	ExtractDataRef (const ComplexPart &x, bool intoSubstring=false, bool intoComplexPart=false)
template<typename T>
std::optional< DataRef >	ExtractDataRef (const Designator< T > &d, bool intoSubstring=false, bool intoComplexPart=false)
template<typename T>
std::optional< DataRef >	ExtractDataRef (const Expr< T > &expr, bool intoSubstring=false, bool intoComplexPart=false)
template<typename A>
std::optional< DataRef >	ExtractDataRef (const std::optional< A > &x, bool intoSubstring=false, bool intoComplexPart=false)
template<typename A>
std::optional< DataRef >	ExtractDataRef (A *p, bool intoSubstring=false, bool intoComplexPart=false)
std::optional< DataRef >	ExtractDataRef (const ActualArgument &, bool intoSubstring=false, bool intoComplexPart=false)
template<typename T>
const Symbol *	IsArrayElement (const Expr< T > &expr, bool intoSubstring=true, bool skipComponents=false)
template<typename T>
bool	isStructureComponent (const Fortran::evaluate::Expr< T > &expr)
template<typename A>
std::optional< NamedEntity >	ExtractNamedEntity (const A &x)
template<typename A>
std::optional< CoarrayRef >	ExtractCoarrayRef (const A &x)
template<typename A>
std::optional< Substring >	ExtractSubstring (const A &x)
template<typename A>
std::optional< ComplexPart >	ExtractComplexPart (const A &x)
const Symbol *	UnwrapWholeSymbolDataRef (const DataRef &)
const Symbol *	UnwrapWholeSymbolDataRef (const std::optional< DataRef > &)
template<typename A>
const Symbol *	UnwrapWholeSymbolDataRef (const A &x)
const Symbol *	UnwrapWholeSymbolOrComponentDataRef (const DataRef &)
const Symbol *	UnwrapWholeSymbolOrComponentDataRef (const std::optional< DataRef > &)
template<typename A>
const Symbol *	UnwrapWholeSymbolOrComponentDataRef (const A &x)
const Symbol *	UnwrapWholeSymbolOrComponentOrCoarrayRef (const DataRef &)
const Symbol *	UnwrapWholeSymbolOrComponentOrCoarrayRef (const std::optional< DataRef > &)
template<typename A>
const Symbol *	UnwrapWholeSymbolOrComponentOrCoarrayRef (const A &x)
template<typename A>
const Symbol *	GetFirstSymbol (const A &x)
const Symbol *	GetLastPointerSymbol (const evaluate::DataRef &)
template<typename TO, TypeCategory FROMCAT>
Expr< TO >	ConvertToType (int toKind, Expr< SomeKind< FROMCAT > > &&x)
template<typename TO, TypeCategory FROMCAT>
Expr< TO >	ConvertToType (int toKind, Expr< Type< FROMCAT > > &&x)
template<typename TO>
Expr< TO >	ConvertToType (int toKind, BOZLiteralConstant &&x)
template<typename T>
bool	IsBOZLiteral (const Expr< T > &expr)
std::optional< Expr< SomeType > >	ConvertToType (const DynamicType &, Expr< SomeType > &&)
std::optional< Expr< SomeType > >	ConvertToType (const DynamicType &, std::optional< Expr< SomeType > > &&)
std::optional< Expr< SomeType > >	ConvertToType (const Symbol &, Expr< SomeType > &&)
std::optional< Expr< SomeType > >	ConvertToType (const Symbol &, std::optional< Expr< SomeType > > &&)
template<TypeCategory TC, typename FROM>
common::IfNoLvalue< Expr< Type< TC > >, FROM >	ConvertTo (const Expr< Type< TC > > &to, FROM &&x)
template<TypeCategory TC, typename FROM>
common::IfNoLvalue< Expr< SomeKind< TC > >, FROM >	ConvertTo (const Expr< SomeKind< TC > > &to, FROM &&from)
template<typename FROM>
common::IfNoLvalue< Expr< SomeType >, FROM >	ConvertTo (const Expr< SomeType > &to, FROM &&from)
template<TypeCategory TOCAT, typename VALUE>
common::IfNoLvalue< Expr< SomeKind< TOCAT > >, VALUE >	ConvertToKind (int kind, VALUE &&x)
template<TypeCategory CAT>
SameKindExprs< CAT, 2 >	AsSameKindExprs (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
ConvertRealOperandsResult	ConvertRealOperands (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
std::optional< Expr< SomeComplex > >	ConstructComplex (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
std::optional< Expr< SomeComplex > >	ConstructComplex (parser::ContextualMessages &, std::optional< Expr< SomeType > > &&, std::optional< Expr< SomeType > > &&, int defaultRealKind)
template<typename A>
Expr< TypeOf< A > >	ScalarConstantToExpr (const A &x)
template<template< typename > class OPR, typename SPECIFIC>
Expr< SPECIFIC >	Combine (Expr< SPECIFIC > &&x, Expr< SPECIFIC > &&y)
template<template< typename > class OPR, TypeCategory CAT>
Expr< SomeKind< CAT > >	PromoteAndCombine (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<template< typename > class OPR>
std::optional< Expr< SomeType > >	NumericOperation (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Power > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Multiply > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Divide > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Add > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Subtract > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
std::optional< Expr< SomeType > >	Negation (parser::ContextualMessages &, Expr< SomeType > &&)
std::optional< Expr< LogicalResult > >	Relate (parser::ContextualMessages &, RelationalOperator, Expr< SomeType > &&, Expr< SomeType > &&)
template<typename T>
Expr< LogicalResult >	PackageRelation (RelationalOperator opr, Expr< T > &&x, Expr< T > &&y)
Expr< Type< TypeCategory::Logical > >	LogicalNegation (Expr< Type< TypeCategory::Logical > > &&x)
Expr< SomeLogical >	LogicalNegation (Expr< SomeLogical > &&)
Expr< Type< TypeCategory::Logical > >	BinaryLogicalOperation (LogicalOperator opr, Expr< Type< TypeCategory::Logical > > &&x, Expr< Type< TypeCategory::Logical > > &&y)
Expr< SomeLogical >	BinaryLogicalOperation (LogicalOperator, Expr< SomeLogical > &&, Expr< SomeLogical > &&)
template<TypeCategory C>
Expr< Type< C > >	operator- (Expr< Type< C > > &&x)
template<TypeCategory C>
Expr< Type< C > >	operator+ (Expr< Type< C > > &&x, Expr< Type< C > > &&y)
template<TypeCategory C>
Expr< Type< C > >	operator- (Expr< Type< C > > &&x, Expr< Type< C > > &&y)
template<TypeCategory C>
Expr< Type< C > >	operator* (Expr< Type< C > > &&x, Expr< Type< C > > &&y)
template<TypeCategory C>
Expr< Type< C > >	operator/ (Expr< Type< C > > &&x, Expr< Type< C > > &&y)
template<TypeCategory C>
Expr< SomeKind< C > >	operator- (Expr< SomeKind< C > > &&x)
template<TypeCategory CAT>
Expr< SomeKind< CAT > >	operator+ (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory CAT>
Expr< SomeKind< CAT > >	operator- (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory CAT>
Expr< SomeKind< CAT > >	operator* (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory CAT>
Expr< SomeKind< CAT > >	operator/ (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory CATEGORY, template< typename > typename WRAPPER, typename WRAPPED>
common::IfNoLvalue< std::optional< Expr< SomeType > >, WRAPPED >	WrapperHelper (int kind, WRAPPED &&x)
template<template< typename > typename WRAPPER, typename WRAPPED>
common::IfNoLvalue< std::optional< Expr< SomeType > >, WRAPPED >	TypedWrapper (const DynamicType &dyType, WRAPPED &&x)
template<typename A>
const Symbol *	GetLastSymbol (const A &x)
template<typename A>
semantics::Attrs	GetAttrs (const A &x)
template<>
semantics::Attrs	GetAttrs< Expr< SomeType > > (const Expr< SomeType > &x)
template<typename A>
semantics::Attrs	GetAttrs (const std::optional< A > &x)
template<typename A>
std::optional< BaseObject >	GetBaseObject (const A &)
template<typename T>
std::optional< BaseObject >	GetBaseObject (const Designator< T > &x)
template<typename T>
std::optional< BaseObject >	GetBaseObject (const Expr< T > &x)
template<typename A>
std::optional< BaseObject >	GetBaseObject (const std::optional< A > &x)
bool	IsAllocatableOrPointerObject (const Expr< SomeType > &)
bool	IsAllocatableDesignator (const Expr< SomeType > &)
bool	IsProcedureDesignator (const Expr< SomeType > &)
bool	IsFunctionDesignator (const Expr< SomeType > &)
bool	IsPointer (const Expr< SomeType > &)
bool	IsProcedurePointer (const Expr< SomeType > &)
bool	IsProcedure (const Expr< SomeType > &)
bool	IsProcedurePointerTarget (const Expr< SomeType > &)
bool	IsBareNullPointer (const Expr< SomeType > *)
bool	IsNullObjectPointer (const Expr< SomeType > *)
bool	IsNullProcedurePointer (const Expr< SomeType > *)
bool	IsNullPointer (const Expr< SomeType > *)
bool	IsNullAllocatable (const Expr< SomeType > *)
bool	IsNullPointerOrAllocatable (const Expr< SomeType > *)
bool	IsObjectPointer (const Expr< SomeType > &)
bool	MayBePassedAsAbsentOptional (const Expr< SomeType > &)
template<typename A>
SymbolVector	GetSymbolVector (const A &x)
const Expr< SomeType > *	GetVariableSelector (const Symbol &)
const Symbol *	GetLastTarget (const SymbolVector &)
template<typename A>
semantics::UnorderedSymbolSet	CollectSymbols (const A &)
template semantics::UnorderedSymbolSet	CollectSymbols (const Expr< SomeType > &)
template semantics::UnorderedSymbolSet	CollectSymbols (const Expr< SomeInteger > &)
template semantics::UnorderedSymbolSet	CollectSymbols (const Expr< SubscriptInteger > &)
template semantics::UnorderedSymbolSet	CollectSymbols (const ProcedureDesignator &)
template semantics::UnorderedSymbolSet	CollectSymbols (const Assignment &)
template<typename A>
semantics::UnorderedSymbolSet	CollectRankOneBoundProvenanceSymbols (const A &)
template semantics::UnorderedSymbolSet	CollectRankOneBoundProvenanceSymbols (const Expr< SomeType > &)
template semantics::UnorderedSymbolSet	CollectRankOneBoundProvenanceSymbols (const Expr< SomeInteger > &)
template semantics::UnorderedSymbolSet	CollectRankOneBoundProvenanceSymbols (const Expr< SubscriptInteger > &)
template<typename A>
semantics::UnorderedSymbolSet	CollectCudaSymbols (const A &)
template semantics::UnorderedSymbolSet	CollectCudaSymbols (const Expr< SomeType > &)
template semantics::UnorderedSymbolSet	CollectCudaSymbols (const Expr< SomeInteger > &)
template semantics::UnorderedSymbolSet	CollectCudaSymbols (const Expr< SubscriptInteger > &)
bool	HasVectorSubscript (const Expr< SomeType > &)
bool	HasVectorSubscript (const ActualArgument &)
bool	IsArraySection (const Expr< SomeType > &expr)
bool	HasConstant (const Expr< SomeType > &)
bool	HasStructureComponent (const Expr< SomeType > &expr)
bool	HasProcedureRef (const Expr< SomeType > &expr)
bool	HasVolatileOrAsynchronousSymbol (const Expr< SomeType > &expr)
bool	CanBuildSplitSumExpressionTree (FoldingContext &, const Expr< SomeType > &lhs, const Expr< SomeType > &rhs)
std::optional< Expr< SomeType > >	TryBuildSplitSumExpressionTrees (const Expr< SomeType > &expr)
parser::Message *	AttachDeclaration (parser::Message &, const Symbol &)
parser::Message *	AttachDeclaration (parser::Message *, const Symbol &)
template<typename MESSAGES, typename... A>
parser::Message *	SayWithDeclaration (MESSAGES &messages, const Symbol &symbol, A &&...x)
template<typename... A>
parser::Message *	WarnWithDeclaration (FoldingContext context, const Symbol &symbol, common::LanguageFeature feature, A &&...x)
template<typename... A>
parser::Message *	WarnWithDeclaration (FoldingContext &context, const Symbol &symbol, common::UsageWarning warning, A &&...x)
std::optional< std::string >	FindImpureCall (FoldingContext &, const Expr< SomeType > &)
std::optional< std::string >	FindImpureCall (FoldingContext &, const ProcedureRef &)
template<typename A>
bool	IsSafelyCopyable (const A &x, bool admitPureCall=false)
template<typename T>
bool	IsExpandableScalar (const Expr< T > &expr, FoldingContext &context, const Shape &shape, bool admitPureCall=false)
std::optional< parser::MessageFixedText >	CheckProcCompatibility (bool isCall, const std::optional< characteristics::Procedure > &lhsProcedure, const characteristics::Procedure rhsProcedure, const SpecificIntrinsic specificIntrinsic, std::string &whyNotCompatible, std::optional< std::string > &warning, bool ignoreImplicitVsExplicit)
template<typename T>
Constant< T >	PackageConstant (int kind, std::vector< Scalar< T > > &&elements, const Constant< T > &reference, const ConstantSubscripts &shape)
std::optional< Expr< SomeType > >	DataConstantConversionExtension (FoldingContext &, const DynamicType &, const Expr< SomeType > &)
std::optional< Expr< SomeType > >	HollerithToBOZ (FoldingContext &, const Expr< SomeType > &, const DynamicType &)
template<typename T>
std::optional< bool >	AreEquivalentInInterface (const Expr< T > &, const Expr< T > &)
template std::optional< bool >	AreEquivalentInInterface< SubscriptInteger > (const Expr< SubscriptInteger > &, const Expr< SubscriptInteger > &)
template std::optional< bool >	AreEquivalentInInterface< SomeInteger > (const Expr< SomeInteger > &, const Expr< SomeInteger > &)
bool	CheckForCoindexedObject (parser::ContextualMessages &, const std::optional< ActualArgument > &, const std::string &procName, const std::string &argName)
std::vector< SymbolVector >	GetSymbolVectors (const Expr< SomeType > &expr)
bool	IsCUDADeviceSymbol (const Symbol &sym)
bool	IsCUDADeviceOnlySymbol (const Symbol &sym)
bool	IsCUDADataAttrSymbol (const Symbol &sym, common::CUDADataAttr attr)
bool	IsCUDAManagedOrUnifiedSymbol (const Symbol &sym)
bool	IsCUDAManagedSymbol (const Symbol &sym)
bool	IsCUDAUnifiedSymbol (const Symbol &sym)
bool	HasCUDADataAttr (const Symbol &sym)
semantics::UnorderedSymbolSet	ExpandCudaAssociations (semantics::UnorderedSymbolSet &&symbols)
template<typename A>
semantics::UnorderedSymbolSet	CollectEffectiveCudaSymbols (const A &expr)
int	CountCUDAManagedSymbols (const semantics::UnorderedSymbolSet &symbols)
int	CountCUDANonUnifiedSymbols (const semantics::UnorderedSymbolSet &symbols)
bool	IsNonAllocatableModuleCUDAManagedSymbol (const Symbol &sym)
template<typename A>
bool	HasNonAllocatableModuleCUDAManagedSymbols (const A &expr)
template<typename A>
int	GetNbOfCUDADeviceSymbols (const A &expr)
int	GetNbOfUniqueCUDADeviceSymbols (const Expr< SomeType > &expr)
int	GetNbOfUniqueCUDAManagedOrUnifiedSymbols (const Expr< SomeType > &expr)
template<typename A>
int	GetNbOfCUDAManagedOrUnifiedSymbols (const A &expr)
template<typename A>
bool	HasCUDADeviceAttrs (const A &expr)
template<typename A>
bool	IsWholeManagedArray (const A &expr)
template<typename A, typename B>
bool	IsCUDADataTransfer (const A &lhs, const B &rhs)
bool	HasCUDAImplicitTransfer (const Expr< SomeType > &expr)
bool	HasOnlyCUDAConstntImplicitTransfer (const Expr< SomeType > &expr)
	Check if the expression is a mix of host and constant variables.
bool	CheckForSymbolMatch (const Expr< SomeType > lhs, const Expr< SomeType > rhs)
std::pair< operation::Operator, std::vector< Expr< SomeType > > >	GetTopLevelOperation (const Expr< SomeType > &expr)
std::pair< operation::Operator, std::vector< Expr< SomeType > > >	GetTopLevelOperationIgnoreResizing (const Expr< SomeType > &expr)
bool	IsSameOrConvertOf (const Expr< SomeType > &expr, const Expr< SomeType > &x)
bool	IsVarSubexpressionOf (const Expr< SomeType > &var, const Expr< SomeType > &super)
std::optional< Expr< SomeType > >	GetConvertInput (const Expr< SomeType > &x)
std::optional< int >	CountDerivedTypeAncestors (const semantics::Scope &)
std::optional< Expr< SomeType > >	GetEnumerationOrdinal (Expr< SomeDerived > &)
Expr< SomeType >	MakeEnumerationIntCall (Expr< SomeDerived > &&)
const semantics::DerivedTypeSpec *	GetDerivedTypeSpec (const DynamicType &)
const semantics::DerivedTypeSpec *	GetDerivedTypeSpec (const std::optional< DynamicType > &)
const semantics::DerivedTypeSpec *	GetEnumerationTypeSpec (const DynamicType &)
const semantics::DerivedTypeSpec *	GetEnumerationTypeSpec (const std::optional< DynamicType > &)
const semantics::DerivedTypeSpec *	GetParentTypeSpec (const semantics::DerivedTypeSpec &)
int	SelectedCharKind (const std::string &, int defaultKind)
std::optional< DynamicType >	ComparisonType (const DynamicType &, const DynamicType &)
std::optional< bool >	IsInteroperableIntrinsicType (const DynamicType &, const common::LanguageFeatureControl *=nullptr, bool checkCharLength=true)
bool	IsCUDAIntrinsicType (const DynamicType &)
bool	AreSameDerivedType (const semantics::DerivedTypeSpec &, const semantics::DerivedTypeSpec &)
bool	AreSameDerivedTypeIgnoringTypeParameters (const semantics::DerivedTypeSpec &, const semantics::DerivedTypeSpec &)
bool	AreSameDerivedTypeIgnoringLengthParameters (const semantics::DerivedTypeSpec &, const semantics::DerivedTypeSpec &)
bool	AreSameDerivedTypeIgnoringSequence (const semantics::DerivedTypeSpec &, const semantics::DerivedTypeSpec &)
template<std::size_t J, typename VISITOR>
common::IfNoLvalue< typename VISITOR::Result, VISITOR >	SearchTypesHelper (VISITOR &&visitor, typename VISITOR::Result &&defaultResult)
template<typename VISITOR>
common::IfNoLvalue< typename VISITOR::Result, VISITOR >	SearchTypes (VISITOR &&visitor, typename VISITOR::Result defaultResult=typename VISITOR::Result{})
template<typename T>
void	ResetExpr (const T &x)
template<typename T>
void	SetExpr (const T &x, Expr< SomeType > &&expr)
bool	AreConformable (int leftRank, int rightRank)
template<typename L, typename R>
bool	AreConformable (const L &left, const R &right)
template<typename L, typename R>
void	ConformabilityCheck (parser::ContextualMessages &context, const L &left, const R &right)
Expr< Type< TypeCategory::Character > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Character > > &&funcRef)
Expr< Type< TypeCategory::Character > >	FoldOperation (FoldingContext &context, Concat &&x)
Expr< Type< TypeCategory::Character > >	FoldOperation (FoldingContext &context, SetLength &&x)
Expr< Type< TypeCategory::Complex > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Complex > > &&funcRef)
Expr< Type< TypeCategory::Complex > >	FoldOperation (FoldingContext &context, ComplexConstructor &&x)
std::optional< Constant< SubscriptInteger > >	GetConstantSubscript (FoldingContext &, Subscript &, const NamedEntity &, int dim)
template<typename TR, typename... TA, std::size_t... I>
std::optional< std::function< Scalar< TR >(FoldingContext &, Scalar< TA >...)> >	GetHostRuntimeWrapperHelper (int resultKind, std::array< int, sizeof...(TA)> argKinds, const std::string &name, std::index_sequence< I... >)
template<typename A>
common::IfNoLvalue< Expr< ResultType< A > >, A >	FoldOperation (FoldingContext &, A &&x)
ComplexPart	FoldOperation (FoldingContext &, ComplexPart &&)
Expr< Type< TypeCategory::Real > >	FoldOperation (FoldingContext &, ComplexComponent &&)
Component	FoldOperation (FoldingContext &, Component &&)
NamedEntity	FoldOperation (FoldingContext &, NamedEntity &&)
Triplet	FoldOperation (FoldingContext &, Triplet &&)
Subscript	FoldOperation (FoldingContext &, Subscript &&)
ArrayRef	FoldOperation (FoldingContext &, ArrayRef &&)
CoarrayRef	FoldOperation (FoldingContext &, CoarrayRef &&)
DataRef	FoldOperation (FoldingContext &, DataRef &&)
Substring	FoldOperation (FoldingContext &, Substring &&)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &, FunctionRef< T > &&)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Designator< T > &&designator)
Expr< TypeParamInquiry::Result >	FoldOperation (FoldingContext &, TypeParamInquiry &&)
Expr< RankOneBoundElement::Result >	FoldOperation (FoldingContext &, RankOneBoundElement &&)
Expr< ImpliedDoIndex::Result >	FoldOperation (FoldingContext &context, ImpliedDoIndex &&)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &, ArrayConstructor< T > &&)
Expr< SomeDerived >	FoldOperation (FoldingContext &, StructureConstructor &&)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &, ConditionalExpr< T > &&)
template<typename... A, std::size_t... I>
std::optional< std::tuple< const Constant< A > *... > >	GetConstantArgumentsHelper (const std::array< int, sizeof...(A)> &kinds, FoldingContext &context, ActualArguments &arguments, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename... A>
std::optional< std::tuple< const Constant< A > *... > >	GetConstantArguments (const std::array< int, sizeof...(A)> &kinds, FoldingContext &context, ActualArguments &args, bool hasOptionalArgument)
template<typename... A, std::size_t... I>
std::optional< std::tuple< Scalar< A >... > >	GetScalarConstantArgumentsHelper (const std::array< int, sizeof...(A)> &kinds, FoldingContext &context, ActualArguments &args, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename... A>
std::optional< std::tuple< Scalar< A >... > >	GetScalarConstantArguments (const std::array< int, sizeof...(A)> &kinds, FoldingContext &context, ActualArguments &args, bool hasOptionalArgument)
template<template< typename, typename... > typename WrapperType, typename TR, typename... TA, std::size_t... I>
Expr< TR >	FoldElementalIntrinsicHelper (int resultKind, const std::array< int, sizeof...(TA)> &argKinds, FoldingContext &context, FunctionRef< TR > &&funcRef, WrapperType< TR, TA... > func, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename TR, typename... TA>
Expr< TR >	FoldElementalIntrinsic (int resultKind, const std::array< int, sizeof...(TA)> &argKinds, FoldingContext &context, FunctionRef< TR > &&funcRef, ScalarFunc< TR, TA... > func, bool hasOptionalArgument=false)
template<typename TR, typename... TA>
Expr< TR >	FoldElementalIntrinsic (int resultKind, const std::array< int, sizeof...(TA)> &argKinds, FoldingContext &context, FunctionRef< TR > &&funcRef, ScalarFuncWithContext< TR, TA... > func, bool hasOptionalArgument=false)
std::optional< std::int64_t >	GetInt64ArgOr (const std::optional< ActualArgument > &, std::int64_t defaultValue)
template<typename A, typename B>
std::optional< std::vector< A > >	GetIntegerVector (const B &x)
template<typename T>
Expr< T >	MakeInvalidIntrinsic (FunctionRef< T > &&funcRef)
std::optional< Expr< SomeType > >	FoldTransfer (FoldingContext &, const ActualArguments &)
template<typename T>
Expr< T >	FoldMINorMAX (FoldingContext &context, FunctionRef< T > &&funcRef, Ordering order)
template<typename T>
Expr< T >	RewriteSpecificMINorMAX (FoldingContext &context, FunctionRef< T > &&funcRef)
Expr< Type< TypeCategory::Integer > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer > > &&)
Expr< Type< TypeCategory::Unsigned > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Unsigned > > &&)
Expr< Type< TypeCategory::Real > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Real > > &&)
Expr< Type< TypeCategory::Logical > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Logical > > &&)
Expr< SomeDerived >	FoldEnumerationNextOrPrevious (FoldingContext &context, FunctionRef< SomeDerived > &&funcRef, bool isNext)
bool	IsTypeOnlyInquiryArg (const SpecificIntrinsic &intrinsic, std::size_t j)
template<typename T>
bool	ArrayConstructorIsFlat (const ArrayConstructorValues< T > &values)
template<typename T>
std::optional< Expr< T > >	AsFlatArrayConstructor (const Expr< T > &expr)
template<TypeCategory CAT>
std::enable_if_t< CAT !=TypeCategory::Derived, std::optional< Expr< SomeKind< CAT > > > >	AsFlatArrayConstructor (const Expr< SomeKind< CAT > > &expr)
template<typename T>
std::optional< Expr< T > >	FromArrayConstructor (FoldingContext &context, ArrayConstructor< T > &&values, const Shape &shape)
template<typename RESULT, typename OPERAND>
std::optional< Expr< RESULT > >	MapOperation (int kind, FoldingContext &context, std::function< Expr< RESULT >(Expr< OPERAND > &&)> &&f, const Shape &shape, std::optional< Expr< SubscriptInteger > > &&length, Expr< OPERAND > &&values)
template<typename RESULT, typename A>
ArrayConstructor< RESULT >	ArrayConstructorFromMold (int kind, const A &prototype, std::optional< Expr< SubscriptInteger > > &&length)
template<typename LEFT, typename RIGHT>
bool	ShapesMatch (FoldingContext &context, const ArrayConstructor< LEFT > &leftArrConst, const ArrayConstructor< RIGHT > &rightArrConst)
template<typename RESULT, typename LEFT, typename RIGHT>
auto	MapOperation (int kind, FoldingContext &context, std::function< Expr< RESULT >(Expr< LEFT > &&, Expr< RIGHT > &&)> &&f, const Shape &shape, std::optional< Expr< SubscriptInteger > > &&length, Expr< LEFT > &&leftValues, Expr< RIGHT > &&rightValues) -> std::optional< Expr< RESULT > >
template<typename RESULT, typename LEFT, typename RIGHT>
auto	MapOperation (int kind, FoldingContext &context, std::function< Expr< RESULT >(Expr< LEFT > &&, Expr< RIGHT > &&)> &&f, const Shape &shape, std::optional< Expr< SubscriptInteger > > &&length, Expr< LEFT > &&leftValues, const Expr< RIGHT > &rightScalar) -> std::optional< Expr< RESULT > >
template<typename RESULT, typename LEFT, typename RIGHT>
auto	MapOperation (int kind, FoldingContext &context, std::function< Expr< RESULT >(Expr< LEFT > &&, Expr< RIGHT > &&)> &&f, const Shape &shape, std::optional< Expr< SubscriptInteger > > &&length, const Expr< LEFT > &leftScalar, Expr< RIGHT > &&rightValues) -> std::optional< Expr< RESULT > >
template<typename DERIVED, typename RESULT, typename... OPD>
std::optional< Expr< SubscriptInteger > >	ComputeResultLength (Operation< DERIVED, RESULT, OPD... > &operation)
template<typename DERIVED, typename RESULT, typename OPERAND>
auto	ApplyElementwise (FoldingContext &context, Operation< DERIVED, RESULT, OPERAND > &operation, std::function< Expr< RESULT >(Expr< OPERAND > &&)> &&f) -> std::optional< Expr< RESULT > >
template<typename DERIVED, typename RESULT, typename OPERAND>
auto	ApplyElementwise (FoldingContext &context, Operation< DERIVED, RESULT, OPERAND > &operation) -> std::optional< Expr< RESULT > >
template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
auto	ApplyElementwise (FoldingContext &context, Operation< DERIVED, RESULT, LEFT, RIGHT > &operation, std::function< Expr< RESULT >(Expr< LEFT > &&, Expr< RIGHT > &&)> &&f) -> std::optional< Expr< RESULT > >
template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
auto	ApplyElementwise (FoldingContext &context, Operation< DERIVED, RESULT, LEFT, RIGHT > &operation) -> std::optional< Expr< RESULT > >
template<typename TO, typename FROM>
common::IfNoLvalue< std::optional< TO >, FROM >	ConvertString (int toKind, FROM &&s)
template<typename TO, TypeCategory FROMCAT>
Expr< TO >	FoldOperation (FoldingContext &context, Convert< TO, FROMCAT > &&convert)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Parentheses< T > &&x)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Negate< T > &&x)
template<typename LEFT, typename RIGHT>
std::optional< std::pair< Scalar< LEFT >, Scalar< RIGHT > > >	OperandsAreConstants (const Expr< LEFT > &x, const Expr< RIGHT > &y)
template<typename DERIVED, typename RESULT, typename LEFT, typename RIGHT>
std::optional< std::pair< Scalar< LEFT >, Scalar< RIGHT > > >	OperandsAreConstants (const Operation< DERIVED, RESULT, LEFT, RIGHT > &operation)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Add< T > &&x)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Subtract< T > &&x)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Multiply< T > &&x)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Divide< T > &&x)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Power< T > &&x)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, RealToIntPower< T > &&x)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &context, Extremum< T > &&x)
Expr< Type< TypeCategory::Real > >	ToReal (int kind, FoldingContext &context, Expr< SomeType > &&expr)
template<typename T>
Expr< T >	PackageConstantBounds (int kind, const ConstantSubscripts &&bounds, bool asScalar=false)
Expr< Type< TypeCategory::Integer > >	LBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer > > &&funcRef)
Expr< Type< TypeCategory::Integer > >	UBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer > > &&funcRef)
Expr< Type< TypeCategory::Integer > >	COBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer > > &&funcRef, bool isUCOBOUND)
template<typename T>
std::optional< Expr< T > >	FoldIntrinsicFunctionCommon (FoldingContext &context, FunctionRef< T > &funcRef)
template<typename T>
Expr< LogicalResult >	FoldOperation (FoldingContext &context, Relational< T > &&relation)
Expr< LogicalResult >	FoldOperation (FoldingContext &context, Relational< SomeType > &&relation)
Expr< Type< TypeCategory::Logical > >	FoldOperation (FoldingContext &context, Not &&x)
Expr< Type< TypeCategory::Logical > >	FoldOperation (FoldingContext &context, LogicalOperation &&operation)
bool	CheckReductionDIM (std::optional< int > &dim, FoldingContext &context, ActualArguments &arg, std::optional< int > dimIndex, int rank)
Constant< LogicalResult > *	GetReductionMASK (std::optional< ActualArgument > &maskArg, const ConstantSubscripts &shape, FoldingContext &context)
template<typename T>
Expr< T >	FoldDotProduct (FoldingContext &context, FunctionRef< T > &&funcRef)
template<typename T>
std::optional< ArrayAndMask< T > >	ProcessReductionArgs (int kind, FoldingContext &context, ActualArguments &arg, std::optional< int > &dim, int arrayIndex, std::optional< int > dimIndex=std::nullopt, std::optional< int > maskIndex=std::nullopt)
template<typename T, typename ACCUMULATOR, typename ARRAY>
Constant< T >	DoReduction (int kind, const Constant< ARRAY > &array, const Constant< LogicalResult > &mask, std::optional< int > &dim, const Scalar< T > &identity, ACCUMULATOR &accumulator)
template<typename T>
Expr< T >	FoldMaxvalMinval (FoldingContext &context, FunctionRef< T > &&ref, RelationalOperator opr, const Scalar< T > &identity)
template<typename T>
Expr< T >	FoldProduct (FoldingContext &context, FunctionRef< T > &&ref, Scalar< T > identity)
template<typename T>
Expr< T >	FoldSum (FoldingContext &context, FunctionRef< T > &&ref)
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const Symbol &symbol, std::optional< parser::CharBlock > name=std::nullopt)
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::string &lit)
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::u16string &lit)
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::u32string &lit)
template<typename A>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const A &x)
template<typename A>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, common::Reference< A > x)
template<typename A>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const A p, const char kw=nullptr)
template<typename A>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::optional< A > &x, const char *kw=nullptr)
template<typename A, bool COPY>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const common::Indirection< A, COPY > &p, const char *kw=nullptr)
template<typename A>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::shared_ptr< A > &p)
template<typename... A>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::variant< A... > &u)
template<typename A>
constexpr Precedence	ToPrecedence (const A &)
Precedence	ToPrecedence (const Not &)
template<typename T>
constexpr Precedence	ToPrecedence (const Relational< T > &)
template<typename T>
constexpr Precedence	ToPrecedence (const Add< T > &)
template<typename T>
constexpr Precedence	ToPrecedence (const Subtract< T > &)
Precedence	ToPrecedence (const Concat &)
template<typename T>
constexpr Precedence	ToPrecedence (const Negate< T > &)
template<typename T>
constexpr Precedence	ToPrecedence (const Multiply< T > &)
template<typename T>
constexpr Precedence	ToPrecedence (const Divide< T > &)
template<typename T>
constexpr Precedence	ToPrecedence (const Power< T > &)
template<typename T>
constexpr Precedence	ToPrecedence (const RealToIntPower< T > &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const A &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const Negate< A > &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const Parentheses< A > &)
constexpr OperatorSpelling	SpellOperator (const Not &)
constexpr OperatorSpelling	SpellOperator (const SetLength &)
constexpr OperatorSpelling	SpellOperator (const ComplexConstructor &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const Add< A > &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const Subtract< A > &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const Multiply< A > &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const Divide< A > &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const Power< A > &)
template<typename A>
constexpr OperatorSpelling	SpellOperator (const RealToIntPower< A > &)
constexpr OperatorSpelling	SpellOperator (const Concat &)
template<typename T>
llvm::raw_ostream &	EmitArray (llvm::raw_ostream &o, const Expr< T > &expr)
template<typename T>
llvm::raw_ostream &	EmitArray (llvm::raw_ostream &, const ArrayConstructorValues< T > &)
template<typename T>
llvm::raw_ostream &	EmitArray (llvm::raw_ostream &o, const ImpliedDo< T > &implDo)
ValueWithRealFlags< value::RealValue >	IntPower (const value::RealValue &base, const value::IntegerValue &power, Rounding rounding)
ValueWithRealFlags< value::ComplexValue >	IntPower (const value::ComplexValue &base, const value::IntegerValue &power, Rounding rounding)
bool	operator== (const TypeVector &lhs, const std::vector< DynamicType > &rhs)
template<typename HostTR, typename... HostTA>
Expr< SomeType >	ApplyHostFunction (FuncPointer< HostTR, HostTA... > func, FoldingContext &context, std::vector< Expr< SomeType > > &&args)
const ArgumentVerifierFunc *	findVerifier (const std::string &intrinsicName)
	ENUM_CLASS (KindCode, none, defaultIntegerKind, defaultRealKind, doublePrecision, quadPrecision, defaultCharKind, defaultLogicalKind, greaterOrEqualToKind, any, same, sameKind, operand, typeless, ieeeFlagType, ieeeRoundType, eventType, teamType, kindArg, effectiveKind, dimArg, likeMultiply, subscript, size, addressable, nullPointerType, exactKind, atomicIntKind, atomicIntOrLogicalKind, sameAtom, extensibleOrUnlimitedType,) struct TypePattern
	ENUM_CLASS (Rank, elemental, elementalOrBOZ, scalar, vector, shape, matrix, array, coarray, atom, known, anyOrAssumedRank, arrayOrAssumedRank, conformable, reduceOperation, dimReduced, dimRemovedOrScalar, scalarIfDim, locReduced, rankPlus1, shaped,) ENUM_CLASS(Optionality
	ENUM_CLASS (ArgFlag, none, canBeNullPointer, canBeMoldNull, canBeNullAllocatable, defaultsToSameKind, defaultsToSizeKind, defaultsToDefaultForResult, notAssumedSize, onlyConstantInquiry) struct IntrinsicDummyArgument
FoldingContext &	GetFoldingContextFrom (const Symbol &symbol)
template<TypeCategory CAT>
std::optional< Expr< SomeType > >	Package (Expr< SomeKind< CAT > > &&catExpr)
template<TypeCategory CAT>
std::optional< Expr< SomeType > >	Package (std::optional< Expr< SomeKind< CAT > > > &&catExpr)
template<template< typename > class OPR>
std::optional< Expr< SomeType > >	MixedRealLeft (Expr< SomeReal > &&rx, Expr< SomeInteger > &&iy)
Expr< SomeComplex >	PromoteRealToComplex (Expr< SomeReal > &&someX)
template<template< typename > class OPR, TypeCategory RCAT>
std::optional< Expr< SomeType > >	MixedComplexLeft (parser::ContextualMessages &messages, const Expr< SomeComplex > &zx, const Expr< SomeKind< RCAT > > &iry, int defaultRealKind)
template<template< typename > class OPR, TypeCategory LCAT>
std::optional< Expr< SomeType > >	MixedComplexRight (parser::ContextualMessages &messages, const Expr< SomeKind< LCAT > > &irx, const Expr< SomeComplex > &zy, int defaultRealKind)
template<template< typename > class OPR, TypeCategory XCAT, TypeCategory YCAT>
Expr< SomeComplex >	PromoteMixedComplexReal (Expr< SomeKind< XCAT > > &&x, Expr< SomeKind< YCAT > > &&y)
template<TypeCategory CAT>
Expr< LogicalResult >	PromoteAndRelate (RelationalOperator opr, Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory TO>
std::optional< Expr< SomeType > >	ConvertToNumeric (int kind, Expr< SomeType > &&x)
std::pair< semantics::UnorderedSymbolSet, semantics::UnorderedSymbolSet >	GetHostAndDeviceSymbols (const Expr< SomeType > &expr)
template<>
semantics::Attrs	GetAttrs< Expr< SomeType > > (const Expr< SomeType > &x)
template<typename T>
const Symbol *	GetBoundSymbol (const Expr< T > &)
const Symbol *	GetBoundSymbol (const Expr< Type< TypeCategory::Integer > > &expr)
template<>
const Symbol *	GetBoundSymbol< SomeInteger > (const Expr< SomeInteger > &expr)
template<typename A>
bool	PointeeComparison (const A x, const A y)
bool	operator< (ActualArgumentRef x, ActualArgumentRef y)
template<typename A>
common::IfNoLvalue< MaybeExpr, A >	AsMaybeExpr (A &&x)
template<typename A>
MaybeExpr	AsMaybeExpr (std::optional< A > &&x)
template<typename TYPE>
Constant< TYPE >	ReadRealLiteral (int kind, parser::CharBlock source, FoldingContext &context, bool isDefaultKind)
template<typename T>
ArrayConstructorValues< T >	MakeSpecific (ArrayConstructorValues< SomeType > &&from)
template<>
const Symbol *	AssumedTypeDummy< parser::Name > (const parser::Name &name)
template<>
const Symbol *	AssumedTypeDummy< parser::AllocateObject > (const parser::AllocateObject &x)
template<>
const Symbol *	AssumedTypeDummy< parser::PointerObject > (const parser::PointerObject &x)
template<template< typename > class OPR, NumericOperator opr>
MaybeExpr	NumericBinaryHelper (ExpressionAnalyzer &context, const parser::Expr::IntrinsicBinary &x)
MaybeExpr	RelationHelper (ExpressionAnalyzer &context, RelationalOperator opr, const parser::Expr::IntrinsicBinary &x)
MaybeExpr	LogicalBinaryHelper (ExpressionAnalyzer &context, LogicalOperator opr, const parser::Expr::IntrinsicBinary &x)

Variables
template<typename A>
constexpr int	ResultKind = std::decay_t<A>::kind()
constexpr int	BOZLiteralConstantKind = LargestRealKind
constexpr int	ExtentIntKind = Fortran::evaluate::SubscriptIntegerKind
constexpr int	SubscriptIntegerKind {8}
constexpr int	CIntegerKind {4}
constexpr int	LargestIntKind {16}
constexpr int	LogicalResultKind {4}
constexpr int	LargestRealKind {16}
constexpr int	AsciiKind {1}
template<typename T>
constexpr bool	IsSpecificIntrinsicType {common::HasMember<T, AllIntrinsicTypes>}
template<typename T>
constexpr bool	IsLengthlessIntrinsicType
	required
	optional
	missing
	repeats

Detailed Description

Implements the conversion from evaluate::ArrayConstructor to HLFIR.

Typedef Documentation

◆ AllIntrinsicCategoryTypes

using Fortran::evaluate::AllIntrinsicCategoryTypes

Initial value:

 
    std::tuple<SomeKind<TypeCategory::Integer>, SomeKind<TypeCategory::Real>,
        SomeKind<TypeCategory::Complex>, SomeKind<TypeCategory::Character>,
        SomeKind<TypeCategory::Logical>, SomeKind<TypeCategory::Unsigned>>

◆ AllIntrinsicKindTypes

using Fortran::evaluate::AllIntrinsicKindTypes

Initial value:

 
    common::CombineTuples<IntegerKindTypes, UnsignedKindTypes, LogicalKindTypes,
        RealKindTypes, ComplexKindTypes, CharacterKindTypes>

◆ AllIntrinsicTypes

using Fortran::evaluate::AllIntrinsicTypes

Initial value:

common::CombineTuples<NumericTypes, CharacterTypes, LogicalTypes>

◆ AllTypes

using Fortran::evaluate::AllTypes

Initial value:

common::CombineTuples<AllIntrinsicTypes, std::tuple<SomeDerived>>

◆ ArgumentVerifierFunc

using Fortran::evaluate::ArgumentVerifierFunc

Initial value:

bool (*)(

const std::vector<Expr<SomeType>> &, FoldingContext &)

Fortran::evaluate::FoldingContext

Definition common.h:224

Structure to register intrinsic argument checks that must be performed.

◆ CharacterKindTypes

using Fortran::evaluate::CharacterKindTypes

Initial value:

std::tuple<TypeKind<TypeCategory::Character, 1>,

TypeKind<TypeCategory::Character, 2>, TypeKind<TypeCategory::Character, 4>>

Fortran::evaluate::TypeKind

Definition typekind-traits.h:46

◆ ComplexKindTypes

using Fortran::evaluate::ComplexKindTypes

Initial value:

 std::tuple<TypeKind<TypeCategory::Complex, 2>,
    TypeKind<TypeCategory::Complex, 3>, TypeKind<TypeCategory::Complex, 4>,
    TypeKind<TypeCategory::Complex, 8>, TypeKind<TypeCategory::Complex, 10>,
    TypeKind<TypeCategory::Complex, 16>>

◆ ConvertRealOperandsResult

using Fortran::evaluate::ConvertRealOperandsResult

Initial value:

std::optional<SameKindExprs<TypeCategory::Real, 2>>

◆ HostRuntimeWrapper

using Fortran::evaluate::HostRuntimeWrapper

Initial value:

std::function<Expr<SomeType>(

FoldingContext &, std::vector<Expr<SomeType>> &&)>

Fortran::evaluate::Expr

Definition common.h:222

◆ HostUnsignedInt

template<int BITS>

using Fortran::evaluate::HostUnsignedInt

Initial value:

typename SmallestUInt<BITS <= 8, BITS <= 16, BITS <= 32, BITS <= 64>::type

Fortran::evaluate::SmallestUInt

Definition common.h:162

◆ IndirectSubscriptIntegerExpr

using Fortran::evaluate::IndirectSubscriptIntegerExpr

Initial value:

common::CopyableIndirection<Expr<SubscriptInteger>>

◆ IntegerKindTypes

using Fortran::evaluate::IntegerKindTypes

Initial value:

 std::tuple<TypeKind<TypeCategory::Integer, 1>,
    TypeKind<TypeCategory::Integer, 2>, TypeKind<TypeCategory::Integer, 4>,
    TypeKind<TypeCategory::Integer, 8>, TypeKind<TypeCategory::Integer, 16>>

◆ LengthlessIntrinsicTypes

using Fortran::evaluate::LengthlessIntrinsicTypes

Initial value:

common::CombineTuples<NumericTypes, LogicalTypes>

◆ LogicalKindTypes

using Fortran::evaluate::LogicalKindTypes

Initial value:

 std::tuple<TypeKind<TypeCategory::Logical, 1>,
    TypeKind<TypeCategory::Logical, 2>, TypeKind<TypeCategory::Logical, 4>,
    TypeKind<TypeCategory::Logical, 8>>

◆ NumericCategoryTypes

using Fortran::evaluate::NumericCategoryTypes

Initial value:

 
    std::tuple<SomeKind<TypeCategory::Integer>, SomeKind<TypeCategory::Real>,
        SomeKind<TypeCategory::Complex>, SomeKind<TypeCategory::Unsigned>>

◆ NumericTypes

using Fortran::evaluate::NumericTypes

Initial value:

common::CombineTuples<IntegerTypes, FloatingTypes, UnsignedTypes>

◆ RealKindTypes

using Fortran::evaluate::RealKindTypes

Initial value:

 
    std::tuple<TypeKind<TypeCategory::Real, 2>, TypeKind<TypeCategory::Real, 3>,
        TypeKind<TypeCategory::Real, 4>, TypeKind<TypeCategory::Real, 8>,
        TypeKind<TypeCategory::Real, 10>, TypeKind<TypeCategory::Real, 16>>

◆ RelationalTypes

using Fortran::evaluate::RelationalTypes

Initial value:

common::CombineTuples<IntegerTypes, RealTypes,

CharacterTypes, UnsignedTypes>

◆ SameKindExprs

template<TypeCategory CAT, int N = 2>

using Fortran::evaluate::SameKindExprs

Initial value:

 
    common::MapTemplate<SameKindExprsHelper<N>::template SameExprs,
        CategoryTypes<CAT>>

◆ ScalarFuncWithContext

template<typename TR, typename... TArgs>

using Fortran::evaluate::ScalarFuncWithContext

Initial value:

std::function<Scalar<TR>(FoldingContext &, const Scalar<TArgs> &...)>

◆ SetOfDerivedTypePairs

using Fortran::evaluate::SetOfDerivedTypePairs

Initial value:

 
    std::set<std::pair<const semantics::DerivedTypeSpec *,
        const semantics::DerivedTypeSpec *>>

◆ SomeCategory

using Fortran::evaluate::SomeCategory

Initial value:

std::tuple<SomeInteger, SomeReal, SomeComplex,

SomeCharacter, SomeLogical, SomeUnsigned, SomeDerived>

◆ StructureConstructorValues

using Fortran::evaluate::StructureConstructorValues

Initial value:

std::map<SymbolRef,

common::CopyableIndirection<Expr<SomeType>>, ComponentCompare>

Fortran::evaluate::ComponentCompare

Definition constant.h:273

◆ TypelessExpression

using Fortran::evaluate::TypelessExpression

Initial value:

std::variant<BOZLiteralConstant, NullPointer,

ProcedureDesignator, ProcedureRef>

Fortran::evaluate::ProcedureRef

Definition call.h:348

Fortran::evaluate::NullPointer

Definition expression.h:942

Fortran::evaluate::ProcedureDesignator

Definition call.h:298

◆ UnsignedKindTypes

using Fortran::evaluate::UnsignedKindTypes

Initial value:

 std::tuple<TypeKind<TypeCategory::Unsigned, 1>,
    TypeKind<TypeCategory::Unsigned, 2>, TypeKind<TypeCategory::Unsigned, 4>,
    TypeKind<TypeCategory::Unsigned, 8>, TypeKind<TypeCategory::Unsigned, 16>>

Function Documentation

◆ HasCUDAImplicitTransfer()

bool Fortran::evaluate::HasCUDAImplicitTransfer ( const Expr< SomeType > & expr )

Check if the expression uses device data in an operation evaluated on the host, which requires an implicit data transfer.

◆ UnwrapExpr()

template<typename A, typename B>

auto Fortran::evaluate::UnwrapExpr	(	int	kind,
		B &	x )

A variant of UnwrapExpr that also requires a specific kind of the expression.

Variable Documentation

◆ IsLengthlessIntrinsicType

template<typename T>

bool Fortran::evaluate::IsLengthlessIntrinsicType

constexpr

Initial value:

{

common::HasMember<T, LengthlessIntrinsicTypes>}

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ AllIntrinsicCategoryTypes

◆ AllIntrinsicKindTypes

◆ AllIntrinsicTypes

◆ AllTypes

◆ ArgumentVerifierFunc

◆ CharacterKindTypes

◆ ComplexKindTypes

◆ ConvertRealOperandsResult

◆ HostRuntimeWrapper

◆ HostUnsignedInt

◆ IndirectSubscriptIntegerExpr

◆ IntegerKindTypes

◆ LengthlessIntrinsicTypes

◆ LogicalKindTypes

◆ NumericCategoryTypes

◆ NumericTypes

◆ RealKindTypes

◆ RelationalTypes

◆ SameKindExprs

◆ ScalarFuncWithContext

◆ SetOfDerivedTypePairs

◆ SomeCategory

◆ StructureConstructorValues

◆ TypelessExpression

◆ UnsignedKindTypes

Function Documentation

◆ HasCUDAImplicitTransfer()

◆ UnwrapExpr()

Variable Documentation

◆ IsLengthlessIntrinsicType