set_lhsType(TypeAndShape::Characterize(lhs, context));
set_isContiguous(lhs.attrs().test(Attr::CONTIGUOUS));
set_isVolatile(lhs.attrs().test(Attr::VOLATILE));
- if (IsProcedure(lhs)) {
- procedure_ = Procedure::Characterize(lhs, context);
- }
}
PointerAssignmentChecker &set_lhsType(std::optional<TypeAndShape> &&);
PointerAssignmentChecker &set_isContiguous(bool);
bool Check(const SomeExpr &);
private:
+ bool CharacterizeProcedure();
template <typename T> bool Check(const T &);
template <typename T> bool Check(const evaluate::Expr<T> &);
template <typename T> bool Check(const evaluate::FunctionRef<T> &);
const Symbol *lhs_{nullptr};
std::optional<TypeAndShape> lhsType_;
std::optional<Procedure> procedure_;
+ bool characterizedProcedure_{false};
bool isContiguous_{false};
bool isVolatile_{false};
bool isBoundsRemapping_{false};
return *this;
}
+bool PointerAssignmentChecker::CharacterizeProcedure() {
+ if (!characterizedProcedure_) {
+ characterizedProcedure_ = true;
+ if (lhs_ && IsProcedure(*lhs_)) {
+ procedure_ = Procedure::Characterize(*lhs_, context_);
+ }
+ }
+ return procedure_.has_value();
+}
+
template <typename T> bool PointerAssignmentChecker::Check(const T &) {
// Catch-all case for really bad target expression
Say("Target associated with %s must be a designator or a call to a"
if (!funcResult) {
msg = "%s is associated with the non-existent result of reference to"
" procedure"_err_en_US;
- } else if (procedure_) {
+ } else if (CharacterizeProcedure()) {
// Shouldn't be here in this function unless lhs is an object pointer.
msg = "Procedure %s is associated with the result of a reference to"
" function '%s' that does not return a procedure pointer"_err_en_US;
return false;
}
std::optional<std::variant<MessageFixedText, MessageFormattedText>> msg;
- if (procedure_) {
+ if (CharacterizeProcedure()) {
// Shouldn't be here in this function unless lhs is an object pointer.
msg = "In assignment to procedure %s, the target is not a procedure or"
" procedure pointer"_err_en_US;
const Procedure *rhsProcedure,
const evaluate::SpecificIntrinsic *specific) {
std::string whyNot;
+ CharacterizeProcedure();
if (std::optional<MessageFixedText> msg{evaluate::CheckProcCompatibility(
isCall, procedure_, rhsProcedure, specific, whyNot)}) {
Say(std::move(*msg), description_, rhsName, whyNot);