34 using MaybeExpr =  typedef
157   MaybeExpr TryDefinedOp(const char *, parser::MessageFixedText,
160   MaybeExpr TryDefinedOp(E opr, parser::MessageFixedText msg) {  in TryDefinedOp()
171   MaybeExpr TryDefinedOp(std::vector<const char *>, parser::MessageFixedText);
172   MaybeExpr TryBoundOp(const Symbol &, int passIndex);
174   MaybeExpr AnalyzeExprOrWholeAssumedSizeArray(const parser::Expr &);
198 MaybeExpr ExpressionAnalyzer::Designate(DataRef &&ref) {  in Designate()
224   } else if (MaybeExpr result{AsGenericExpr(std::move(ref))}) {  in Designate()
240 MaybeExpr ExpressionAnalyzer::CompleteSubscripts(ArrayRef &&ref) {  in CompleteSubscripts()
273 MaybeExpr ExpressionAnalyzer::ApplySubscripts(  in ApplySubscripts()
287           [&](auto &&) -> MaybeExpr {  in ApplySubscripts()
376 MaybeExpr ExpressionAnalyzer::FixMisparsedSubstring(  in FixMisparsedSubstring()
389           if (MaybeExpr substringExpr{Analyze(d)}) {  in FixMisparsedSubstring()
402 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Designator &d) {  in Analyze()
409   if (MaybeExpr result{Analyze(d.u)}) {  in Analyze()
433 template <typename A> common::IfNoLvalue<MaybeExpr, A> AsMaybeExpr(A &&x) {  in AsMaybeExpr()
436 template <typename A> MaybeExpr AsMaybeExpr(std::optional<A> &&x) {  in AsMaybeExpr()
454             if (MaybeExpr ie{Analyze(n)}) {  in AnalyzeKindParam()
470   using Result = MaybeExpr;
516 MaybeExpr ExpressionAnalyzer::IntLiteralConstant(  in IntLiteralConstant()
523     if (MaybeExpr result{common::SearchTypes(  in IntLiteralConstant()
538 MaybeExpr ExpressionAnalyzer::Analyze(  in Analyze()
545 MaybeExpr ExpressionAnalyzer::Analyze(  in Analyze()
586 MaybeExpr ExpressionAnalyzer::Analyze(const parser::RealLiteralConstant &x) {  in Analyze()
644 MaybeExpr ExpressionAnalyzer::Analyze(  in Analyze()
658 MaybeExpr ExpressionAnalyzer::Analyze(  in Analyze()
670 MaybeExpr ExpressionAnalyzer::Analyze(const parser::ComplexPart &x) {  in Analyze()
674 MaybeExpr ExpressionAnalyzer::Analyze(const parser::ComplexLiteralConstant &z) {  in Analyze()
681 MaybeExpr ExpressionAnalyzer::AnalyzeString(std::string &&string, int kind) {  in AnalyzeString()
703 MaybeExpr ExpressionAnalyzer::Analyze(const parser::CharLiteralConstant &x) {  in Analyze()
710 MaybeExpr ExpressionAnalyzer::Analyze(  in Analyze()
718 MaybeExpr ExpressionAnalyzer::Analyze(const parser::LogicalLiteralConstant &x) {  in Analyze()
732 MaybeExpr ExpressionAnalyzer::Analyze(const parser::BOZLiteralConstant &x) {  in Analyze()
765 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Name &n) {  in Analyze()
804 MaybeExpr ExpressionAnalyzer::Analyze(const parser::NamedConstant &n) {  in Analyze()
806   if (MaybeExpr value{Analyze(n.v)}) {  in Analyze()
816 MaybeExpr ExpressionAnalyzer::Analyze(const parser::NullInit &n) {  in Analyze()
817   if (MaybeExpr value{Analyze(n.v)}) {  in Analyze()
828 MaybeExpr ExpressionAnalyzer::Analyze(const parser::InitialDataTarget &x) {  in Analyze()
832 MaybeExpr ExpressionAnalyzer::Analyze(const parser::DataStmtValue &x) {  in Analyze()
836     if (MaybeExpr expr{Analyze(repeat->u)}) {  in Analyze()
856     if (MaybeExpr expr{Analyze(*bound)}) {  in GetSubstringBound()
875 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Substring &ss) {  in Analyze()
876   if (MaybeExpr baseExpr{Analyze(std::get<parser::DataRef>(ss.t))}) {  in Analyze()
878       if (MaybeExpr newBaseExpr{Designate(std::move(*dataRef))}) {  in Analyze()
906 MaybeExpr ExpressionAnalyzer::Analyze(  in Analyze()
913   if (MaybeExpr string{Analyze(std::get<parser::CharLiteralConstant>(x.t))}) {  in Analyze()
926           [&](auto &&ckExpr) -> MaybeExpr {  in Analyze()
947 MaybeExpr ExpressionAnalyzer::Analyze(const parser::SubstringInquiry &x) {  in Analyze()
948   if (MaybeExpr substring{Analyze(x.v)}) {  in Analyze()
963     MaybeExpr &&expr) {  in AsSubscript()
1035 MaybeExpr ExpressionAnalyzer::Analyze(const parser::ArrayElement &ae) {  in Analyze()
1036   MaybeExpr baseExpr;  in Analyze()
1117 MaybeExpr ExpressionAnalyzer::Analyze(const parser::StructureComponent &sc) {  in Analyze()
1118   MaybeExpr base{Analyze(sc.base)};  in Analyze()
1195 MaybeExpr ExpressionAnalyzer::Analyze(const parser::CoindexedNamedObject &x) {  in Analyze()
1224       MaybeExpr coex{Analyze(cosub)};  in Analyze()
1304   MaybeExpr ToExpr();
1309   using Result = MaybeExpr;
1336   void Push(MaybeExpr &&);
1347     if (MaybeExpr y{exprAnalyzer_.Analyze(x)}) {  in GetSpecificIntExpr()
1366 void ArrayConstructorContext::Push(MaybeExpr &&x) {  in Push()
1627 MaybeExpr ArrayConstructorContext::ToExpr() {  in ToExpr()
1631 MaybeExpr ExpressionAnalyzer::Analyze(const parser::ArrayConstructor &array) {  in Analyze()
1640 MaybeExpr ExpressionAnalyzer::Analyze(  in Analyze()
1696     MaybeExpr value{Analyze(expr)};  in Analyze()
1819         } else if (MaybeExpr converted{  in Analyze()
1991   if (MaybeExpr base{Analyze(sc.base)}) {  in AnalyzeProcedureComponentRef()
2466 MaybeExpr ExpressionAnalyzer::Analyze(const parser::FunctionReference &funcRef,  in Analyze()
2582     MaybeExpr lhs{Analyze(std::get<parser::DataRef>(x.t))};  in Analyze()
2583     MaybeExpr rhs{Analyze(std::get<parser::Expr>(x.t))};  in Analyze()
2678 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Parentheses &x) {  in Analyze()
2679   if (MaybeExpr operand{Analyze(x.v.value())}) {  in Analyze()
2693 static MaybeExpr NumericUnaryHelper(ExpressionAnalyzer &context,  in NumericUnaryHelper()
2713 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::UnaryPlus &x) {  in Analyze()
2717 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Negate &x) {  in Analyze()
2728 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::NOT &x) {  in Analyze()
2744 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::PercentLoc &x) {  in Analyze()
2751   } else if (MaybeExpr argExpr{Analyze(x.v.value())}) {  in Analyze()
2763 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::DefinedUnary &x) {  in Analyze()
2774 MaybeExpr NumericBinaryHelper(ExpressionAnalyzer &context, NumericOperator opr,  in NumericBinaryHelper()
2794 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Power &x) {  in Analyze()
2798 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Multiply &x) {  in Analyze()
2802 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Divide &x) {  in Analyze()
2806 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Add &x) {  in Analyze()
2810 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Subtract &x) {  in Analyze()
2814 MaybeExpr ExpressionAnalyzer::Analyze(  in Analyze()
2825 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::Concat &x) {  in Analyze()
2833           [&](auto &&x, auto &&y) -> MaybeExpr {  in Analyze()
2854 MaybeExpr ExpressionAnalyzer::AnalyzeDefinedOp(  in AnalyzeDefinedOp()
2866 MaybeExpr RelationHelper(ExpressionAnalyzer &context, RelationalOperator opr,  in RelationHelper()
2892 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::LT &x) {  in Analyze()
2896 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::LE &x) {  in Analyze()
2900 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::EQ &x) {  in Analyze()
2904 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::NE &x) {  in Analyze()
2908 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::GE &x) {  in Analyze()
2912 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::GT &x) {  in Analyze()
2916 MaybeExpr LogicalBinaryHelper(ExpressionAnalyzer &context, LogicalOperator opr,  in LogicalBinaryHelper()
2935 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::AND &x) {  in Analyze()
2939 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::OR &x) {  in Analyze()
2943 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::EQV &x) {  in Analyze()
2947 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::NEQV &x) {  in Analyze()
2951 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr::DefinedBinary &x) {  in Analyze()
3044 MaybeExpr ExpressionAnalyzer::ExprOrVariable(  in ExprOrVariable()
3059   MaybeExpr result;  in ExprOrVariable()
3099 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr &expr) {  in Analyze()
3103 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Variable &variable) {  in Analyze()
3107 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Selector &selector) {  in Analyze()
3120         if (MaybeExpr result{Analyze(funcRef->value(), &ctor)}) {  in Analyze()
3145 MaybeExpr ExpressionAnalyzer::Analyze(const parser::DataStmtConstant &x) {  in Analyze()
3150 MaybeExpr ExpressionAnalyzer::Analyze(const parser::AllocateObject &x) {  in Analyze()
3154 MaybeExpr ExpressionAnalyzer::Analyze(const parser::PointerObject &x) {  in Analyze()
3168             if (MaybeExpr kind{Analyze(x)}) {  in AnalyzeKindSelector()
3267     const MaybeExpr &result, TypeCategory category, bool defaultKind) {  in EnforceTypeConstraint()
3293 MaybeExpr ExpressionAnalyzer::MakeFunctionRef(parser::CharBlock callSite,  in MakeFunctionRef()
3326 MaybeExpr ExpressionAnalyzer::MakeFunctionRef(  in MakeFunctionRef()
3341   if (MaybeExpr expr{context_.Analyze(x)}) {  in Analyze()
3495 MaybeExpr ArgumentAnalyzer::TryDefinedOp(const char *opr,  in TryDefinedOp()
3522         if (MaybeExpr result{TryBoundOp(*symbol, passIndex)}) {  in TryDefinedOp()
3542 MaybeExpr ArgumentAnalyzer::TryDefinedOp(  in TryDefinedOp()
3554 MaybeExpr ArgumentAnalyzer::TryBoundOp(const Symbol &symbol, int passIndex) {  in TryBoundOp()
3690   } else if (MaybeExpr argExpr{AnalyzeExprOrWholeAssumedSizeArray(expr)}) {  in AnalyzeExpr()
3703 MaybeExpr ArgumentAnalyzer::AnalyzeExprOrWholeAssumedSizeArray(  in AnalyzeExprOrWholeAssumedSizeArray()
3784       MaybeExpr realExpr{  in ConvertBOZ()
3790       MaybeExpr intExpr{  in ConvertBOZ()