(closes #1858) Add support for derived type accessors in ref2arrayrange

changelog

@@ -1,3 +1,6 @@
+   18) PR #3266 for #1858. Adds support for derived-type accessors in
+   the Reference2ArrayRangeTrans transformation.
+
    17) PR #3277 for #3276. Update copyright statements for 2026.
 
    16) PR #3258 for #279. Removes Arguments.dofs and generally improves

examples/nemo/scripts/utils.py

@@ -58,7 +58,7 @@
     "ldfdyn", "sbcapr", "sbctide", "zdfgls", "sbcrnf", "sbcisf", "dynldf_iso",
     "stopts", "icb_oce", "domvvl", "sms_pisces", "zdfmfc", "abl", "ice1d",
     "sed", "p2zlim", "oce_trc", "p4zpoc", "tide_mod", "sbcwave", "isf_oce",
-    "step_oce", "bdyice",
+    "step_oce", "bdyice", "lbcnfd"
 ]
 
 # Files that PSyclone could process but would reduce the performance.
@@ -201,7 +201,6 @@ def normalise_loops(
     :param hoist_expressions: whether to hoist bounds and loop invariant
         statements out of the loop nest.
     '''
-    filename = schedule.root.name
     if hoist_local_arrays and schedule.name not in CONTAINS_STMT_FUNCTIONS:
         # Apply the HoistLocalArraysTrans when possible, it cannot be applied
         # to files with statement functions because it will attempt to put the
@@ -230,9 +229,6 @@ def normalise_loops(
         # Convert all array implicit loops to explicit loops
         explicit_loops = ArrayAssignment2LoopsTrans()
         for assignment in schedule.walk(Assignment):
-            if filename == "fldread.f90":
-                # TODO #2951: This file has issues converting SturctureRefs
-                continue
             try:
                 explicit_loops.apply(
                     assignment, options={'verbose': True})

src/psyclone/psyir/nodes/array_mixin.py

@@ -193,18 +193,22 @@ def is_lower_bound(self, index):
         '''
         return self._is_bound(index, "lower")
 
-    def _get_bound_expression(self, pos: int, bound: str):
+    def _get_bound_expression(self, position: int, bound: str):
         '''
         Lookup the upper or lower bound of this ArrayMixin.
 
-        :param pos: the dimension of the array for which to lookup the bound.
+        :param position: the dimension of the array for which to lookup the
+            bound.
         :param bound: "upper" or "lower" - the bound which to lookup.
 
         :returns: the declared bound for the specified dimension of this array
                   or a call to the {U/L}BOUND intrinsic if it is unknown.
         :rtype: :py:class:`psyclone.psyir.nodes.Node`
 
         :raises InternalError: if bound is neither "upper" or "lower".
+        :raises ValueError: if the shape of the given 'position' is needed to
+            generate the bound expression, but we don't have that type
+            information.
 
         '''
         if bound not in ("upper", "lower"):
@@ -229,8 +233,13 @@ def _get_bound_expression(self, pos: int, bound: str):
             cursor = cursor.member
             # Collect member information.
             if isinstance(cursor, ArrayMixin):
-                new_indices = [idx.copy() for idx in cursor.indices]
-                cnames.append((cursor.name.lower(), new_indices))
+                try:
+                    new_indices = [idx.copy() for idx in cursor.indices]
+                    cnames.append((cursor.name.lower(), new_indices))
+                except InternalError:
+                    # The node is incomplete, but we can still use the type
+                    # information to populate the bounds
+                    cnames.append(cursor.name.lower())
             else:
                 cnames.append(cursor.name.lower())
             # Continue to resolve datatype unless we hit an
@@ -243,17 +252,23 @@ def _get_bound_expression(self, pos: int, bound: str):
                 continue
             cursor_type = cursor_type.components[cursor.name.lower()].datatype
 
-        if (isinstance(cursor_type, ArrayType) and
-                cursor_type.shape[pos] not in [ArrayType.Extent.DEFERRED,
-                                               ArrayType.Extent.ATTRIBUTE]):
-            # We have the full type information and the bound is known.
-            if bound == "lower":
-                return cursor_type.shape[pos].lower.copy()
-            # If the upper bound is required and is of ArrayType.Extent type
-            # then we'll have to proceed to construct a call to the UBOUND
-            # intrinsic.
-            if not isinstance(cursor_type.shape[pos].upper, ArrayType.Extent):
-                return cursor_type.shape[pos].upper.copy()
+        if isinstance(cursor_type, ArrayType):
+            if position > len(cursor_type.shape):
+                raise ValueError(
+                    f"In '{type(self).__name__}' '{self.name}' the specified "
+                    f"index '{position}' must be less than the number of "
+                    f"dimensions '{len(cursor_type.shape)}'.")
+            if cursor_type.shape[position] not in [ArrayType.Extent.DEFERRED,
+                                                   ArrayType.Extent.ATTRIBUTE]:
+                # We have the full type information and the bound is known.
+                if bound == "lower":
+                    return cursor_type.shape[position].lower.copy()
+                # If the upper bound is required and is of ArrayType.Extent
+                # type then we'll have to proceed to construct a call to the
+                # UBOUND intrinsic.
+                if not isinstance(cursor_type.shape[position].upper,
+                                  ArrayType.Extent):
+                    return cursor_type.shape[position].upper.copy()
 
         # We've either failed to resolve the type or we don't know the extent
         # of the array dimension so construct a call to the BOUND intrinsic.
@@ -279,10 +294,10 @@ def _get_bound_expression(self, pos: int, bound: str):
         if bound == "lower":
             return IntrinsicCall.create(
                 IntrinsicCall.Intrinsic.LBOUND,
-                [ref, ("dim", Literal(str(pos+1), INTEGER_TYPE))])
+                [ref, ("dim", Literal(str(position+1), INTEGER_TYPE))])
         return IntrinsicCall.create(
                 IntrinsicCall.Intrinsic.UBOUND,
-                [ref, ("dim", Literal(str(pos+1), INTEGER_TYPE))])
+                [ref, ("dim", Literal(str(position+1), INTEGER_TYPE))])
 
     def get_lbound_expression(self, pos):
         '''
@@ -294,12 +309,11 @@ def get_lbound_expression(self, pos):
                         lower bound.
 
         :returns: the declared lower bound for the specified dimension of
-            the array accesed or a call to the LBOUND intrinsic if it is
+            the array accessed or a call to the LBOUND intrinsic if it is
             unknown.
         :rtype: :py:class:`psyclone.psyir.nodes.Node`
 
         '''
-        self._validate_index(pos)
         # Call the helper function
         return self._get_bound_expression(pos, "lower")
 
@@ -313,12 +327,11 @@ def get_ubound_expression(self, pos):
                         upper bound.
 
         :returns: the declared upper bound for the specified dimension of
-            the array accesed or a call to the UBOUND intrinsic if it is
+            the array accessed or a call to the UBOUND intrinsic if it is
             unknown.
         :rtype: :py:class:`psyclone.psyir.nodes.Node`
 
         '''
-        self._validate_index(pos)
         # Call the helper function
         return self._get_bound_expression(pos, "upper")
 
@@ -334,8 +347,6 @@ def get_full_range(self, pos):
                   pos for this ArrayMixin.
         :rtype: :py:class:`psyclone.psyir.nodes.Range`
         '''
-        self._validate_index(pos)
-
         lbound = self.get_lbound_expression(pos)
         ubound = self.get_ubound_expression(pos)
 

src/psyclone/psyir/transformations/inline_trans.py

@@ -860,10 +860,7 @@ def _generate_formal_arg_replacement(
                 break
             cursor = cursor.member
 
-        # TODO #1858 - once we support converting structure accesses into
-        # explicit array accesses, we can put back the testing in
-        # inline_trans_test.py that covers this code and remove the pragma:
-        if not actual_arg.walk(Range) and local_indices:  # pragma: no cover
+        if not actual_arg.walk(Range) and local_indices:
             # There are no Ranges in the actual argument but the local
             # reference is an array access.
             # Create updated index expressions for that access.