Store when-statement case type normally, store bool in AssociatedAction

Previously we were storing the boolean result of a when-statement's '=='
operator in the ResolvedExpression for the case-expression. This was
inconsistent with how we do things elsewhere, and caused complications
in the typed converter.

This commit adds a QualifiedType to AssociatedActions and stores the
boolean result there. Storing this result is particularly important in
the case where it is param-true or param-false.

This commit also adds a 'getAction' method to ResolvedExpression to
facilitate fetching the 'COMPARE' action.

Signed-off-by: Ben Harshbarger <[email protected]>

Author: benharsh

frontend/include/chpl/resolution/resolution-types.h

@@ -2378,15 +2378,18 @@ class AssociatedAction {
   Action action_;
   const TypedFnSignature* fn_;
   ID id_;
+  types::QualifiedType type_;
 
  public:
-  AssociatedAction(Action action, const TypedFnSignature* fn, ID id)
-    : action_(action), fn_(fn), id_(id) {
+  AssociatedAction(Action action, const TypedFnSignature* fn, ID id,
+                   types::QualifiedType type)
+    : action_(action), fn_(fn), id_(id), type_(type) {
   }
   bool operator==(const AssociatedAction& other) const {
     return action_ == other.action_ &&
            fn_ == other.fn_ &&
-           id_ == other.id_;
+           id_ == other.id_ &&
+           type_ == other.type_;
   }
   bool operator!=(const AssociatedAction& other) const {
     return !(*this == other);
@@ -2400,9 +2403,12 @@ class AssociatedAction {
   /** Return the ID is associated with the action */
   const ID& id() const { return id_; }
 
+  const types::QualifiedType type() const { return type_; }
+
   void mark(Context* context) const {
     if (fn_ != nullptr) fn_->mark(context);
     id_.mark(context);
+    type_.mark(context);
   }
 
   void stringify(std::ostream& ss, chpl::StringifyKind stringKind) const;
@@ -2478,6 +2484,19 @@ class ResolvedExpression {
     return associatedActions_;
   }
 
+  // TODO: Expected to be a placeholder as we look towards updating the
+  // representation of associated actions.
+  std::optional<AssociatedAction> getAction(AssociatedAction::Action action) const {
+    // TODO: what if there are multiple instances of the same action?
+    auto it = std::find_if(associatedActions_.begin(), associatedActions_.end(),
+                [&](const AssociatedAction a) { return a.action() == action; });
+    if (it != associatedActions_.end()) {
+      return *it;
+    } else {
+      return {};
+    }
+  }
+
   const ResolvedParamLoop* paramLoop() const {
     return paramLoop_;
   }
@@ -2505,8 +2524,9 @@ class ResolvedExpression {
   /** add an associated function */
   void addAssociatedAction(AssociatedAction::Action action,
                            const TypedFnSignature* fn,
-                           ID id) {
-    associatedActions_.push_back(AssociatedAction(action, fn, id));
+                           ID id,
+                           types::QualifiedType type) {
+    associatedActions_.push_back(AssociatedAction(action, fn, id, type));
   }
 
   void setParamLoop(const ResolvedParamLoop* paramLoop) { paramLoop_ = paramLoop; }

frontend/lib/resolution/Resolver.cpp

@@ -681,11 +681,11 @@ const types::Param* Resolver::determineWhenCaseValue(const uast::AstNode* ast, I
                       /* hasQuestionArg */ false,
                       /* isParenless */ false,
                       actuals);
-  auto c = resolveGeneratedCall(ast, &ci, &inScopes);
-  c.noteResult(&caseResult, { { AssociatedAction::COMPARE, ast->id() } });
 
+  auto c = resolveGeneratedCall(ast, &ci, &inScopes);
   auto type = c.result.exprType();
-  caseResult.setType(type);
+  c.noteResult(&caseResult, { { AssociatedAction::COMPARE, ast->id(), type } });
+
   return type.param();
 }
 
@@ -2308,7 +2308,7 @@ bool Resolver::CallResultWrapper::noteResultWithoutError(
     ResolvedExpression* r,
     const uast::AstNode* astForContext,
     const CallResolutionResult& result,
-    optional<ActionAndId> actionAndId) {
+    optional<ActionInfo> actionInfo) {
   bool needsErrors = false;
   bool markErroneous = false;
 
@@ -2339,7 +2339,7 @@ bool Resolver::CallResultWrapper::noteResultWithoutError(
   }
 
   if (!result.exprType().hasTypePtr() || markErroneous) {
-    if (!actionAndId && r) {
+    if (!actionInfo && r) {
       // Only set the type to erroneous if we're handling an actual user call,
       // and not an associated action.
       r->setType(QualifiedType(r->type().kind(), ErroneousType::get(resolver.context)));
@@ -2350,12 +2350,22 @@ bool Resolver::CallResultWrapper::noteResultWithoutError(
     // issued its own error, so we shouldn't emit a general error.
     return !result.speciallyHandled() || needsErrors;
   } else {
-    if (actionAndId) {
+    if (actionInfo) {
       // save candidates as associated functions
-      for (auto& sig : result.mostSpecific()) {
-        if (sig && r) {
-          r->addAssociatedAction(std::get<0>(*actionAndId), sig.fn(),
-                                 std::get<1>(*actionAndId));
+      if (result.mostSpecific().isEmpty() && r) {
+        // Store an associated action that did not have a function.
+        // E.g., 'COMPARE' for a when-statement condition that is param-true
+        r->addAssociatedAction(actionInfo->action, nullptr,
+                               actionInfo->id, actionInfo->type);
+      } else {
+        bool seen = false;
+        for (auto& sig : result.mostSpecific()) {
+          if (sig && r) {
+            CHPL_ASSERT(!seen);
+            seen = true;
+            r->addAssociatedAction(actionInfo->action, sig.fn(),
+                                   actionInfo->id, actionInfo->type);
+          }
         }
       }
     } else if (r) {
@@ -2372,13 +2382,13 @@ bool Resolver::CallResultWrapper::noteResultWithoutError(
 
 
 bool Resolver::CallResultWrapper::noteResultWithoutError(ResolvedExpression* r,
-                                                          optional<ActionAndId> actionAndId) {
-  return noteResultWithoutError(*parent, r, astForContext, result, std::move(actionAndId));
+                                                          optional<ActionInfo> actionInfo) {
+  return noteResultWithoutError(*parent, r, astForContext, result, std::move(actionInfo));
 }
 
 void Resolver::CallResultWrapper::noteResult(ResolvedExpression* r,
-                                              optional<ActionAndId> actionAndId) {
-  if (noteResultWithoutError(r, std::move(actionAndId))) {
+                                              optional<ActionInfo> actionInfo) {
+  if (noteResultWithoutError(r, std::move(actionInfo))) {
     issueBasicError();
   }
 }
@@ -2414,9 +2424,9 @@ bool Resolver::CallResultWrapper::rerunCallAndPrintCandidates() {
 }
 
 void Resolver::CallResultWrapper::noteResultPrintCandidates(ResolvedExpression* r,
-                                                             optional<ActionAndId> actionAndId) {
+                                                             optional<ActionInfo> actionInfo) {
   CHPL_ASSERT(!wasGeneratedCall || receiverType.isUnknown());
-  if (noteResultWithoutError(r, std::move(actionAndId))) {
+  if (noteResultWithoutError(r, std::move(actionInfo))) {
     if (rerunCallAndPrintCandidates()) {
       return;
     }
@@ -2792,7 +2802,7 @@ bool Resolver::resolveSpecialNewCall(const Call* call) {
 
   // note: the resolution machinery will get compiler generated candidates
   auto c = resolveGeneratedCall(call, &ci, &inScopes);
-  optional<ActionAndId> action({ AssociatedAction::NEW_INIT, call->id() });
+  optional<ActionInfo> action({ AssociatedAction::NEW_INIT, call->id() });
   c.noteResultPrintCandidates(&re, std::move(action));
 
 
@@ -3221,7 +3231,7 @@ bool Resolver::resolveSpecialKeywordCall(const Call* call) {
 
       // Note: this issues errors from compilerError in the body of the
       // domain builder.
-      optional<ActionAndId> action({ AssociatedAction::RUNTIME_TYPE, fnCall->id() });
+      optional<ActionInfo> action({ AssociatedAction::RUNTIME_TYPE, fnCall->id() });
       bool needsErrors =
         runResult.result().noteResultWithoutError(&r, std::move(action));
 
@@ -4717,8 +4727,8 @@ bool Resolver::enter(const uast::Manage* manage) {
       }
     }
     CHPL_ASSERT(enterSig && exitSig);
-    rr.addAssociatedAction(AssociatedAction::ENTER_CONTEXT, enterSig, manage->id());
-    rr.addAssociatedAction(AssociatedAction::EXIT_CONTEXT, exitSig, manage->id());
+    rr.addAssociatedAction(AssociatedAction::ENTER_CONTEXT, enterSig, manage->id(), {});
+    rr.addAssociatedAction(AssociatedAction::EXIT_CONTEXT, exitSig, manage->id(), {});
   }
 
   enterScope(manage);
@@ -5228,7 +5238,7 @@ rerunCallInfoWithIteratorTag(ResolutionContext* rc,
   if (!newC.mostSpecific().isEmpty()) {
     for (auto sig : newC.mostSpecific()) {
       if (!sig) continue;
-      r.addAssociatedAction(AssociatedAction::ITERATE, sig.fn(), call->id());
+      r.addAssociatedAction(AssociatedAction::ITERATE, sig.fn(), call->id(), {});
     }
 
     return newC;

frontend/lib/resolution/Resolver.h

@@ -37,7 +37,13 @@ namespace resolution {
 
 struct Resolver : BranchSensitiveVisitor<DefaultFrame> {
   // types used below
-  using ActionAndId = std::tuple<AssociatedAction::Action, ID>;
+  //using ActionInfo = std::tuple<AssociatedAction::Action, ID, types::QualifiedType>;
+  struct ActionInfo {
+    public:
+      AssociatedAction::Action action;
+      ID id;
+      types::QualifiedType type;
+  };
   using SubstitutionsMap = types::CompositeType::SubstitutionsMap;
   using ReceiverScopesVec = SimpleMethodLookupHelper::ReceiverScopesVec;
   using IgnoredExtraData = std::variant<std::monostate>;
@@ -527,17 +533,17 @@ struct Resolver : BranchSensitiveVisitor<DefaultFrame> {
     //
     // Instead, returns 'true' if an error needs to be issued.
     bool noteResultWithoutError(ResolvedExpression* r,
-                                optional<ActionAndId> associatedActionAndId = {});
+                                optional<ActionInfo> associatedActionInfo = {});
 
     static bool noteResultWithoutError(Resolver& resolver,
                                        ResolvedExpression* r,
                                        const uast::AstNode* astForContext,
                                        const CallResolutionResult& c,
-                                       optional<ActionAndId> associatedActionAndId = {});
+                                       optional<ActionInfo> associatedActionInfo = {});
 
     // Same as noteResultWithoutError, but also issues errors.
     void noteResult(ResolvedExpression* r,
-                    optional<ActionAndId> associatedActionAndId = {});
+                    optional<ActionInfo> associatedActionInfo = {});
 
     // Issues a more specific error (listing rejected candidates) if possible.
     // To collect the candidates, re-runs the call. Returns true if an error
@@ -547,7 +553,7 @@ struct Resolver : BranchSensitiveVisitor<DefaultFrame> {
     // Like noteResult, except attempts to do more work to print fancier errors
     // (see rerunCallAndPrintCandidates).
     void noteResultPrintCandidates(ResolvedExpression* r,
-                                   optional<ActionAndId> associatedActionAndId = {});
+                                     optional<ActionInfo> associatedActionInfo = {});
   };
 
   /* The resolver's wrapper of resolution::resolveGeneratedCall.

frontend/lib/resolution/VarScopeVisitor.cpp

@@ -211,7 +211,10 @@ static const types::Param* determineParamValue(const ResolvedExpression& rr) {
 }
 
 const types::Param* VarScopeVisitor::determineWhenCaseValue(const uast::AstNode* ast, RV& extraData) {
-  return determineParamValue(extraData.byAst(ast));
+  if (auto action = extraData.byAst(ast).getAction(AssociatedAction::COMPARE)) {
+    return action->type().param();
+  }
+  return nullptr;
 }
 
 const types::Param* VarScopeVisitor::determineIfValue(const uast::AstNode* ast, RV& extraData) {

frontend/lib/resolution/resolution-types.cpp

@@ -1364,6 +1364,10 @@ void AssociatedAction::stringify(std::ostream& ss,
     ss << " id=";
     id_.stringify(ss, stringKind);
   }
+  if (!type_.isUnknown()) {
+    ss << " type=";
+    type_.stringify(ss, stringKind);
+  }
 }
 
 void ResolvedExpression::stringify(std::ostream& ss,

frontend/lib/resolution/return-type-inference.cpp

@@ -499,7 +499,11 @@ void ReturnTypeInferrer::doExitScope(const uast::AstNode* node, RV& rv) {
 }
 
 const types::Param* ReturnTypeInferrer::determineWhenCaseValue(const uast::AstNode* ast, RV& rv) {
-  return rv.byAst(ast).type().param();
+  if (auto action = rv.byAst(ast).getAction(AssociatedAction::COMPARE)) {
+    return action->type().param();
+  } else {
+    return nullptr;
+  }
 }
 const types::Param* ReturnTypeInferrer::determineIfValue(const uast::AstNode* ast, RV& rv) {
   return rv.byAst(ast).type().param();