(towards #3124) Codeblocks with children references

src/psyclone/psyir/backend/fortran.py

@@ -985,14 +985,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.
@@ -1074,19 +1076,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

@@ -3379,7 +3379,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 = (
@@ -3440,7 +3440,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

@@ -47,12 +47,16 @@
 from psyclone.core import AccessType, Signature, VariablesAccessMap
 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):
     '''Node representing some generic Fortran code that PSyclone does not
-    attempt to manipulate. As such it is a leaf in the PSyIR and therefore
-    has no children.
+    attempt to manipulate. It has a child Reference for each symbol used in
+    the CodeBlock.
 
     :param fp2_nodes: the fparser2 parse-tree nodes representing the
         Fortran code constituting the code block.
@@ -69,7 +73,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.
@@ -105,6 +109,35 @@ def __init__(self, fp2_nodes, structure, parent=None, annotations=None):
             self.ast_end = None
         # 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))
 
     def __eq__(self, other):
         '''
@@ -186,12 +219,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).
@@ -235,20 +282,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):

src/psyclone/psyir/nodes/reference.py

@@ -119,6 +119,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.
@@ -133,6 +134,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

@@ -481,16 +481,18 @@ def _compute_forward_uses(self, basic_block_list: list[Node]):
                         if defs_out is not None:
                             self._defsout.append(defs_out)
                         return
-                    if (
-                        self._reference.symbol.name
-                        in reference.get_symbol_names()
-                    ):
-                        # Assume the worst for a CodeBlock and we count them
-                        # as killed and defsout and uses.
-                        if defs_out is not None:
-                            self._killed.append(defs_out)
-                        defs_out = reference
-                        continue
+                    for child in reference.children:
+                        if self._reference.symbol is child.symbol:
+                            # It refers to this symbol, assume the worst and
+                            # consider it defout and killed
+                            if defs_out is not None:
+                                self._killed.append(defs_out)
+                            defs_out = child
+                            break
+                elif isinstance(reference.parent, CodeBlock):
+                    # We have already dealt with References inside Codeblocks
+                    # above, so skip this reference
+                    pass
                 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.
@@ -764,16 +766,18 @@ def _compute_backward_uses(self, basic_block_list: list[Node]):
                             "DefinitionUseChains can't handle code containing"
                             " GOTO statements."
                         )
-                    if (
-                        self._reference.symbol.name
-                        in reference.get_symbol_names()
-                    ):
-                        # Assume the worst for a CodeBlock and we count them
-                        # as killed and defsout and uses.
-                        if defs_out is not None:
-                            self._killed.append(defs_out)
-                        defs_out = reference
-                        continue
+                    for child in reference.children:
+                        if self._reference.symbol is child.symbol:
+                            # It refers to this symbol, assume the worst and
+                            # consider it defout and killed
+                            if defs_out is not None:
+                                self._killed.append(defs_out)
+                            defs_out = child
+                            break
+                elif isinstance(reference.parent, CodeBlock):
+                    # We have already dealt with References inside Codeblocks
+                    # above, so skip this reference
+                    pass
                 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

@@ -1161,7 +1161,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

@@ -38,9 +38,9 @@
 from typing import Optional, Dict, Any, List, Tuple
 
 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, INTEGER_TYPE
 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
@@ -389,6 +376,7 @@ def apply(self, node: Loop, options: Optional[Dict[str, Any]] = None) \
         :param options: a dictionary with options for transformations.
 
         '''
+        self.validate(node)
         # For each array reference in the Loop:
         # Find every access to the same symbol in the loop
         # They all have to be accessed with the same index statement, and

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

@@ -163,7 +163,7 @@ def test_gen_param_decls_case_insensitive(fortran_reader,
         "integer(kind=an_int), parameter :: a_second_int = 5_i_def\n"
         "integer, parameter :: nfieldnames3d = 4\n"
         "integer, dimension(nfieldnames3d), parameter :: "
-        "interpolationlevels = [2, 0, HUGE(InterpolationLevels) / 3, 0]\n")
+        "InterpolationLevels = [2, 0, HUGE(InterpolationLevels) / 3, 0]\n")
 
 
 def test_gen_decls(fortran_writer):
@@ -250,9 +250,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_array(fortran_writer):
@@ -300,9 +300,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

@@ -950,18 +950,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", 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()