(Towards #3060) reference accesses for intrinsicCall

src/psyclone/core/access_sequence.py

@@ -45,7 +45,6 @@
 
 from psyclone.core.access_type import AccessType
 from psyclone.core.signature import Signature
-from psyclone.errors import InternalError
 
 if TYPE_CHECKING:
     from psyclone.psyir.nodes import Node
@@ -73,32 +72,6 @@ def __init__(
     def __str__(self) -> str:
         return f"{self._access_type}"
 
-    def change_read_to_write(self) -> None:
-        '''This changes the access mode from READ to WRITE.
-        This is used for processing assignment statements,
-        where the LHS is first considered to be READ,
-        and which is then changed to be WRITE.
-
-        :raises InternalError: if the variable originally does not have\
-            READ access.
-
-        '''
-        if self._access_type != AccessType.READ:
-            raise InternalError("Trying to change variable to 'WRITE' "
-                                "which does not have 'READ' access.")
-        self._access_type = AccessType.WRITE
-
-    def change_read_to_constant(self):
-        '''This changes the access mode from READ to CONSTANT.
-
-        :raises InternalError: if the variable does not have READ access.
-        '''
-        if self._access_type != AccessType.READ:
-            raise InternalError(f"Trying to change variable access from "
-                                f"'READ' to 'CONSTANT' but access type is "
-                                f" '{self._access_type}'.")
-        self._access_type = AccessType.CONSTANT
-
     def component_indices(self):
         '''
         :returns: a tuple of tuples of index expressions; one for every
@@ -134,6 +107,17 @@ def access_type(self) -> AccessType:
         '''
         return self._access_type
 
+    @access_type.setter
+    def access_type(self, value: AccessType) -> None:
+        '''
+        :param value: the new access type.
+        '''
+        if not isinstance(value, AccessType):
+            raise TypeError(
+                f"Expected AccessType but got '{type(value).__name__}'."
+            )
+        self._access_type = value
+
     def is_any_write(self) -> bool:
         '''
         :returns: whether this access represents a write of any kind.
@@ -319,35 +303,6 @@ def add_access(self, access_type: AccessType, node: 'Node') -> None:
         '''
         self.append(AccessInfo(access_type, node))
 
-    def change_read_to_constant(self):
-        '''This function is used to change a READ into a CONSTANT.
-
-        :raises InternalError: if there is an access that is not READ or
-                               INQUIRY or there is > 1 READ accesses.
-        '''
-        read_access = None
-        for acc in self:
-
-            if acc.access_type == AccessType.READ:
-                if read_access:
-                    raise InternalError(
-                        f"Trying to change variable '{self._signature}' to "
-                        f"'CONSTANT' but it has more than one 'READ' access."
-                    )
-                read_access = acc
-
-            elif acc.access_type not in AccessType.non_data_accesses():
-                raise InternalError(
-                    f"Variable '{self._signature}' has a '{acc.access_type}' "
-                    f"access. change_read_to_constant() expects only "
-                    f"inquiry accesses and a single 'READ' access.")
-
-        if not read_access:
-            raise InternalError(
-                f"Trying to change variable '{self._signature}' to "
-                f"'CONSTANT' but it does not have a 'READ' access.")
-        read_access.change_read_to_constant()
-
     def update(self, access_seq: AccessSequence) -> None:
         '''
         This function adds all accesses from the given access sequence
@@ -365,40 +320,6 @@ def update(self, access_seq: AccessSequence) -> None:
         for access_info in access_seq:
             self.add_access(access_info.access_type, access_info.node)
 
-    def change_read_to_write(self) -> None:
-        '''This function is only used when analysing an assignment statement.
-        The LHS has first all variables identified, which will be READ.
-        This function is then called to change the assigned-to variable
-        on the LHS to from READ to WRITE. Since the LHS is stored in a separate
-        AccessSequence class, it is guaranteed that there is only
-        one READ entry for the variable (although there maybe INQUIRY accesses
-        for array bounds).
-
-        :raises InternalError: if there is an access that is not READ or
-                               INQUIRY or there is > 1 READ access.
-        '''
-        read_access = None
-        for acc in self:
-
-            if acc.access_type == AccessType.READ:
-                if read_access:
-                    raise InternalError(
-                        f"Trying to change variable '{self._signature}' to "
-                        f"'WRITE' but it has more than one 'READ' access.")
-                read_access = acc
-
-            elif acc.access_type not in AccessType.non_data_accesses():
-                raise InternalError(
-                    f"Variable '{self._signature}' has a '{acc.access_type}' "
-                    f"access. change_read_to_write() expects only inquiry "
-                    f"accesses and a single 'READ' access.")
-
-        if not read_access:
-            raise InternalError(
-                f"Trying to change variable '{self._signature}' to 'WRITE' but"
-                f" it does not have a 'READ' access.")
-        read_access.change_read_to_write()
-
     def has_indices(self, index_variable: Optional[str] = None) -> bool:
         ''' Checks whether this variable accesses has any index. If the
         optional `index_variable` is provided, only indices involving the given

src/psyclone/psyir/nodes/assignment.py

@@ -39,7 +39,7 @@
 
 ''' This module contains the Assignment node implementation.'''
 
-from psyclone.core import VariablesAccessMap
+from psyclone.core import VariablesAccessMap, AccessType
 from psyclone.errors import InternalError
 from psyclone.psyir.nodes.literal import Literal
 from psyclone.psyir.nodes.array_reference import ArrayReference
@@ -180,27 +180,15 @@ def reference_accesses(self) -> VariablesAccessMap:
             (a sequence of AccessTypes).
 
         '''
-        # It is important that a new instance is used to handle the LHS,
-        # since a check in 'change_read_to_write' makes sure that there
-        # is only one access to the variable!
         lhs_accesses = self.lhs.reference_accesses()
-        # Now change the (one) access to the assigned variable to be WRITE.
+        # Now change the top (last) access to be WRITE.
+        if isinstance(self.lhs, Reference):
+            sig, _ = self.lhs.get_signature_and_indices()
+            lhs_accesses[sig][-1].access_type = AccessType.WRITE
         # Note that if the LHS is a CodeBlock then reference_accesses() will
         # already have given all Signatures READWRITE access. This is not
         # strictly correct (they should probably be UNKNOWN) and is the
         # subject of #2863.
-        if isinstance(self.lhs, Reference):
-            sig, _ = self.lhs.get_signature_and_indices()
-            var_info = lhs_accesses[sig]
-            try:
-                var_info.change_read_to_write()
-            except InternalError as err:
-                # An internal error typically indicates that the same variable
-                # is used twice on the LHS, e.g.: g(g(1)) = ... This is not
-                # supported in PSyclone.
-                raise NotImplementedError(
-                    f"The variable '{self.lhs.name}' appears more than once on"
-                    f" the left-hand side of an assignment.") from err
 
         # Merge the data (that shows now WRITE for the variable) with the
         # parameter to this function. It is important that first the