Dyno: simplify array type creation (#27177)

Closes Cray/chapel-private#7334, which
required resolving:

```Chapel
use ReplicatedDist;

var Space = {1..10};
const ReplicatedSpace = Space dmapped new replicatedDist();
var RA: [ReplicatedSpace] int;
```

To be merged after #27171.
Clean diff:
https://github.com/chapel-lang/chapel/pull/27177/files/47946ac16e576a8d92863f8cffb4efebccb2ff96..132e5f2c0931cfbd96003239e9499ab435abbbd3

The `dom` and `eltType` fields are [required as part of the
DSI](https://chapel-lang.org/docs/technotes/dsi.html#id11).

In practice, they are relied on in various method on the `_array`
builtin record:


https://github.com/chapel-lang/chapel/blob/47946ac16e576a8d92863f8cffb4efebccb2ff96/modules/internal/ChapelArray.chpl#L832-L834


https://github.com/chapel-lang/chapel/blob/47946ac16e576a8d92863f8cffb4efebccb2ff96/modules/internal/ChapelArray.chpl#L819-L820

So, instead of special casing various well-known array classes to
extract their `dom` and `eltType` fields, simply adjust the InitResolver
code to search for these required fields until they are found.

While there, it seemed easy enough to add errors for when these things
are missing.

Reviewed by @arifthpe -- thanks!

## Testing
- [x] dyno tests
- [x] `test/release/examples/primers/replicated.chpl` resolves
- [x] paratest

Author: DanilaFe

frontend/lib/resolution/InitResolver.cpp

@@ -350,11 +350,47 @@ static auto helpExtractFields(ResolutionContext* rc, const BasicClassType* bct,
   return ret;
 }
 
+// same as above, but consider parent classes
+template <typename FoundEach, typename ...FieldNames, size_t ... Is>
+static auto helpExtractFieldsHierarchy(ResolutionContext* rc, const BasicClassType* bct, FoundEach& foundEach, std::index_sequence<Is...>, FieldNames... names) {
+  typename ImplCreateNTuple<Is...>::type ret;
+
+  while (bct) {
+    auto& rf = fieldsForTypeDecl(rc, bct,
+                                 DefaultsPolicy::IGNORE_DEFAULTS);
+    for (int i = 0; i < rf.numFields(); i++) {
+        ((rf.fieldName(i) == names ?
+          (std::get<Is>(ret) = rf.fieldType(i),
+           std::get<Is>(foundEach) += 1,
+           0) : 0), ...);
+    }
+
+    bct = bct->parentClassType();
+
+    // if we've found all of them, stop
+    if ((std::get<Is>(foundEach) && ...)) {
+      break;
+    }
+  }
+
+  return ret;
+}
+
 template <typename ...FieldNames>
 static auto extractFields(ResolutionContext* rc, const BasicClassType* bct,  FieldNames... names) {
   return helpExtractFields(rc, bct, std::make_index_sequence<sizeof...(FieldNames)>(), names...);
 }
 
+// similar to extractFields, but instead of assuming the fields are in the given
+// class, traverse the class hierarchy to find them. Also, the additional
+// foundEach template argument is used to count how many times each field
+// has occurred. This is useful to know when to stop searching, and to
+// issue errors for missing fields.
+template <typename FoundEach, typename ...FieldNames>
+static auto extractFieldsHierarchy(ResolutionContext* rc, const BasicClassType* bct,  FoundEach& foundEach, FieldNames... names) {
+  return helpExtractFieldsHierarchy(rc, bct, foundEach, std::make_index_sequence<sizeof...(FieldNames)>(), names...);
+}
+
 static std::tuple<QualifiedType, QualifiedType, QualifiedType>
 extractRectangularInfo(ResolutionContext* rc, const BasicClassType* bct) {
   return extractFields(rc, bct, "rank", "idxType", "strides");
@@ -424,60 +460,21 @@ static const ArrayType* arrayTypeFromSubsHelper(
   auto [instanceBct, baseArr] = extractBasicSubclassFromInstance(instanceQt);
   if (!instanceBct || !baseArr) return genericArray;
 
-  if (baseArr->id().symbolPath() == "ChapelDistribution.BaseRectangularArr") {
-    auto [domInstanceQt] = extractFields(rc, instanceBct, "dom");
-    auto domain = domainTypeFromInstance(rc, domInstanceQt);
-    CHPL_ASSERT(domain);
-
-    auto [eltType] = extractFields(rc, baseArr, "eltType");
-    return ArrayType::getArrayType(context, instanceQt,
-                                   QualifiedType(QualifiedType::TYPE, domain),
-                                   eltType);
-  } else if (instanceBct->id().symbolPath() ==
-                 "DefaultAssociative.DefaultAssociativeArr" ||
-             instanceBct->id().symbolPath() ==
-                 "ArrayViewReindex.ArrayViewReindexArr" ||
-             instanceBct->id().symbolPath() ==
-                 "ArrayViewSlice.ArrayViewSliceArr" ||
-             instanceBct->id().symbolPath() ==
-                 "ArrayViewRankChange.ArrayViewRankChangeArr") {
-    auto [domInstanceQt] = extractFields(rc, instanceBct, "dom");
-    auto domain = domainTypeFromInstance(rc, domInstanceQt);
-    CHPL_ASSERT(domain);
-
-    CHPL_ASSERT(baseArr &&
-                baseArr->id().symbolPath() == "ChapelDistribution.AbsBaseArr");
-    auto [eltType] = extractFields(rc, baseArr, "eltType");
-
-    return ArrayType::getArrayType(context, instanceQt,
-                                   QualifiedType(QualifiedType::TYPE, domain),
-                                   eltType);
-  } else if (baseArr->id().symbolPath() ==
-             "ChapelDistribution.BaseSparseArrImpl") {
-    // The Impl doesn't have the data, the parent class does.
-    auto baseArrSparse = baseArr->parentClassType();
-    CHPL_ASSERT(baseArrSparse &&
-                baseArrSparse->id().symbolPath() ==
-                    "ChapelDistribution.BaseSparseArr");
-    auto absBaseArr = baseArrSparse->parentClassType();
-    CHPL_ASSERT(absBaseArr &&
-                absBaseArr->id().symbolPath() ==
-                    "ChapelDistribution.AbsBaseArr");
-
-    auto [domInstanceQt] = extractFields(rc, baseArrSparse,"dom");
-    auto [eltType] = extractFields(rc, absBaseArr, "eltType");
-    auto domain = domainTypeFromInstance(rc, domInstanceQt);
-    CHPL_ASSERT(domain);
-
-    return ArrayType::getArrayType(context, instanceQt,
-                                   QualifiedType(QualifiedType::TYPE, domain),
-                                   eltType);
-  } else {
-    CHPL_UNIMPL("unknown kind of array class");
+  auto fieldCounts = std::make_pair(0, 0);
+  auto [domInstanceQt, eltType] = extractFieldsHierarchy(rc, instanceBct, fieldCounts, "dom", "eltType");
+
+  if (fieldCounts.first == 0) {
+    rc->context()->error(instanceBct->id(), "array implementation class doesn't have required field 'dom'");
   }
+  if (fieldCounts.second == 0) {
+    rc->context()->error(instanceBct->id(), "array implementation class doesn't have required field 'eltType'");
+  }
+
+  auto domain = domainTypeFromInstance(rc, domInstanceQt);
 
-  // If we reach here, we weren't able to resolve the array type
-  return genericArray;
+  return ArrayType::getArrayType(context, instanceQt,
+                                 QualifiedType(QualifiedType::TYPE, domain),
+                                 eltType);
 }
 
 static const Type* ctFromSubs(ResolutionContext* rc,