Dyno: support for partial type instantiations (#27861)

This PR resolves most of the issues in `test/types/partial`, __except__
`test/types/partial/formals`, which is caused by
Cray/chapel-private#7669.

We simply didn't have code written to support partial instantiations.
Previously, invoking any type constructor reset any previously applied
substitutions. Thus:

```Chapel
record triple { type fst; type snd; type thd; }

type a = triple(int, ?);
type b = a(bool, ?);
type c = b(real, ?);
```

Produced `a = triple(int, ?)`, `b = triple(bool, ?)` and `c =
triple(real, ?)`. This is not correct.

This PR makes the following adjustments.

* When a type constructor is invoked, inserts the existing substitutions
of the type into the call. This mirrors the logic for invoking `new` on
a partial instantiation. The calling code already knows when defaults
should or should not be included.
* The exception to the above is that in inheritance expressions, we for
some reason computed the type of `A` in `A(?)` as `A(A's defaults)`.
This was not needed or relied on anywhere, so I removed it.
* Detects cases in which are are invoking a type constructor, but don't
know the type. This can happen in initial signatures, where the
type-to-be-constructed its given by a preceding formal. In this case, we
know the intent to be `TYPE`, but the `Type*` is `UnknownType`. Signal
this case from `CallInfo::create`, and defer resolution to instantiation
where necessary.
* Allowed `init=`'s lhs to be partially generic. We clearly allow this
(in, e.g., `var r: R(t1, ?) = ...`).
* Allow the RHS of `init=` to be a `param`. We clearly allow this (see
`test/types/partial/initeq.chpl`).

## Testing
- [x] dyno tests
- [x] paratest
- [x] paratest --dyno-resolve-only (down to 54 failures to resolve
working programs)

Reviewed by @benharsh -- thanks!

Author: DanilaFe

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

@@ -650,14 +650,22 @@ class CallInfo {
       with the ID of the scope that should be searched for candidates.
       That is, if the call expression is 'M.f(...)' for a module 'M', then
       'moduleScopeId' will be set to the ID of the module 'M'.
+
+      This method detects calls to type constructors where the type
+      being constructed is not yet known. if 'outIncompleteTypeConstructor' is
+      provided and not 'nullptr', sets '*outIncompleteTypeConstructor' to 'true'
+      when detecting such a call. In that case, the returned CallInfo
+      should not be resolved.
+
    */
   static CallInfo create(Context* context,
                          const uast::Call* call,
                          const ResolutionResultByPostorderID& byPostorder,
                          bool raiseErrors = true,
                          std::vector<const uast::AstNode*>* actualAsts=nullptr,
                          ID* moduleScopeId=nullptr,
-                         UniqueString rename = UniqueString());
+                         UniqueString rename = UniqueString(),
+                         bool* outIncompleteTypeConstructor = nullptr);
 
   /** Construct a CallInfo by adding a method receiver argument to
       the passed CallInfo. */

frontend/lib/resolution/Resolver.cpp

@@ -3238,14 +3238,16 @@ resolveSpecialKeywordCallAsNormalCall(Resolver& rv,
                                       ResolvedExpression& noteInto) {
   auto runResult = rv.context->runAndDetectErrors([&](Context* ctx) {
     std::vector<const AstNode*> actualAsts;
+    bool isIncompleteTypeConstructor = false;
     auto ci = CallInfo::create(rv.context, innerCall, rv.byPostorder,
                                /* raiseErrors */ true,
                                /* actualAsts */ &actualAsts,
                                /* moduleScopeId */ nullptr,
-                               /* rename */ name);
+                               /* rename */ name,
+                               &isIncompleteTypeConstructor);
 
     auto skip = shouldSkipCallResolution(&rv, innerCall, actualAsts, ci);
-    if (skip != NONE) {
+    if (isIncompleteTypeConstructor || skip != NONE) {
       return CallResolutionResult::getEmpty();
     }
 
@@ -5294,11 +5296,7 @@ types::QualifiedType Resolver::typeForBooleanOp(const uast::OpCall* op) {
 }
 
 bool Resolver::enter(const Call* call) {
-  // At this time, we don't allow method calls in inheritance expressions,
-  // so we assume that there can't be overloading etc.
-  if (call != curInheritanceExpr) {
-    callNodeStack.push_back(call);
-  }
+  callNodeStack.push_back(call);
   auto op = call->toOpCall();
 
   if (op && initResolver) {
@@ -5574,17 +5572,20 @@ void Resolver::handleCallExpr(const uast::Call* call) {
 
   std::vector<const uast::AstNode*> actualAsts;
   ID moduleScopeId;
+  bool isIncompleteTypeConstructor = false;
   auto ci = CallInfo::create(context, call, byPostorder,
                              /* raiseErrors */ true,
                              &actualAsts,
-                             &moduleScopeId);
+                             &moduleScopeId,
+                             /* rename */ UniqueString(),
+                             &isIncompleteTypeConstructor);
   auto inScopes =
     moduleScopeId.isEmpty() ?
     CallScopeInfo::forNormalCall(scope, poiScope) :
     CallScopeInfo::forQualifiedCall(context, moduleScopeId, scope, poiScope);
 
   auto skip = shouldSkipCallResolution(this, call, actualAsts, ci);
-  if (!skip) {
+  if (!skip && !isIncompleteTypeConstructor) {
     ResolvedExpression& r = byPostorder.byAst(call);
     QualifiedType receiverType = methodReceiverType();
 
@@ -5706,9 +5707,7 @@ void Resolver::exit(const Call* call) {
 
   // Always remove the call from the stack if we pushed it there,
   // to make sure it's properly set.
-  if (call != curInheritanceExpr) {
-    callNodeStack.pop_back();
-  }
+  callNodeStack.pop_back();
 }
 
 bool Resolver::enter(const Dot* dot) {

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

@@ -228,7 +228,7 @@ setupCallForCopyOrMove(Resolver& resolver,
                         std::move(actuals));
   } else {
     // For other types, use `init=`.
-    auto varArg = QualifiedType(QualifiedType::VAR, lhsType.type(), lhsType.param());
+    auto varArg = QualifiedType(QualifiedType::INIT_RECEIVER, lhsType.type(), lhsType.param());
     actuals.push_back(CallInfoActual(varArg, USTR("this")));
     outAsts.push_back(ast);
     actuals.push_back(CallInfoActual(rhsType, UniqueString()));

frontend/lib/resolution/maybe-const.cpp

@@ -292,6 +292,13 @@ bool AdjustMaybeRefs::enter(const Call* ast, RV& rv) {
         // it was inferred, so we need to offset by one.
         const AstNode* actualAst = inferredReceiver ? actualAsts[actualIdx-1] :
                                                       actualAsts[actualIdx];
+
+        // we could've inserted synthetic actuals when making a second
+        // call to a partially instantiated type.
+        if (!actualAst) {
+          continue;
+        }
+
         Access access = accessForQualifier(fa->formalType().kind());
 
         exprStack.push_back(ExprStackEntry(actualAst, access,

frontend/lib/resolution/resolution-queries.cpp

@@ -6440,6 +6440,25 @@ resolveFnCall(ResolutionContext* rc,
     }
   }
 
+  // if the original call was a type constructor via a managed type
+  // (e.g., (owned C(?))(typeArg)), adjust the return type to keep
+  // the management of the called type.
+  const ClassType* calledCt = nullptr;
+  if (ci.calledType().type() && (calledCt = ci.calledType().type()->toClassType())) {
+    const ClassType* retCt = nullptr;
+    const BasicClassType* retBct = nullptr;
+    if (retType && retType->type() &&
+        (retCt = retType->type()->toClassType()) &&
+        retCt->decorator().isUnknownManagement() && retCt->manageableType() &&
+        (retBct = retCt->manageableType()->toBasicClassType())) {
+      auto newCt = ClassType::get(context, retBct,
+                                  calledCt->manager(),
+                                  calledCt->decorator());
+      CHPL_ASSERT(retType->param() == nullptr);
+      retType = QualifiedType(retType->kind(), newCt);
+    }
+  }
+
   return CallResolutionResult(mostSpecific,
                               rejectedPossibleIteratorCandidates,
                               ((bool) retType) ? *retType : QualifiedType(),
@@ -6687,6 +6706,10 @@ bool addExistingSubstitutionsAsActuals(Context* context,
       auto fieldAst = parsing::idToAst(context, id)->toVarLikeDecl();
       if (fieldAst->storageKind() == QualifiedType::TYPE ||
           fieldAst->storageKind() == QualifiedType::PARAM) {
+        if (qt.isParam() && !qt.hasParamPtr()) {
+          // don't add param substitutions that are not known
+          continue;
+        }
         addedSubs = true;
         outActuals.emplace_back(qt, fieldAst->name());
         outActualAsts.push_back(nullptr);

frontend/lib/resolution/resolution-types.cpp

@@ -428,13 +428,76 @@ static QualifiedType convertToInitReceiverType(const QualifiedType original) {
   return original;
 }
 
+static void prependActualFromSubstitutions(Context* context,
+                                           const QualifiedType& calledType,
+                                           std::vector<CallInfoActual>& actuals,
+                                           std::vector<const uast::AstNode*>* actualAsts) {
+  if (!calledType.type()) {
+    return;
+  }
+
+  std::vector<CallInfoActual> generatedActuals;
+  std::vector<const uast::AstNode*> generatedActualAsts;
+  if (!addExistingSubstitutionsAsActuals(context, calledType.type(),
+                                         generatedActuals, generatedActualAsts)) {
+    // didn't do anything; just return.
+    return;
+  }
+
+  // if the user is explicitly overriding a substitution, don't include the
+  // previous value, since that would double up the named actuals.
+  // Unnamed actuals are assumed to be sequentially mapped to the remaining
+  // (non-substituted) formals.
+
+  // find the user-mentioned actuals
+  std::set<UniqueString> existingNames;
+  for (const auto& actual : actuals) {
+    existingNames.insert(actual.byName());
+  }
+
+  // remove any generated actuals that the user has overridden
+  //   idx points to current element
+  //   firstToRemove points to the next available index to keep elements
+  // two-list implementation of: https://en.cppreference.com/w/cpp/algorithm/remove.html
+  size_t firstToRemove = 0;
+  for(; firstToRemove < generatedActuals.size(); firstToRemove++) {
+    if (existingNames.count(generatedActuals[firstToRemove].byName()) != 0) {
+      break;
+    }
+  }
+  for (size_t idx = firstToRemove; idx < generatedActuals.size(); idx++) {
+    if (existingNames.count(generatedActuals[idx].byName()) == 0) {
+      generatedActuals[firstToRemove] = std::move(generatedActuals[idx]);
+      generatedActualAsts[firstToRemove] = generatedActualAsts[idx];
+      firstToRemove++;
+    }
+  }
+  generatedActuals.erase(generatedActuals.begin() + firstToRemove,generatedActuals.end());
+  generatedActualAsts.erase(generatedActualAsts.begin() + firstToRemove,generatedActualAsts.end());
+
+  // move the user-provided actuals into the generated lists, then swap
+  generatedActuals.insert(generatedActuals.end(),
+                          std::make_move_iterator(actuals.begin()),
+                          std::make_move_iterator(actuals.end()));
+  actuals.swap(generatedActuals);
+  if (actualAsts != nullptr) {
+    generatedActualAsts.insert(generatedActualAsts.end(),
+                               std::make_move_iterator(actualAsts->begin()),
+                               std::make_move_iterator(actualAsts->end()));
+    actualAsts->swap(generatedActualAsts);
+  }
+}
+
+
+
 CallInfo CallInfo::create(Context* context,
                           const Call* call,
                           const ResolutionResultByPostorderID& byPostorder,
                           bool raiseErrors,
                           std::vector<const uast::AstNode*>* actualAsts,
                           ID* moduleScopeId,
-                          UniqueString rename) {
+                          UniqueString rename,
+                          bool* outIncompleteTypeConstructor) {
 
   // Pieces of the CallInfo we need to prepare.
   UniqueString name;
@@ -497,6 +560,14 @@ CallInfo CallInfo::create(Context* context,
         makeCallToDotThis();
       } else {
         calledType = *calledExprType;
+        prependActualFromSubstitutions(context, calledType, actuals, actualAsts);
+      }
+    } else if (calledExprType && calledExprType->isUnknown() && calledExprType->isType()) {
+      // it looks like we're invoking a type constructor, but we don't know
+      // what type. We don't know enough to set calledType, and the call
+      // shouldn't be resolved. Signal this via outIncompleteTypeConstructor.
+      if (outIncompleteTypeConstructor != nullptr) {
+        *outIncompleteTypeConstructor = true;
       }
     } else if (!call->isOpCall() && dotReceiverType &&
                isKindForMethodReceiver(dotReceiverType->kind())) {

frontend/lib/resolution/signature-checks.cpp

@@ -65,18 +65,19 @@ static const bool& checkSignatureQuery(Context* context,
           (isInQualifier(thisIntent) && sig->formalType(0).type()->isClassType()))) {
       context->error(errId, "Bad 'this' intent for init=");
     }
-    bool rhsIntentGenericOrRef = isGenericQualifier(rhsIntent) ||
-                                 isRefQualifier(rhsIntent);
+    bool rhsIntentGenericOrRefOrParam = isGenericQualifier(rhsIntent) ||
+                                        isRefQualifier(rhsIntent) ||
+                                        rhsIntent == Qualifier::PARAM;
     // check the intent of the rhs argument
     if (sig->formalType(0).type() == sig->formalType(1).type()) {
       // same-type case: only const/default/ref/const ref RHS is allowed
       // allow 'in' for borrowed RHS, such as when defining init= for a class.
-      if (!rhsIntentGenericOrRef && !sig->formalType(0).type()->isClassType()) {
+      if (!rhsIntentGenericOrRefOrParam && !sig->formalType(0).type()->isClassType()) {
         context->error(errId, "Bad intent for same-type init= other argument");
       }
     } else {
       // different-type case: RHS can be 'in' intent in addition
-      if (!(rhsIntentGenericOrRef || isInQualifier(rhsIntent))) {
+      if (!(rhsIntentGenericOrRefOrParam || isInQualifier(rhsIntent))) {
         context->error(errId, "Bad intent for cross-type init= other argument");
       }
     }

frontend/lib/types/CompositeType.cpp

@@ -59,14 +59,21 @@ static void stringifySortedSubstitutions(std::ostream& ss,
                                          const std::vector<SubstitutionPair>& sorted,
                                          bool& emittedField) {
   for (const auto& sub : sorted) {
+    if (sub.second.isParam() && sub.second.param() == nullptr &&
+        stringKind == StringifyKind::CHPL_SYNTAX) {
+      // we know the type of the param value, but not the value. Production
+      // doesn't print it.
+      continue;
+    }
+
     if (emittedField) ss << ", ";
 
     if (stringKind != StringifyKind::CHPL_SYNTAX) {
       sub.first.stringify(ss, stringKind);
       ss << ":";
       sub.second.stringify(ss, stringKind);
     } else {
-      if (sub.second.isType() || (sub.second.isParam() && sub.second.param() == nullptr)) {
+      if (sub.second.isType()) {
         sub.second.type()->stringify(ss, stringKind);
       } else if (sub.second.isParam()) {
         sub.second.param()->stringify(ss, stringKind);

frontend/test/resolution/testInitSemantics.cpp

@@ -2306,6 +2306,51 @@ static void testInitEqRecursionError() {
   assert(guard.realizeErrors() > 0);
 }
 
+static void testPartialTypeInitEq() {
+  std::string prog = R"""(
+    record R {
+      type T;
+      param p : T;
+    }
+
+    proc R.init=(param p : this.type.T) {
+      this.T = p.type;
+      this.p = p;
+    }
+
+    operator :(from, type t: R(from.type)) {
+      var tmp: t = from;
+      return tmp;
+    }
+
+    type root = R(?);
+    var r1 : R(string, ?) = "hi";
+    var r2 : R(int, ?) = 1234;
+  )""";
+
+  auto context = buildStdContext();
+  ErrorGuard guard(context);
+  auto vars = resolveTypesOfVariables(context, prog, {"root", "r1", "r2"});
+
+  auto rootType = vars["root"].type();
+  assert(rootType && rootType->isRecordType());
+  assert(rootType->toRecordType()->instantiatedFrom() == nullptr);
+
+  auto r1Type = vars["r1"].type();
+  assert(r1Type && r1Type->isRecordType());
+  ensureSubs(context, r1Type->toCompositeType(), {
+    {"T", QualifiedType(QualifiedType::TYPE, RecordType::getStringType(context))},
+    {"p", QualifiedType::makeParamString(context, "hi")}
+  });
+
+  auto r2Type = vars["r2"].type();
+  assert(r2Type && r2Type->isRecordType());
+  ensureSubs(context, r2Type->toCompositeType(), {
+    {"T", QualifiedType(QualifiedType::TYPE, IntType::get(context, 64))},
+    {"p", QualifiedType::makeParamInt(context, 1234)}
+  });
+}
+
 // TODO:
 // - test using defaults for types and params
 //   - also in conditionals
@@ -2372,6 +2417,8 @@ int main() {
   testInitEqRecursion();
   testInitEqRecursionError();
 
+  testPartialTypeInitEq();
+
   return 0;
 }