(towards #3124) Codeblocks with children references

src/psyclone/psyir/backend/fortran.py

@@ -1000,14 +1000,16 @@ def gen_decls(self,
         except KeyError:
             internal_interface_symbol = None
         if unresolved_symbols and not (
-                symbol_table.wildcard_imports() or internal_interface_symbol):
+                symbol_table.wildcard_imports() or
+                internal_interface_symbol or
+                (symbol_table.node and symbol_table.node.walk(CodeBlock))):
             symbols_txt = ", ".join(
                 ["'" + sym.name + "'" for sym in unresolved_symbols])
             raise VisitorError(
                 f"The following symbols are not explicitly declared or "
                 f"imported from a module and there are no wildcard "
-                f"imports which could be bringing them into scope: "
-                f"{symbols_txt}")
+                f"imports, generic interfaces or CodeBlocks which could be "
+                f"bringing them into scope: {symbols_txt}")
 
         # Check that the names of all symbols are less than the limit
         # imposed by the Fortran standard.
@@ -1089,19 +1091,23 @@ def filecontainer_node(self, node):
         :rtype: str
 
         :raises VisitorError: if the attached symbol table contains
-            any non-routine symbols.
+            any symbols that can not be declard in a FileContainer.
         :raises VisitorError: if more than one child is a Routine Node
             with is_program set to True.
 
         '''
         for symbol in node.symbol_table.symbols:
-            # TODO #2201 - ContainerSymbols should be accepted but
-            # currently are stored in its containing scope.
-            if not isinstance(symbol, RoutineSymbol):
+            # Only RoutineSymbols and ContainerSymbol can be declared here
+            # pylint: disable=unidiomatic-typecheck
+            if type(symbol) is Symbol and symbol.is_unresolved:
+                # However we also accept symbols that we don't know where
+                # they are declared, so we propagated upwards.
+                continue
+            if not isinstance(symbol, (RoutineSymbol, ContainerSymbol)):
                 raise VisitorError(
                     f"In the Fortran backend, a file container should not "
-                    f"have any symbols associated with it other than "
-                    f"RoutineSymbols, but found {str(symbol)}.")
+                    f"have any data symbols associated with it, "
+                    f"but found {str(symbol)}.")
 
         program_nodes = len([child for child in node.children if
                              isinstance(child, Routine) and child.is_program])

src/psyclone/psyir/frontend/fparser2.py

@@ -3575,7 +3575,7 @@ def _do_construct_handler(self, node, parent):
                 self.process_comment(child, preceding_comments)
                 continue
             if isinstance(child, Fortran2003.Directive) and not found_do_stmt:
-                directive = self._directive_handler(child, None)
+                directive = self._directive_handler(child, loop.parent)
                 # Add the directive before the loop.
                 loop.parent.addchild(directive)
                 directive.preceding_comment = (
@@ -3636,7 +3636,7 @@ def _if_construct_handler(self, node, parent):
             if isinstance(child, Fortran2003.Comment):
                 self.process_comment(child, preceding_comments)
             if isinstance(child, Fortran2003.Directive):
-                direc = self._directive_handler(child, None)
+                direc = self._directive_handler(child, parent)
                 parent.addchild(direc)
                 direc.preceding_comment = (
                     self._comments_list_to_string(preceding_comments)

src/psyclone/psyir/nodes/codeblock.py

@@ -48,7 +48,10 @@
 from psyclone.errors import InternalError
 from psyclone.psyir.nodes.statement import Statement
 from psyclone.psyir.nodes.datanode import DataNode
+from psyclone.psyir.nodes.reference import Reference
 from psyclone.psyir.nodes.node import Node
+from psyclone.psyir.symbols import (
+    SymbolTable, SymbolError, UnresolvedInterface)
 
 
 class CodeBlock(Statement, DataNode):
@@ -73,7 +76,7 @@ class CodeBlock(Statement, DataNode):
 
     '''
     #: Textual description of the node.
-    _children_valid_format = "<LeafNode>"
+    _children_valid_format = "[Reference]*"
     _text_name = "CodeBlock"
     _colour = "red"
     #: The annotations that are supported by this node.
@@ -111,6 +114,35 @@ def __init__(
             self._parse_tree_nodes = [parse_tree]
         # Store the structure of the code block.
         self._structure = structure
+        # Capture all symbols used inside the Codeblock as children References
+        self._insert_representative_references()
+
+    @staticmethod
+    def _validate_child(position: int, child: Node) -> bool:
+        '''
+        :param position: the position to be validated.
+        :param child: a child to be validated.
+
+        :return: whether the given child and position are valid for this node.
+
+        '''
+        return isinstance(child, Reference)
+
+    def _insert_representative_references(self):
+        ''' Insert Reference children under this codeblock that
+        represent each of the symbols used inside the CodeBlock.
+        '''
+        for symbol_name in self.get_symbol_names():
+            try:
+                symtab = self.scope.symbol_table
+            except SymbolError:
+                # Needed for detached CodeBlocks, mainly used in testing
+                symtab = SymbolTable()
+            symbol = symtab.find_or_create(
+                symbol_name, interface=UnresolvedInterface())
+            ref = Reference(symbol)
+            if ref not in self.children:
+                self.addchild(Reference(symbol))
 
     @staticmethod
     def create(*args, **kwargs) -> CodeBlock:
@@ -184,20 +216,20 @@ def reference_accesses(self) -> VariablesAccessMap:
         TODO #2863 - it would be better to use AccessType.UNKNOWN here but
         currently VariablesAccessMap does not consider that type of access.
 
-        This method makes use of
-        :py:meth:`~psyclone.psyir.nodes.CodeBlock.get_symbol_names` and is
-        therefore subject to the same limitations as that method.
-
         :returns: a map of all the symbol accessed inside this node, the
             keys are Signatures (unique identifiers to a symbol and its
             structure accessors) and the values are AccessSequence
             (a sequence of AccessTypes).
 
         '''
         var_accesses = VariablesAccessMap()
-        for name in self.get_symbol_names():
-            var_accesses.add_access(Signature(name), AccessType.READWRITE,
-                                    self)
+        # All symbols accessed within the CodeBlock are captured as Reference
+        # nodes and stored as children of the CodeBlock node
+        for child in self.children:
+            var_accesses.add_access(
+                Signature(child.name),
+                AccessType.READWRITE,
+                child)
         return var_accesses
 
     def __str__(self) -> str:
@@ -294,12 +326,26 @@ def get_symbol_names(self) -> list[str]:
                         node is node.parent.children[0]):
                     result.append(node.string)
             elif not isinstance(node.parent,
+                                # We don't want labels associated with loop or
+                                # branch control.
                                 (Fortran2003.Cycle_Stmt,
                                  Fortran2003.End_Do_Stmt,
                                  Fortran2003.Exit_Stmt,
                                  Fortran2003.Else_Stmt,
                                  Fortran2003.End_If_Stmt)):
-                # We don't want labels associated with loop or branch control.
+
+                # Check if this name is a structure accessor instead of a
+                # symbol
+                if isinstance(node.parent, Fortran2003.Part_Ref):
+                    # Also account for array fields name%array(i)
+                    check = node.parent
+                else:
+                    check = node
+                if isinstance(check.parent, Fortran2003.Data_Ref):
+                    # The first child is the base reference, the others are
+                    # accessor names, which are not symbols
+                    if check.parent.children[0] is not check:
+                        continue
                 result.append(node.string)
         # Precision on literals requires special attention since they are just
         # stored in the tree as str (fparser/#456).
@@ -407,3 +453,10 @@ def get_fortran_lines(self) -> list[str]:
         for node in self._parse_tree_nodes:
             output.extend(str(node.text, encoding="utf8").split("\n"))
         return output
+
+    def get_symbol_names(self) -> list[str]:
+        '''
+        :returns: the name of all symbols accessed in the CodeBlock.
+        '''
+        # TODO #3038 Treesitter support is incomplete
+        return []

src/psyclone/psyir/nodes/reference.py

@@ -130,6 +130,7 @@ def is_write(self):
         # pylint: disable=import-outside-toplevel
         from psyclone.psyir.nodes.assignment import Assignment
         from psyclone.psyir.nodes.call import Call
+        from psyclone.psyir.nodes.codeblock import CodeBlock
         from psyclone.psyir.nodes.intrinsic_call import IntrinsicCall
         parent = self.parent
         # pure or inquiry IntrinsicCall nodes do not write to their arguments.
@@ -144,6 +145,9 @@ def is_write(self):
         # The reference that is the LHS of an assignment is a write.
         if isinstance(parent, Assignment) and parent.lhs is self:
             return True
+        # Assume the worst for CodeBlocks
+        if isinstance(parent, CodeBlock):
+            return True
         return False
 
     @property

src/psyclone/psyir/tools/definition_use_chains.py

@@ -589,17 +589,14 @@ def _compute_forward_uses(self, basic_block_list: list[Node]):
                             if defs_out[sig] is not None:
                                 self._defsout[sig].append(defs_out[sig])
                         return
-                    for i, ref in enumerate(self._references[:]):
-                        if (
-                            ref.symbol.name
-                            in reference.get_symbol_names()
-                        ):
-                            # Assume the worst for a CodeBlock and we count
-                            # them as killed and defsout and uses.
-                            sig = self._reference_signatures[i]
-                            if defs_out[sig] is not None:
-                                self._killed[sig].append(defs_out[sig])
-                            defs_out[sig] = reference
+                elif isinstance(reference.parent, CodeBlock):
+                    for i, _ in enumerate(self._references[:]):
+                        # Assume the worst for a CodeBlock and we count
+                        # them as killed and defsout and uses.
+                        sig = self._reference_signatures[i]
+                        if defs_out[sig] is not None:
+                            self._killed[sig].append(defs_out[sig])
+                        defs_out[sig] = reference
                 elif isinstance(reference, Call):
                     # If its a local variable we can ignore it as we'll catch
                     # the Reference later if its passed into the Call.
@@ -888,17 +885,14 @@ def _compute_backward_uses(self, basic_block_list: list[Node]):
                             "DefinitionUseChains can't handle code containing"
                             " GOTO statements."
                         )
-                    for i, ref in enumerate(self._references[:]):
-                        if (
-                            ref.symbol.name
-                            in reference.get_symbol_names()
-                        ):
-                            # Assume the worst for a CodeBlock and we count
-                            # them as killed and defsout and uses.
-                            sig = self._reference_signatures[i]
-                            if defs_out[sig] is not None:
-                                self._killed[sig].append(defs_out[sig])
-                            defs_out[sig] = reference
+                elif isinstance(reference.parent, CodeBlock):
+                    for i, _ in enumerate(self._references[:]):
+                        # Assume the worst for a CodeBlock and we count
+                        # them as killed and defsout and uses.
+                        sig = self._reference_signatures[i]
+                        if defs_out[sig] is not None:
+                            self._killed[sig].append(defs_out[sig])
+                        defs_out[sig] = reference
                 elif isinstance(reference, Call):
                     # If its a local variable we can ignore it as we'll catch
                     # the Reference later if its passed into the Call.

src/psyclone/psyir/transformations/inline_trans.py

@@ -1157,7 +1157,7 @@ def validate(
                         continue
                     exprn = prev.ancestor(Statement, include_self=True)
                     stmt = exprn.debug_string().strip()
-                    if isinstance(prev, (CodeBlock, Call, Kern, Loop)):
+                    if isinstance(prev, (Kern, Loop)):
                         raise TransformationError(
                             f"Cannot inline routine '{routine.name}' "
                             f"because one or more of its declarations "

src/psyclone/psyir/transformations/scalarisation_trans.py

@@ -36,9 +36,9 @@
 '''This module provides the sclarization transformation class.'''
 
 from psyclone.core import VariablesAccessMap, Signature, SymbolicMaths
-from psyclone.psyGen import Kern
-from psyclone.psyir.nodes import Call, CodeBlock, Literal, \
-        IfBlock, Loop, Node, Range, Reference, Routine, StructureReference
+from psyclone.psyir.nodes import (
+    Literal, IfBlock, Loop, Node, Range, Reference, Routine,
+    StructureReference)
 from psyclone.psyir.nodes.array_mixin import ArrayMixin
 from psyclone.psyir.symbols import DataSymbol, RoutineSymbol, ScalarType
 from psyclone.psyir.transformations.loop_trans import LoopTrans
@@ -110,12 +110,6 @@ def _is_local_array(signature: Signature,
         '''
         if not var_accesses[signature].has_indices():
             return False
-        # If any of the accesses are to a CodeBlock then we stop. This can
-        # happen if there is a string access inside a string concatenation,
-        # e.g. NEMO4.
-        for access in var_accesses[signature]:
-            if isinstance(access.node, CodeBlock):
-                return False
         base_symbol = var_accesses[signature][0].node.symbol
         if not base_symbol.is_automatic:
             return False
@@ -307,13 +301,6 @@ def _value_unused_after_loop(sig: Signature,
             if has_complex_index:
                 return False
 
-            # If next access is a Call or CodeBlock or Kern then
-            # we have to assume the value is used. These nodes don't
-            # have the is_read property that Reference has, so we need
-            # to be explicit.
-            if isinstance(next_access, (CodeBlock, Call, Kern)):
-                return False
-
             # If the access is a read, then return False
             if next_access.is_read:
                 return False

src/psyclone/tests/psyir/backend/fortran_gen_decls_test.py

@@ -252,9 +252,9 @@ def test_gen_decls(fortran_writer):
     with pytest.raises(VisitorError) as excinfo:
         _ = fortran_writer.gen_decls(symbol_table)
     assert ("The following symbols are not explicitly declared or imported "
-            "from a module and there are no wildcard "
-            "imports which could be bringing them into scope: "
-            "'unknown'" in str(excinfo.value))
+            "from a module and there are no wildcard imports, generic "
+            "interfaces or CodeBlocks which could be bringing them into scope:"
+            " 'unknown'" in str(excinfo.value))
 
 
 def test_gen_decls_char(fortran_writer):
@@ -347,9 +347,10 @@ def test_gen_decls_nested_scope(fortran_writer):
     # be brought into scope
     with pytest.raises(VisitorError) as err:
         fortran_writer.gen_decls(inner_table)
-    assert ("symbols are not explicitly declared or imported from a module "
-            "and there are no wildcard imports which "
-            "could be bringing them into scope: 'unknown1'" in str(err.value))
+    assert ("The following symbols are not explicitly declared or imported "
+            "from a module and there are no wildcard imports, generic "
+            "interfaces or CodeBlocks which could be bringing them into scope:"
+            " 'unknown1'" in str(err.value))
     # Add a ContainerSymbol with a wildcard import in the outermost scope
     csym = ContainerSymbol("other_mod")
     csym.wildcard_import = True

src/psyclone/tests/psyir/backend/fortran_test.py

@@ -958,18 +958,18 @@ def test_fw_filecontainer_2(fortran_writer):
 def test_fw_filecontainer_error1(fortran_writer):
     '''Check that an instance of the FortranWriter class raises the
     expected exception if the symbol table associated with a
-    FileContainer node contains any symbols.
+    FileContainer node contains any data symbols.
 
     '''
     symbol_table = SymbolTable()
-    symbol_table.add(Symbol("x"))
+    symbol_table.add(DataSymbol("x", ScalarType.integer_type()))
     file_container = FileContainer.create("None", symbol_table, [])
     with pytest.raises(VisitorError) as info:
         _ = fortran_writer(file_container)
     assert (
         "In the Fortran backend, a file container should not have any "
-        "symbols associated with it other than RoutineSymbols, but found "
-        "x: Symbol<Automatic>." in str(info.value))
+        "data symbols associated with it, but found x: DataSymbol"
+        in str(info.value))
 
     # Check that a routine symbol is fine.
     symbol_table = SymbolTable()