Dyno resolve tuple AssociatedActions per-component

frontend/include/chpl/framework/mark-functions.h

@@ -99,6 +99,15 @@ template<typename T, size_t i> struct mark<llvm::SmallVector<T, i>> {
   }
 };
 
+template<typename T, size_t i> struct mark<llvm::SmallVector<T*, i>> {
+  void operator()(Context* context, const llvm::SmallVector<T*, i>& keep) const {
+    for (auto const &elt : keep) {
+      chpl::mark<T> marker;
+      marker(context, elt);
+    }
+  }
+};
+
 template<typename T> struct mark<chpl::optional<T>> {
   void operator()(Context* context, const chpl::optional<T>& keep) const {
     if (keep) {

frontend/include/chpl/resolution/copy-elision.h

@@ -24,12 +24,13 @@
 #include "chpl/resolution/resolution-types.h"
 
 #include <set>
+#include <unordered_map>
 
 namespace chpl {
 namespace resolution {
 
 
-/* Computes the set of IDs of initialization points
+/* Computes the IDs of initialization points
    that can be 'move's rather than '=' or 'copy-init'.
      * If the elided initialization point is a variable initialization expr,
        the ID of the initialized variable is stored in the set.
@@ -40,14 +41,17 @@ namespace resolution {
      * If the elided initialization point is a 'yield' statement, the
        ID of the 'yield' is stored in the set.
 
+   The value corresponding to the ID key is the ID of the init part being moved
+   from.
+
    Does not consider copy elision that only work with temporary
    variables (e.g. acceptsWithIn(returnsByValue())).
 
    This is not a query. It may raise errors within the currently running query.
 
    allSplitInitedVars can be computed by computeSplitInits.
  */
-std::set<ID>
+std::unordered_map<ID, ID>
 computeElidedCopies(Context* context,
                     const uast::AstNode* symbol,
                     const ResolutionResultByPostorderID& byPostorder,

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

@@ -2569,22 +2569,41 @@ class AssociatedAction {
     TUPLE_CAST,
   };
 
+  using ActionsList = llvm::SmallVector<const AssociatedAction*>;
+
  private:
   Action action_;
   const TypedFnSignature* fn_;
   ID id_;
   types::QualifiedType type_;
 
+  // An index associated with some tuple per-element actions, where it is
+  // necessary to keep track of which tuple element the action applies to.
+  // The sentinel value of -1 indicates no associated tuple element.
+  int tupleEltIdx_ = -1;
+
+  // A list of actions contained within this one.
+  // Currently only used for tuple copy-init-deinit, where each element may
+  // have a sub-action.
+  ActionsList subActions_;
+
  public:
   AssociatedAction(Action action, const TypedFnSignature* fn, ID id,
-                   types::QualifiedType type)
-    : action_(action), fn_(fn), id_(id), type_(type) {
-  }
+                   types::QualifiedType type, int tupleEltIdx = -1,
+                   ActionsList subActions = {})
+      : action_(action),
+        fn_(fn),
+        id_(id),
+        type_(type),
+        tupleEltIdx_(tupleEltIdx),
+        subActions_(std::move(subActions)) {}
   bool operator==(const AssociatedAction& other) const {
     return action_ == other.action_ &&
            fn_ == other.fn_ &&
            id_ == other.id_ &&
-           type_ == other.type_;
+           type_ == other.type_ &&
+           tupleEltIdx_ == other.tupleEltIdx_ &&
+           subActions_ == other.subActions_;
   }
   bool operator!=(const AssociatedAction& other) const {
     return !(*this == other);
@@ -2600,15 +2619,40 @@ class AssociatedAction {
 
   const types::QualifiedType type() const { return type_; }
 
+  bool hasTupleEltIdx() const {
+    return tupleEltIdx_ != -1;
+  }
+
+  const int tupleEltIndex() const {
+    CHPL_ASSERT(hasTupleEltIdx());
+    return tupleEltIdx_;
+  }
+
+  const ActionsList& subActions() const {
+    return subActions_;
+  }
+
+  size_t hash() const {
+    return chpl::hash(action_, fn_, id_, type_, tupleEltIdx_, subActions_);
+  }
+
   void mark(Context* context) const {
     if (fn_ != nullptr) fn_->mark(context);
     id_.mark(context);
     type_.mark(context);
+    chpl::mark<decltype(tupleEltIdx_)>{}(context, tupleEltIdx_);
+    for (const auto& subAction : subActions_) {
+      subAction->mark(context);
+    }
   }
 
   void stringify(std::ostream& ss, chpl::StringifyKind stringKind) const;
 
   static const char* kindToString(Action a);
+
+  /// \cond DO_NOT_DOCUMENT
+  DECLARE_DUMP;
+  /// \endcond DO_NOT_DOCUMENT
 };
 
 class ResolvedParamLoop;
@@ -2729,12 +2773,20 @@ class ResolvedExpression {
   /** set the point-of-instantiation scope */
   void setPoiScope(const PoiScope* poiScope) { poiScope_ = poiScope; }
 
-  /** add an associated function */
+  /** remove all associated actions */
+  void clearAssociatedActions() {
+    associatedActions_.clear();
+  }
+
+  /** add an associated action */
   void addAssociatedAction(AssociatedAction::Action action,
                            const TypedFnSignature* fn,
                            ID id,
                            types::QualifiedType type) {
-    associatedActions_.push_back(AssociatedAction(action, fn, id, type));
+    addAssociatedAction(AssociatedAction(action, fn, id, type));
+  }
+  void addAssociatedAction(AssociatedAction action) {
+    associatedActions_.push_back(action);
   }
 
   void setParamLoop(const ResolvedParamLoop* paramLoop) { paramLoop_ = paramLoop; }
@@ -3689,6 +3741,7 @@ CHPL_DEFINE_STD_HASH_(MostSpecificCandidate, (key.hash()));
 CHPL_DEFINE_STD_HASH_(MostSpecificCandidates, (key.hash()));
 CHPL_DEFINE_STD_HASH_(CallResolutionResult, (key.hash()));
 CHPL_DEFINE_STD_HASH_(TheseResolutionResult, (key.hash()));
+CHPL_DEFINE_STD_HASH_(AssociatedAction, (key.hash()));
 CHPL_DEFINE_STD_HASH_(ResolvedFields, (key.hash()));
 CHPL_DEFINE_STD_HASH_(FieldDetail, (key.hash()));
 CHPL_DEFINE_STD_HASH_(ForwardingDetail, (key.hash()));

frontend/include/chpl/uast/TupleDecl.h

@@ -187,7 +187,7 @@ class TupleDecl final : public Decl {
   const Decl* decl(int i) const {
     CHPL_ASSERT(i >= 0 && i < numDecls());
     const AstNode* ast = this->child(i);
-    CHPL_ASSERT(ast->isVariable() || ast->isTupleDecl());
+    CHPL_ASSERT(ast->isVariable() || ast->isFormal() || ast->isTupleDecl());
     CHPL_ASSERT(ast->isDecl());
     return (const Decl*)ast;
   }

frontend/lib/resolution/InitResolver.cpp

@@ -1021,6 +1021,8 @@ bool InitResolver::handleAssignmentToField(const OpCall* node) {
   auto lhs = node->actual(0);
   auto rhs = node->actual(1);
 
+  // TODO: handle assignment to field(s) via tuple destructuring
+
   // TODO: Is 'field' or 'this.field' too strict of a pattern?
   auto [fieldId, isSuperField] = fieldIdFromPossibleMentionOfField(lhs);
 

frontend/lib/resolution/Resolver.cpp

@@ -3251,6 +3251,17 @@ bool Resolver::resolveSpecialOpCall(const Call* call) {
     if (op->numActuals() == 2) {
       // Update a generic/unknown type when split-init is used.
       adjustTypesOnAssign(op->actual(0), op->actual(1));
+
+      if (auto lhsTuple = op->actual(0)->toTuple()) {
+        auto rhsQt = byPostorder.byAst(op->actual(1)).type();
+        if (auto rhsTupleType = rhsQt.type()->toTupleType()) {
+          if (lhsTuple->numActuals() != rhsTupleType->numElements()) {
+            context->error(call, "tuple size mismatch in split tuple assign");
+            byPostorder.byAst(call).setType(QualifiedType(
+                QualifiedType::UNKNOWN, ErroneousType::get(context)));
+          }
+        }
+      }
     }
   } else if (op->op() == USTR("...")) {
     // just leave it unknown -- tuple expansion only makes sense