From cf29867067bbf237a1ebfb5fcee5c065e1f67bc0 Mon Sep 17 00:00:00 2001
From: Ahmad Rezaii <ahmad.rezaii@hpe.com>
Date: Wed, 7 Aug 2024 16:27:45 -0600
Subject: [PATCH] refactor common owned-shared logic into helper

Signed-off-by: Ahmad Rezaii <ahmad.rezaii@hpe.com>
---
 frontend/include/chpl/resolution/can-pass.h |  5 ++
 frontend/lib/resolution/can-pass.cpp        | 75 ++++++++++-----------
 2 files changed, 39 insertions(+), 41 deletions(-)

diff --git a/frontend/include/chpl/resolution/can-pass.h b/frontend/include/chpl/resolution/can-pass.h
index e82e44a7bfa8..605858796709 100644
--- a/frontend/include/chpl/resolution/can-pass.h
+++ b/frontend/include/chpl/resolution/can-pass.h
@@ -138,6 +138,11 @@ class CanPassResult {
                                       const types::QualifiedType& actualType,
                                       const types::QualifiedType& formalType);
 
+  static CanPassResult
+  canInstantiateOwnedSharedHelper(Context* context,
+                                  const types::ClassType* actualCt,
+                                  const types::CompositeType* formalCt);
+
  public:
   CanPassResult() { }
   ~CanPassResult() = default;
diff --git a/frontend/lib/resolution/can-pass.cpp b/frontend/lib/resolution/can-pass.cpp
index fba2e4b605f0..32691e8f8843 100644
--- a/frontend/lib/resolution/can-pass.cpp
+++ b/frontend/lib/resolution/can-pass.cpp
@@ -812,6 +812,35 @@ bool CanPassResult::canInstantiateBuiltin(Context* context,
   return false;
 }
 
+
+CanPassResult
+CanPassResult::canInstantiateOwnedSharedHelper(Context* context,
+                                               const types::ClassType* actualCt,
+                                               const types::CompositeType* formalCt) {
+  if (formalCt->isRecordType() && actualCt->decorator().isManaged()) {
+    if (parsing::idIsInBundledModule(context, formalCt->id())) {
+      auto attrGrp = parsing::idToAttributeGroup(context, formalCt->id());
+      if (attrGrp->hasPragma(uast::pragmatags::PragmaTag::PRAGMA_MANAGED_POINTER)) {
+        if (auto manager = actualCt->manager()) {
+          // check for instantiating _owned or _shared records
+          if ((formalCt->name() == UniqueString::get(context, "_owned") &&
+              manager->isAnyOwnedType()) ||
+              (formalCt->name() == UniqueString::get(context, "_shared") &&
+              manager->isAnySharedType())) {
+                // TODO: what ConversionKind should we return here?
+                return CanPassResult(/* no fail reason, passes */ {},
+                        /* instantiates */ true,
+                        /* promotes */ false,
+                        /* converts */ ConversionKind::OTHER);
+          }
+        }
+      }
+    }
+  }
+  // more checking to be done by canInstantiate
+  return CanPassResult::fail(FAIL_CANNOT_INSTANTIATE);
+}
+
 CanPassResult CanPassResult::canInstantiate(Context* context,
                                             const QualifiedType& actualQT,
                                             const QualifiedType& formalQT) {
@@ -854,47 +883,11 @@ CanPassResult CanPassResult::canInstantiate(Context* context,
         return got;
       }
     } else if (auto formalCt = formalT->toCompositeType()) {
-      // check for instantiating _owned record
-      if (formalCt->isRecordType() &&
-          formalCt->name() == UniqueString::get(context, "_owned")) {
-        if (actualCt->decorator().isManaged()) {
-          // check that the recordType is actually our _owned type in our bundled module
-          // e.g., is ID in bundled modules and does it have 'pragma "managed pointer"'?
-          if (parsing::idIsInBundledModule(context, formalCt->id())) {
-            auto attrGrp = parsing::idToAttributeGroup(context, formalCt->id());
-            if (attrGrp->hasPragma(uast::pragmatags::PragmaTag::PRAGMA_MANAGED_POINTER)) {
-              if (auto manager = actualCt->manager()) {
-                if (manager->isAnyOwnedType()) {
-                  // TODO: what ConversionKind should we return here?
-                  return CanPassResult(/* no fail reason, passes */ {},
-                          /* instantiates */ true,
-                          /* promotes */ false,
-                          /* converts */ ConversionKind::OTHER);
-                }
-              }
-            }
-          }
-        } // check for instantiating _shared record
-      } else if (formalCt->isRecordType() &&
-                 formalCt->name() == UniqueString::get(context, "_shared")) {
-        if (actualCt->decorator().isManaged()) {
-          // check that the recordType is actually our _shared type in our bundled module
-          // e.g., is ID in bundled modules and does it have 'pragma "managed pointer"'?
-          if (parsing::idIsInBundledModule(context, formalCt->id())) {
-            auto attrGrp = parsing::idToAttributeGroup(context, formalCt->id());
-            if (attrGrp->hasPragma(uast::pragmatags::PragmaTag::PRAGMA_MANAGED_POINTER)) {
-              if (auto manager = actualCt->manager()) {
-                if (manager->isAnySharedType()) {
-                  // TODO: what ConversionKind should we return here?
-                  return CanPassResult(/* no fail reason, passes */ {},
-                          /* instantiates */ true,
-                          /* promotes */ false,
-                          /* converts */ ConversionKind::OTHER);
-                }
-              }
-            }
-          }
-        }
+      auto canPassOwnedShared = canInstantiateOwnedSharedHelper(context,
+                                                                actualCt,
+                                                                formalCt);
+      if (canPassOwnedShared.passes()) {
+        return canPassOwnedShared;
       }
     }
   } else if (auto actualCt = actualT->toCompositeType()) {