Handle in/inout formals when promotion occurs in call-init-deinit etc.

Prior to this commit, call-init-deinit would always resolve
`init=` or `=` using the exact type of the actual. This
is not the appropriate thing to do when promotion is involved,
since it's the yielded type / scalar type that's being copied.
This commit adjusts VarScopeVisitor's API to behave properly
in this case (including, but not limited to, disabling
copy elision for promoted calls)

Signed-off-by: Danila Fedorin <[email protected]>

Author: DanilaFe

frontend/lib/resolution/Resolver.cpp

@@ -2548,12 +2548,18 @@ void Resolver::adjustTypesOnAssign(const AstNode* lhsAst,
 void
 Resolver::adjustTypesForOutFormals(const CallInfo& ci,
                                    const std::vector<const AstNode*>& asts,
-                                   const MostSpecificCandidates& fns) {
+                                   const CallResolutionResult& crr) {
 
+  const PromotionIteratorType* promotionCtx = nullptr;
+  if (!crr.exprType().isUnknownOrErroneous()) {
+    promotionCtx = crr.exprType().type()->toPromotionIteratorType();
+  }
   std::vector<QualifiedType> actualFormalTypes;
   std::vector<Qualifier> actualIntents;
-  computeActualFormalIntents(context, fns, ci, asts,
-                             actualIntents, actualFormalTypes);
+  std::vector<bool> actualPromoted;
+  computeActualFormalIntents(context, crr.mostSpecific(), ci, asts,
+                             actualIntents, actualFormalTypes, actualPromoted,
+                             promotionCtx);
 
   int actualIdx = 0;
   for (const auto& actual : ci.actuals()) {
@@ -5560,7 +5566,7 @@ void Resolver::handleCallExpr(const uast::Call* call) {
     c.noteResultPrintCandidates(&r);
 
     // handle type inference for variables split-inited by 'out' formals
-    adjustTypesForOutFormals(ci, actualAsts, c.result.mostSpecific());
+    adjustTypesForOutFormals(ci, actualAsts, c.result);
 
     // issue errors for iterator groups where e.g. serial/standalone types mismatch
     issueIteratorDiagnosticsIfNeeded(*this, call, inScopes, c.result);

frontend/lib/resolution/Resolver.h

@@ -602,7 +602,7 @@ struct Resolver : BranchSensitiveVisitor<DefaultFrame> {
   // handles setting types of variables for split init with 'out' formals
   void adjustTypesForOutFormals(const CallInfo& ci,
                                 const std::vector<const uast::AstNode*>& asts,
-                                const MostSpecificCandidates& fns);
+                                const CallResolutionResult& crr);
 
   // helper for resolveTupleDecl
   // e.g. var (a, b) = mytuple

frontend/lib/resolution/VarScopeVisitor.cpp

@@ -21,6 +21,7 @@
 
 #include "chpl/parsing/parsing-queries.h"
 #include "chpl/resolution/ResolvedVisitor.h"
+#include "chpl/resolution/resolution-queries.h"
 #include "chpl/resolution/resolution-types.h"
 #include "chpl/resolution/scope-queries.h"
 #include "chpl/uast/all-uast.h"
@@ -404,13 +405,34 @@ bool VarScopeVisitor::enter(const FnCall* callAst, RV& rv) {
       actualAsts.insert(actualAsts.begin(), nullptr);
     }
 
+
     // compute a vector indicating which actuals are passed to
     // an 'out' formal in all return intent overloads
+    const PromotionIteratorType* promoCtx = nullptr;
+    if (!rr->type().isUnknownOrErroneous()) {
+      promoCtx = rr->type().type()->toPromotionIteratorType();
+    }
     std::vector<QualifiedType> actualFormalTypes;
     std::vector<Qualifier> actualFormalIntents;
+    std::vector<bool> actualPromoted;
     computeActualFormalIntents(context, candidates, ci, actualAsts,
-                               actualFormalIntents, actualFormalTypes);
-
+                               actualFormalIntents, actualFormalTypes,
+                               actualPromoted, promoCtx);
+
+    // for a given actual index, returns:
+    // * nullptr if no promotion ocurred
+    // * the scalar type of the given actual was used in promotion
+    // * the actual type itself if it was not
+    // This can be used to signal to handleInFormal() etc. to adjust
+    // their behavior for promotion, and to provide the additional information
+    // of the scalar type.
+    auto getScalarType = [&](int idx) {
+      auto& actualQt = ci.actual(idx).type();
+      return
+        promoCtx == nullptr ? nullptr :
+        actualPromoted[idx] ? &getPromotionType(context, actualQt) :
+        &actualQt;
+    };
     int actualIdx = 0;
     for (auto actual : ci.actuals()) {
       (void) actual; // avoid compilation error about unused variable
@@ -428,11 +450,12 @@ bool VarScopeVisitor::enter(const FnCall* callAst, RV& rv) {
                  !(ci.name() == "init" && actualIdx == 0)) {
         // don't do this for the 'this' argument to 'init', because it
         // is not getting copied.
+
         handleInFormal(callAst, actualAst,
-                       actualFormalTypes[actualIdx], rv);
+                       actualFormalTypes[actualIdx], getScalarType(actualIdx), rv);
       } else if (kind == Qualifier::INOUT) {
         handleInoutFormal(callAst, actualAst,
-                          actualFormalTypes[actualIdx], rv);
+                          actualFormalTypes[actualIdx], getScalarType(actualIdx), rv);
       } else {
         // otherwise, visit the actuals to gather mentions
         actualAst->traverse(rv);
@@ -576,13 +599,17 @@ computeActualFormalIntents(Context* context,
                            const CallInfo& ci,
                            const std::vector<const AstNode*>& actualAsts,
                            std::vector<Qualifier>& actualFormalIntents,
-                           std::vector<QualifiedType>& actualFormalTypes) {
+                           std::vector<QualifiedType>& actualFormalTypes,
+                           std::vector<bool>& actualPromoted,
+                           const types::PromotionIteratorType* promoCtx) {
 
   int nActuals = ci.numActuals();
   actualFormalIntents.clear();
   actualFormalIntents.resize(nActuals);
   actualFormalTypes.clear();
   actualFormalTypes.resize(nActuals);
+  actualPromoted.clear();
+  actualPromoted.resize(nActuals);
 
   int nFns = candidates.numBest();
   if (nFns == 0) {
@@ -599,6 +626,12 @@ computeActualFormalIntents(Context* context,
         auto intent  = normalizeFormalIntent(fa->formalType().kind());
         QualifiedType& aft = actualFormalTypes[actualIdx];
 
+        // all actualPromoted are guaranteed to be the same IF all the
+        // formal types are guaranteed to be the same, which they are
+        // using the checks below.
+        actualPromoted[actualIdx] =
+          promoCtx && promoCtx->promotedFormals().count(fa->formal()->id()) > 0;
+
         if (firstCandidate) {
           actualFormalIntents[actualIdx] = intent;
           if (intent != Qualifier::UNKNOWN) {

frontend/lib/resolution/VarScopeVisitor.h

@@ -80,11 +80,13 @@ class VarScopeVisitor : public BranchSensitiveVisitor<VarFrame, MutatingResolved
   virtual void handleInFormal(const uast::FnCall* ast,
                               const uast::AstNode* actual,
                               const types::QualifiedType& formalType,
+                              const types::QualifiedType* actualScalarType,
                               RV& rv) = 0;
   /** Called for an actual passed to an 'out' formal */
   virtual void handleInoutFormal(const uast::FnCall* ast,
                                  const uast::AstNode* actual,
                                  const types::QualifiedType& formalType,
+                                 const types::QualifiedType* actualScalarType,
                                  RV& rv) = 0;
 
   /** Called for a 'return' */
@@ -302,7 +304,9 @@ computeActualFormalIntents(Context* context,
                            const CallInfo& ci,
                            const std::vector<const AstNode*>& actualAsts,
                            std::vector<uast::Qualifier>& actualFrmlIntents,
-                           std::vector<types::QualifiedType>& actualFrmlTypes);
+                           std::vector<types::QualifiedType>& actualFrmlTypes,
+                           std::vector<bool>& actualWasPromoted,
+                           const types::PromotionIteratorType* promoCtx);
 
 } // end namespace resolution
 

frontend/lib/resolution/call-init-deinit.cpp

@@ -131,9 +131,11 @@ struct CallInitDeinit : VarScopeVisitor {
                        RV& rv) override;
   void handleInFormal(const FnCall* ast, const AstNode* actual,
                       const QualifiedType& formalType,
+                      const QualifiedType* actualScalarType,
                       RV& rv) override;
   void handleInoutFormal(const FnCall* ast, const AstNode* actual,
                          const QualifiedType& formalType,
+                         const QualifiedType* actualScalarType,
                          RV& rv) override;
   void handleReturn(const uast::Return* ast, RV& rv) override;
   void handleThrow(const uast::Throw* ast, RV& rv) override;
@@ -719,9 +721,10 @@ void CallInitDeinit::resolveCopyInit(const AstNode* ast,
 
   std::vector<Qualifier> intents;
   std::vector<QualifiedType> formalTypes;
+  std::vector<bool> actualPromoted;
 
   computeActualFormalIntents(context, c.result.mostSpecific(), ci, actualAsts,
-                             intents, formalTypes);
+                             intents, formalTypes, actualPromoted, /* promotionCtx */ nullptr);
 
   bool formalUsesInIntent = false;
   CHPL_ASSERT(intents.size() >= 1);
@@ -1128,6 +1131,7 @@ void CallInitDeinit::handleOutFormal(const FnCall* ast,
 }
 void CallInitDeinit::handleInFormal(const FnCall* ast, const AstNode* actual,
                                     const QualifiedType& formalType,
+                                    const QualifiedType* actualScalarType,
                                     RV& rv) {
   VarFrame* frame = currentFrame();
 
@@ -1147,6 +1151,7 @@ void CallInitDeinit::handleInFormal(const FnCall* ast, const AstNode* actual,
   if (elidedCopyFromIds.count(actual->id()) > 0 &&
       isValue(actualType.kind()) &&
       Type::needsInitDeinitCall(actualType.type())) {
+    CHPL_ASSERT(actualScalarType == nullptr);
     // it is move initialization
     resolveMoveInit(actual, actual, formalType, actualType, rv);
 
@@ -1157,13 +1162,15 @@ void CallInitDeinit::handleInFormal(const FnCall* ast, const AstNode* actual,
     CHPL_ASSERT(!actualId.isEmpty());
     frame->deinitedVars.emplace(actualId, ast->id());
   } else {
-    processInit(frame, actual, formalType, actualType, rv);
+    processInit(frame, actual, formalType,
+                actualScalarType ? *actualScalarType : actualType, rv);
   }
 }
 
 void CallInitDeinit::handleInoutFormal(const FnCall* ast,
                                        const AstNode* actual,
                                        const QualifiedType& formalType,
+                                       const QualifiedType* actualScalarType,
                                        RV& rv) {
   // check for use of deinited variables
   processMentions(actual, rv);
@@ -1172,7 +1179,8 @@ void CallInitDeinit::handleInoutFormal(const FnCall* ast,
   QualifiedType actualType = rv.byAst(actual).type();
 
   // resolve '=' for storing and writeback
-  resolveAssign(actual, actualType, formalType, rv);
+  resolveAssign(actual,
+                actualScalarType ? *actualScalarType : actualType, formalType, rv);
 }
 
 void CallInitDeinit::processReturnThrowYield(const uast::AstNode* ast, RV& rv) {

frontend/lib/resolution/copy-elision.cpp

@@ -93,9 +93,11 @@ struct FindElidedCopies : VarScopeVisitor {
                        RV& rv) override;
   void handleInFormal(const FnCall* ast, const AstNode* actual,
                       const QualifiedType& formalType,
+                      const QualifiedType* actualScalarType,
                       RV& rv) override;
   void handleInoutFormal(const FnCall* ast, const AstNode* actual,
                          const QualifiedType& formalType,
+                         const QualifiedType* actualScalarType,
                          RV& rv) override;
 
   void handleReturn(const uast::Return* ast, RV& rv) override;
@@ -345,13 +347,18 @@ void FindElidedCopies::handleOutFormal(const FnCall* ast,
 }
 void FindElidedCopies::handleInFormal(const FnCall* ast, const AstNode* actual,
                                       const QualifiedType& formalType,
+                                      const QualifiedType* actualScalarType,
                                       RV& rv) {
   // 'in' formal can be copied from another variable, and that
   // copy might need to be elided
   VarFrame* frame = currentFrame();
   ID actualToId = refersToId(actual, rv);
   bool elide = false;
-  if (!actualToId.isEmpty() && isEligibleVarInAnyFrame(actualToId)) {
+  if (actualScalarType) {
+    // cannot do copy elision across promotion, since a single actual variable
+    // feeds into several scalar formals.
+    elide = false;
+  } else if (!actualToId.isEmpty() && isEligibleVarInAnyFrame(actualToId)) {
     // check that the types are the same
     if (rv.hasId(actualToId)) {
       QualifiedType actualType = rv.byId(actualToId).type();
@@ -370,6 +377,7 @@ void FindElidedCopies::handleInFormal(const FnCall* ast, const AstNode* actual,
 void FindElidedCopies::handleInoutFormal(const FnCall* ast,
                                          const AstNode* actual,
                                          const QualifiedType& formalType,
+                                         const QualifiedType* actualScalarType,
                                          RV& rv) {
   // 'inout' can't be the RHS for an elided copy
   processMentions(actual, rv);

frontend/lib/resolution/split-init.cpp

@@ -69,9 +69,11 @@ struct FindSplitInits : VarScopeVisitor {
                        RV& rv) override;
   void handleInFormal(const FnCall* ast, const AstNode* actual,
                       const QualifiedType& formalType,
+                      const QualifiedType* actualScalarType,
                       RV& rv) override;
   void handleInoutFormal(const FnCall* ast, const AstNode* actual,
                          const QualifiedType& formalType,
+                         const QualifiedType* actualScalarType,
                          RV& rv) override;
 
   void handleReturn(const uast::Return* ast, RV& rv) override;
@@ -210,12 +212,14 @@ void FindSplitInits::handleOutFormal(const FnCall* ast, const AstNode* actual,
 
 void FindSplitInits::handleInFormal(const FnCall* ast, const AstNode* actual,
                                     const QualifiedType& formalType,
+                                    const QualifiedType* actualScalarType,
                                     RV& rv) {
   processMentions(actual, rv);
 }
 
 void FindSplitInits::handleInoutFormal(const FnCall* ast, const AstNode* actual,
                                        const QualifiedType& formalType,
+                                       const QualifiedType* actualScalarType,
                                        RV& rv) {
   processMentions(actual, rv);
 }