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, KIND > >
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	CollectSymbolsHelper
struct	ComplexComponent
struct	ComplexConstructor
class	ComplexPart
struct	ComplexPartExtractor
class	Component
struct	ComponentCompare
struct	Concat
class	Constant
class	Constant< SomeDerived >
class	Constant< Type< TypeCategory::Character, KIND > >
class	ConstantBase
class	ConstantBounds
struct	ConstantObjectPointer
struct	Convert
struct	ConvertToKindHelper
class	CopyInOutExplicitInterface
class	CountAccumulator
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, KIND > >
class	Expr< Type< TypeCategory::Complex, KIND > >
class	Expr< Type< TypeCategory::Integer, KIND > >
class	Expr< Type< TypeCategory::Logical, KIND > >
class	Expr< Type< TypeCategory::Real, KIND > >
class	Expr< Type< TypeCategory::Unsigned, KIND > >
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	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
class	IntrinsicCallHelper
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	OffsetSymbol
class	Operation
class	OperationAccumulator
struct	OperatorSpelling
struct	Parentheses
struct	Parentheses< SomeDerived >
struct	Power
struct	ProcedureDesignator
class	ProcedureRef
class	ProductAccumulator
class	RealToIntLimitHelper
struct	RealToIntPower
struct	RealTypeVisitor
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, 1 >
class	Type< TypeCategory::Character, 2 >
class	Type< TypeCategory::Character, 4 >
class	Type< TypeCategory::Complex, KIND >
class	Type< TypeCategory::Integer, KIND >
class	Type< TypeCategory::Logical, KIND >
class	Type< TypeCategory::Real, KIND >
class	Type< TypeCategory::Unsigned, KIND >
struct	TypeBase
struct	TypeKindVisitor
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, 8>
using	CInteger = Type<TypeCategory::Integer, 4>
using	LargestInt = Type<TypeCategory::Integer, 16>
using	LogicalResult = Type<TypeCategory::Logical, 4>
using	LargestReal = Type<TypeCategory::Real, 16>
using	Ascii = Type<TypeCategory::Character, 1>
template<TypeCategory CATEGORY, typename T>
using	SameKind = Type<CATEGORY, std::decay_t<T>::kind>
using	IndirectSubscriptIntegerExpr
template<TypeCategory CATEGORY, int KIND>
using	CategoryKindTuple
template<TypeCategory CATEGORY, int... KINDS>
using	CategoryTypesHelper
template<TypeCategory CATEGORY>
using	CategoryTypes = CategoryTypesHelper<CATEGORY, 1, 2, 3, 4, 8, 10, 16, 32>
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	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 &)
template bool	IsConstantExpr (const Expr< SomeType > &)
template bool	IsConstantExpr (const Expr< SomeInteger > &)
template bool	IsConstantExpr (const Expr< SubscriptInteger > &)
template bool	IsConstantExpr (const StructureConstructor &)
template<typename A>
bool	IsScopeInvariantExpr (const A &)
template bool	IsScopeInvariantExpr (const Expr< SomeType > &)
template bool	IsScopeInvariantExpr (const Expr< SomeInteger > &)
template bool	IsScopeInvariantExpr (const Expr< SubscriptInteger > &)
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)
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	MayNeedCopy (const ActualArgument , const characteristics::DummyArgument , FoldingContext &, bool forCopyOut)
void	RealFlagWarnings (FoldingContext &, const RealFlags &, const char *op)
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 &)
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>
constexpr auto	GetScalarConstantValue (const EXPR &expr) -> std::optional< Scalar< T > >
template<int KIND>
constexpr std::optional< std::int64_t >	ToInt64 (const Expr< Type< TypeCategory::Integer, KIND > > &expr)
template<int KIND>
constexpr std::optional< std::int64_t >	ToInt64 (const Expr< Type< TypeCategory::Unsigned, KIND > > &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 &)
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)
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)
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, impureSubroutine, transformationalFunction, noClass) class IntrinsicProcTable
bool	AcceptsIntentOutAllocatableCoarray (const std::string &)
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 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	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 (Expr< SomeKind< FROMCAT > > &&x)
template<typename TO, TypeCategory FROMCAT, int FROMKIND>
Expr< TO >	ConvertToType (Expr< Type< FROMCAT, FROMKIND > > &&x)
template<typename TO>
Expr< TO >	ConvertToType (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, int TK, typename FROM>
common::IfNoLvalue< Expr< Type< TC, TK > >, FROM >	ConvertTo (const Expr< Type< TC, TK > > &, 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)
template<int K>
Expr< Type< TypeCategory::Logical, K > >	LogicalNegation (Expr< Type< TypeCategory::Logical, K > > &&x)
Expr< SomeLogical >	LogicalNegation (Expr< SomeLogical > &&)
template<int K>
Expr< Type< TypeCategory::Logical, K > >	BinaryLogicalOperation (LogicalOperator opr, Expr< Type< TypeCategory::Logical, K > > &&x, Expr< Type< TypeCategory::Logical, K > > &&y)
Expr< SomeLogical >	BinaryLogicalOperation (LogicalOperator, Expr< SomeLogical > &&, Expr< SomeLogical > &&)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator- (Expr< Type< C, K > > &&x)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator+ (Expr< Type< C, K > > &&x, Expr< Type< C, K > > &&y)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator- (Expr< Type< C, K > > &&x, Expr< Type< C, K > > &&y)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator* (Expr< Type< C, K > > &&x, Expr< Type< C, K > > &&y)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator/ (Expr< Type< C, K > > &&x, Expr< Type< C, K > > &&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 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<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 > &)
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 (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)
bool	IsCUDADeviceSymbol (const Symbol &sym)
bool	IsCUDAManagedOrUnifiedSymbol (const Symbol &sym)
template<typename A>
int	GetNbOfCUDADeviceSymbols (const A &expr)
template<typename A>
int	GetNbOfCUDAManagedOrUnifiedSymbols (const A &expr)
template<typename A>
bool	HasCUDADeviceAttrs (const A &expr)
template<typename A, typename B>
bool	IsCUDADataTransfer (const A &lhs, const B &rhs)
bool	HasCUDAImplicitTransfer (const Expr< SomeType > &expr)
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)
const semantics::DerivedTypeSpec *	GetDerivedTypeSpec (const DynamicType &)
const semantics::DerivedTypeSpec *	GetDerivedTypeSpec (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	AreSameDerivedTypeIgnoringSequence (const semantics::DerivedTypeSpec &, const semantics::DerivedTypeSpec &)
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)
template<int KIND>
Expr< Type< TypeCategory::Character, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Character, KIND > > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Character, KIND > >	FoldOperation (FoldingContext &context, Concat< KIND > &&x)
template<int KIND>
Expr< Type< TypeCategory::Character, KIND > >	FoldOperation (FoldingContext &context, SetLength< KIND > &&x)
template<int KIND>
Expr< Type< TypeCategory::Complex, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Complex, KIND > > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Complex, KIND > >	FoldOperation (FoldingContext &context, ComplexConstructor< KIND > &&x)
std::optional< Constant< SubscriptInteger > >	GetConstantSubscript (FoldingContext &, Subscript &, const NamedEntity &, int dim)
template<typename TR, typename... TA>
std::optional< std::function< Scalar< TR >(FoldingContext &, Scalar< TA >...)> >	GetHostRuntimeWrapper (const std::string &name)
template<typename A>
common::IfNoLvalue< Expr< ResultType< A > >, A >	FoldOperation (FoldingContext &, A &&x)
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 &&)
ComplexPart	FoldOperation (FoldingContext &, ComplexPart &&)
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< ImpliedDoIndex::Result >	FoldOperation (FoldingContext &context, ImpliedDoIndex &&)
template<typename T>
Expr< T >	FoldOperation (FoldingContext &, ArrayConstructor< T > &&)
Expr< SomeDerived >	FoldOperation (FoldingContext &, StructureConstructor &&)
template<typename... A, std::size_t... I>
std::optional< std::tuple< const Constant< A > *... > >	GetConstantArgumentsHelper (FoldingContext &context, ActualArguments &arguments, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename... A>
std::optional< std::tuple< const Constant< A > *... > >	GetConstantArguments (FoldingContext &context, ActualArguments &args, bool hasOptionalArgument)
template<typename... A, std::size_t... I>
std::optional< std::tuple< Scalar< A >... > >	GetScalarConstantArgumentsHelper (FoldingContext &context, ActualArguments &args, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename... A>
std::optional< std::tuple< Scalar< A >... > >	GetScalarConstantArguments (FoldingContext &context, ActualArguments &args, bool hasOptionalArgument)
template<template< typename, typename... > typename WrapperType, typename TR, typename... TA, std::size_t... I>
Expr< TR >	FoldElementalIntrinsicHelper (FoldingContext &context, FunctionRef< TR > &&funcRef, WrapperType< TR, TA... > func, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename TR, typename... TA>
Expr< TR >	FoldElementalIntrinsic (FoldingContext &context, FunctionRef< TR > &&funcRef, ScalarFunc< TR, TA... > func, bool hasOptionalArgument=false)
template<typename TR, typename... TA>
Expr< TR >	FoldElementalIntrinsic (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)
template<int KIND>
Expr< Type< TypeCategory::Integer, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer, KIND > > &&)
template<int KIND>
Expr< Type< TypeCategory::Unsigned, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Unsigned, KIND > > &&)
template<int KIND>
Expr< Type< TypeCategory::Real, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Real, KIND > > &&)
template<int KIND>
Expr< Type< TypeCategory::Logical, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Logical, KIND > > &&)
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 (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 (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 (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 (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 (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 (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)
template<int KIND>
Expr< Type< TypeCategory::Real, KIND > >	ToReal (FoldingContext &context, Expr< SomeType > &&expr)
template<int KIND>
Expr< Type< TypeCategory::Real, KIND > >	FoldOperation (FoldingContext &context, ComplexComponent< KIND > &&x)
template<typename T>
Expr< T >	PackageConstantBounds (const ConstantSubscripts &&bounds, bool asScalar=false)
template<int KIND>
Expr< Type< TypeCategory::Integer, KIND > >	LBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer, KIND > > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Integer, KIND > >	UBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer, KIND > > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Integer, KIND > >	COBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer, KIND > > &&funcRef, bool isUCOBOUND)
template<typename T>
std::optional< Expr< T > >	FoldIntrinsicFunctionCommon (FoldingContext &context, FunctionRef< T > &funcRef)
template<int X_RKIND, int MOLD_IKIND>
Expr< SomeReal >	RealToIntBoundHelper (bool round, bool negate)
template<int X_RKIND, int MOLD_RKIND>
std::optional< std::pair< Expr< SomeReal >, Expr< SomeReal > > >	RealToRealBoundsHelper ()
template<int X_IKIND, int MOLD_RKIND>
std::optional< Expr< SomeInteger > >	IntToRealBoundHelper (bool negate)
template<int X_IKIND, int MOLD_IKIND>
std::optional< Expr< SomeInteger > >	IntToIntBoundHelper ()
template<typename T>
Expr< LogicalResult >	FoldOperation (FoldingContext &context, Relational< T > &&relation)
Expr< LogicalResult >	FoldOperation (FoldingContext &context, Relational< SomeType > &&relation)
template<int KIND>
Expr< Type< TypeCategory::Logical, KIND > >	FoldOperation (FoldingContext &context, Not< KIND > &&x)
template<int KIND>
Expr< Type< TypeCategory::Logical, KIND > >	FoldOperation (FoldingContext &context, LogicalOperation< KIND > &&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)
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 &)
template<int KIND>
constexpr Precedence	ToPrecedence (const Not< KIND > &)
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 > &)
template<int KIND>
constexpr Precedence	ToPrecedence (const Concat< KIND > &)
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 > &)
template<int KIND>
constexpr OperatorSpelling	SpellOperator (const Not< KIND > &)
template<int KIND>
constexpr OperatorSpelling	SpellOperator (const SetLength< KIND > &)
template<int KIND>
constexpr OperatorSpelling	SpellOperator (const ComplexConstructor< KIND > &)
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 > &)
template<int KIND>
constexpr OperatorSpelling	SpellOperator (const Concat< KIND > &)
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)
template<typename REAL, typename INT>
ValueWithRealFlags< REAL >	TimesIntPowerOf (const REAL &factor, const REAL &base, const INT &power, Rounding rounding=TargetCharacteristics::defaultRounding)
template<typename REAL, typename INT>
ValueWithRealFlags< REAL >	IntPower (const REAL &base, const INT &power, Rounding rounding=TargetCharacteristics::defaultRounding)
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,) 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)
template<int KIND>
Expr< SomeComplex >	MakeComplex (Expr< Type< TypeCategory::Real, KIND > > &&re, Expr< Type< TypeCategory::Real, KIND > > &&im)
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)
template<typename T>
const Symbol *	GetBoundSymbol (const Expr< T > &)
template<int KIND>
const Symbol *	GetBoundSymbol (const Expr< Type< TypeCategory::Integer, KIND > > &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 (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 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>>

◆ 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:216

Structure to register intrinsic argument checks that must be performed.

◆ CategoryKindTuple

template<TypeCategory CATEGORY, int KIND>

using Fortran::evaluate::CategoryKindTuple

Initial value:

 
    std::conditional_t<common::IsValidKindOfIntrinsicType(CATEGORY, KIND),
        std::tuple<Type<CATEGORY, KIND>>, std::tuple<>>

◆ CategoryTypesHelper

template<TypeCategory CATEGORY, int... KINDS>

using Fortran::evaluate::CategoryTypesHelper

Initial value:

common::CombineTuples<CategoryKindTuple<CATEGORY, KINDS>...>

◆ 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:214

◆ 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:154

◆ IndirectSubscriptIntegerExpr

using Fortran::evaluate::IndirectSubscriptIntegerExpr

Initial value:

common::CopyableIndirection<Expr<SubscriptInteger>>

◆ LengthlessIntrinsicTypes

using Fortran::evaluate::LengthlessIntrinsicTypes

Initial value:

common::CombineTuples<NumericTypes, LogicalTypes>

◆ 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>

◆ 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:226

◆ TypelessExpression

using Fortran::evaluate::TypelessExpression

Initial value:

std::variant<BOZLiteralConstant, NullPointer,

ProcedureDesignator, ProcedureRef>

Fortran::evaluate::ProcedureRef

Definition call.h:232

Fortran::evaluate::NullPointer

Definition expression.h:827

Fortran::evaluate::ProcedureDesignator

Definition call.h:197

Function Documentation

◆ HasCUDAImplicitTransfer()

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

Check if the expression is a mix of host and device variables that require implicit data transfer.

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

◆ AllIntrinsicTypes

◆ AllTypes

◆ ArgumentVerifierFunc

◆ CategoryKindTuple

◆ CategoryTypesHelper

◆ ConvertRealOperandsResult

◆ HostRuntimeWrapper

◆ HostUnsignedInt

◆ IndirectSubscriptIntegerExpr

◆ LengthlessIntrinsicTypes

◆ NumericCategoryTypes

◆ NumericTypes

◆ RelationalTypes

◆ SameKindExprs

◆ ScalarFuncWithContext

◆ SetOfDerivedTypePairs

◆ SomeCategory

◆ StructureConstructorValues

◆ TypelessExpression

Function Documentation

◆ HasCUDAImplicitTransfer()

Variable Documentation

◆ IsLengthlessIntrinsicType