(Closes #2642, initial step towards #2643) Implement extends(type), procedure in derived type, class in declarations.

doc/developer_guide/psyir_symbols.rst

@@ -78,16 +78,15 @@ explicitly listed may be assumed to be unsupported):
 +----------------------+--------------------+--------------------+
 |                      |Supported           |Unsupported         |
 +======================+====================+====================+
-|Variables             |ALLOCATABLE         |CLASS               |
+|Variables             |ALLOCATABLE, CLASS  |                    |
 +----------------------+--------------------+--------------------+
 |                      |CHARACTER, DOUBLE   |COMPLEX, CHARACTER  |
 |                      |PRECISION, INTEGER, |with LEN or KIND    |
 |                      |LOGICAL, REAL       |                    |
 +----------------------+--------------------+--------------------+
-|                      |Derived Types       |'extends',          |
-|                      |                    |'abstract' or with  |
-|                      |                    |CONTAINS; Operator  |
-|                      |                    |overloading         |
+|                      |Derived Types,      |'abstract',         |
+|                      |'extends',          |operator overloading|
+|                      |CONTAINS            |                    |
 +----------------------+--------------------+--------------------+
 |                      |DIMENSION           |Array extents       |
 |                      |                    |specified using     |

src/psyclone/domain/gocean/kernel/psyir.py

@@ -50,8 +50,10 @@
 from psyclone.errors import InternalError
 from psyclone.parse.utils import ParseError
 from psyclone.psyir.frontend.fortran import FortranReader
+from psyclone.psyir.backend.fortran import FortranWriter
 from psyclone.psyir.nodes import Container
-from psyclone.psyir.symbols import DataTypeSymbol, UnsupportedFortranType
+from psyclone.psyir.symbols import DataTypeSymbol, UnsupportedFortranType, \
+                                   StructureType
 
 
 class GOceanContainer(Container):
@@ -222,16 +224,22 @@ def create_from_psyir(symbol):
 
         datatype = symbol.datatype
 
-        if not isinstance(datatype, UnsupportedFortranType):
+        if not isinstance(datatype, StructureType):
             raise InternalError(
                 f"Expected kernel metadata to be stored in the PSyIR as "
-                f"an UnsupportedFortranType, but found "
+                f"a StructureType, but found "
                 f"{type(datatype).__name__}.")
 
-        # In an UnsupportedFortranType, the declaration is stored as a
-        # string, so use create_from_fortran_string()
+        # TODO #2643: This is a temporary solution using FortranWriter
+        # to allow the current metadata extraction to work with StructureType,
+        # instead of relying on UnsupportedFortranType.
+        # This will be removed when the metadata is extracted from the PSyIR
+        # itself.
+        type_declaration = FortranWriter().gen_typedecl(symbol)
+        type_declaration = type_declaration.replace(", public", "")
+        type_declaration = type_declaration.replace(", private", "")
         return GOceanKernelMetadata.create_from_fortran_string(
-            datatype.declaration)
+            type_declaration)
 
     @staticmethod
     def create_from_fortran_string(fortran_string):

src/psyclone/domain/lfric/kernel/lfric_kernel_metadata.py

@@ -75,7 +75,9 @@
 from psyclone.errors import InternalError
 from psyclone.parse.utils import ParseError
 from psyclone.psyir.frontend.fortran import FortranReader
-from psyclone.psyir.symbols import DataTypeSymbol, UnsupportedFortranType
+from psyclone.psyir.backend.fortran import FortranWriter
+from psyclone.psyir.symbols import DataTypeSymbol, UnsupportedFortranType, \
+                                   StructureType
 
 # pylint: disable=too-many-lines
 # pylint: disable=too-many-instance-attributes
@@ -698,6 +700,16 @@ def create_from_psyir(symbol):
 
         datatype = symbol.datatype
 
+        # TODO #2643: This is a temporary solution using FortranWriter
+        # to allow the current metadata extraction to work with StructureType,
+        # instead of relying on UnsupportedFortranType.
+        # This will be removed when the metadata is extracted from the PSyIR
+        # itself.
+        if isinstance(datatype, StructureType):
+            type_declaration = FortranWriter().gen_typedecl(symbol, False)
+            return LFRicKernelMetadata.create_from_fortran_string(
+                type_declaration)
+
         if not isinstance(datatype, UnsupportedFortranType):
             raise InternalError(
                 f"Expected kernel metadata to be stored in the PSyIR as "

src/psyclone/psyGen.py

@@ -60,7 +60,8 @@
                                     UnresolvedType,
                                     ImportInterface, INTEGER_TYPE,
                                     RoutineSymbol, Symbol)
-from psyclone.psyir.symbols.datatypes import UnsupportedFortranType
+from psyclone.psyir.symbols.datatypes import (UnsupportedFortranType,
+                                              StructureType)
 
 # The types of 'intent' that an argument to a Fortran subroutine
 # may have
@@ -1753,6 +1754,8 @@ def _rename_psyir(self, suffix):
         # the kernel metadata.
         container_table = container.symbol_table
         for sym in container_table.datatypesymbols:
+            # Either the DataTypeSymbol is of UnsupportedFortranType,
+            # in which case we replace in its whole declaration.
             if isinstance(sym.datatype, UnsupportedFortranType):
                 new_declaration = sym.datatype.declaration.replace(
                     orig_kern_name, new_kern_name)
@@ -1761,6 +1764,46 @@ def _rename_psyir(self, suffix):
                     new_declaration,
                     partial_datatype=sym.datatype.partial_datatype)
                 # pylint: enable=protected-access
+            # Or the DataTypeSymbol is a StructureType, in which case we
+            # go through its procedure components.
+            elif isinstance(sym.datatype, StructureType):
+                for procedure_name, procedure_component \
+                 in sym.datatype.procedure_components.items():
+                    # Either the procedure component is of
+                    # UnsupportedFortranType, in which case we replace in its
+                    # whole declaration.
+                    if isinstance(procedure_component.datatype,
+                                  UnsupportedFortranType):
+                        new_declaration = \
+                            procedure_component.datatype.declaration.replace(
+                                orig_kern_name, new_kern_name)
+                        new_procedure_component = StructureType.ComponentType(
+                            procedure_component.name,
+                            UnsupportedFortranType(new_declaration,
+                                                   procedure_component.
+                                                   datatype.partial_datatype),
+                            procedure_component.visibility,
+                            procedure_component.initial_value)
+                        sym.datatype.procedure_components[procedure_name] = \
+                            new_procedure_component
+                    # Or the procedure component has an initial value that is
+                    # a Reference to the original kernel name, in which case
+                    # we replace it with a Reference to the new kernel name.
+                    elif (procedure_component.initial_value is not None
+                            and (procedure_component.initial_value.name.lower()
+                                 == orig_kern_name.lower())):
+                        new_kernel_symbol = RoutineSymbol(new_kern_name)
+                        new_procedure_component = \
+                            StructureType.ComponentType(procedure_component
+                                                        .name,
+                                                        procedure_component
+                                                        .datatype,
+                                                        procedure_component
+                                                        .visibility,
+                                                        Reference(
+                                                            new_kernel_symbol))
+                        sym.datatype.procedure_components[procedure_name] = \
+                            new_procedure_component
 
     @property
     def modified(self):

src/psyclone/psyad/domain/lfric/lfric_adjoint.py

@@ -52,7 +52,7 @@
 from psyclone.psyad import AdjointVisitor
 from psyclone.psyad.domain.common import create_adjoint_name
 from psyclone.psyir.nodes import Routine
-from psyclone.psyir.symbols import ContainerSymbol, UnsupportedFortranType
+from psyclone.psyir.symbols import (ContainerSymbol, StructureType)
 from psyclone.psyir.symbols.symbol import ArgumentInterface, ImportInterface
 
 
@@ -80,8 +80,9 @@ def generate_lfric_adjoint(tl_psyir, active_variables):
     # linear kernel.
     tl_container = find_container(tl_psyir)
     for sym in tl_container.symbol_table.datatypesymbols:
-        if (isinstance(sym.datatype, UnsupportedFortranType) and
-                "extends(kernel_type)" in sym.datatype.declaration.lower()):
+        if (isinstance(sym.datatype, StructureType) and
+            sym.datatype.extends is not None and
+                sym.datatype.extends.name.lower() == "kernel_type"):
             tl_metadata_name = sym.name
             break
     else:

src/psyclone/psyir/backend/fortran.py

@@ -122,11 +122,15 @@ def gen_datatype(datatype, name):
     '''
     if isinstance(datatype, DataTypeSymbol):
         # Symbol is of derived type
+        if datatype.is_class:
+            return f"class({datatype.name})"
         return f"type({datatype.name})"
 
     if (isinstance(datatype, ArrayType) and
             isinstance(datatype.intrinsic, DataTypeSymbol)):
         # Symbol is an array of derived types
+        if datatype.intrinsic.is_class:
+            return f"class({datatype.intrinsic.name})"
         return f"type({datatype.intrinsic.name})"
 
     try:
@@ -488,6 +492,54 @@ def gen_use(self, symbol, symbol_table):
 
         return f"{self._nindent}use{intrinsic_str}{symbol.name}\n"
 
+    def gen_proceduredecl(self, symbol, include_visibility=True):
+        '''Create and return the Fortran procedure declaration for this Symbol.
+
+        :param symbol: the symbol instance.
+        :type symbol: Union[:py:class:`psyclone.psyir.symbols.DataSymbol`,
+                            :py:class:`psyclone.psyir.symbols.datatypes.
+                                            StructureType.ComponentType`]
+        :param bool include_visibility: whether to include the visibility of
+            the symbol in the generated declaration (default True).
+
+        :returns: the Fortran procedure declaration as a string.
+        :rtype: str
+
+        :raises VisitorError: if the symbol is not a RoutineSymbol or a
+                              StructureType.ComponentType.
+        :raises InternalError: if the visibility is to be included but is
+                               neither PUBLIC nor PRIVATE.
+        '''
+        if not isinstance(symbol, (DataSymbol, StructureType.ComponentType)):
+            raise VisitorError(
+                f"gen_proceduredecl() expects a 'DataSymbol' or "
+                f"'StructureType.ComponentType' as its first "
+                f"argument but got '{type(symbol).__name__}'")
+
+        if isinstance(symbol.datatype, UnsupportedFortranType):
+            return f"{self._nindent}{symbol.datatype.declaration}\n"
+
+        result = f"{self._nindent}procedure"
+
+        if include_visibility:
+            if symbol.visibility == Symbol.Visibility.PRIVATE:
+                result += ", private"
+            elif symbol.visibility == Symbol.Visibility.PUBLIC:
+                result += ", public"
+            else:
+                raise InternalError(
+                    f"A Symbol must be either public or private but symbol "
+                    f"'{symbol.name}' has visibility '{symbol.visibility}'")
+
+        # Specify name
+        result += f" :: {symbol.name}"
+
+        # Specify initialisation expression
+        if symbol.initial_value:
+            result += " => " + self._visit(symbol.initial_value)
+
+        return result + "\n"
+
     def gen_vardecl(self, symbol, include_visibility=False):
         '''Create and return the Fortran variable declaration for this Symbol
         or derived-type member.
@@ -696,8 +748,17 @@ def gen_typedecl(self, symbol, include_visibility=True):
                 f"Fortran backend cannot generate code for symbol "
                 f"'{symbol.name}' of type '{type(symbol.datatype).__name__}'")
 
+        if not isinstance(symbol.datatype, StructureType):
+            raise VisitorError(
+                f"gen_typedecl expects a DataTypeSymbol with a StructureType "
+                f"as its datatype but got: '{type(symbol.datatype).__name__}'")
+
         result = f"{self._nindent}type"
 
+        if symbol.datatype.extends:
+            # This is a component of a derived type
+            result += f", extends({symbol.datatype.extends.name})"
+
         if include_visibility:
             if symbol.visibility == Symbol.Visibility.PRIVATE:
                 result += ", private"
@@ -710,12 +771,6 @@ def gen_typedecl(self, symbol, include_visibility=True):
                     f"type '{type(symbol.visibility).__name__}'")
         result += f" :: {symbol.name}\n"
 
-        if isinstance(symbol.datatype, UnresolvedType):
-            raise VisitorError(
-                f"Local Symbol '{symbol.name}' is of UnresolvedType and "
-                f"therefore no declaration can be created for it. Should it "
-                f"have an ImportInterface?")
-
         self._depth += 1
 
         for member in symbol.datatype.components.values():
@@ -724,6 +779,14 @@ def gen_typedecl(self, symbol, include_visibility=True):
             # part of a module.
             result += self.gen_vardecl(member,
                                        include_visibility=include_visibility)
+        if len(symbol.datatype.procedure_components) > 0:
+            result += f"{self._nindent}contains\n"
+            self._depth += 1
+            for procedure in symbol.datatype.procedure_components.values():
+                result += self.gen_proceduredecl(procedure,
+                                                 include_visibility)
+            self._depth -= 1
+
         self._depth -= 1
 
         result += f"{self._nindent}end type {symbol.name}\n"
@@ -947,7 +1010,9 @@ def gen_decls(self, symbol_table, is_module_scope=False):
         unresolved_symbols = []
         for sym in all_symbols[:]:
             if isinstance(sym.interface, UnresolvedInterface):
-                unresolved_symbols.append(sym)
+                # Explicitly deal with '*' as in 'class(*) :: var'
+                if sym.name != "*":
+                    unresolved_symbols.append(sym)
                 all_symbols.remove(sym)
         try:
             internal_interface_symbol = symbol_table.lookup(