#2642 Some codecov progress, some tests still missing.

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

@@ -224,28 +224,22 @@ def create_from_psyir(symbol):
 
         datatype = symbol.datatype
 
+        if not isinstance(datatype, StructureType):
+            raise InternalError(
+                f"Expected kernel metadata to be stored in the PSyIR as "
+                f"a StructureType, but found "
+                f"{type(datatype).__name__}.")
+
         # 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)
-            type_declaration = type_declaration.replace(", public", "")
-            type_declaration = type_declaration.replace(", private", "")
-            return GOceanKernelMetadata.create_from_fortran_string(
-                type_declaration)
-
-        if not isinstance(datatype, UnsupportedFortranType):
-            raise InternalError(
-                f"Expected kernel metadata to be stored in the PSyIR as "
-                f"an UnsupportedFortranType, but found "
-                f"{type(datatype).__name__}.")
-
-        # In an UnsupportedFortranType, the declaration is stored as a
-        # string, so use create_from_fortran_string()
+        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/psyir/backend/fortran.py

@@ -505,7 +505,8 @@ def gen_proceduredecl(self, symbol, include_visibility=True):
         :returns: the Fortran procedure declaration as a string.
         :rtype: str
 
-        :raises VisitorError: if the symbol is not a RoutineSymbol.
+        :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.
         '''
@@ -747,12 +748,6 @@ 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 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?")
-
         if not isinstance(symbol.datatype, StructureType):
             raise VisitorError(
                 f"gen_typedecl expects a DataTypeSymbol with a StructureType "

src/psyclone/psyir/frontend/fparser2.py

@@ -2028,18 +2028,8 @@ def _process_derived_type_decln(self, parent, decl, visibility_map):
             # We support derived-type definitions with a CONTAINS section.
             contains_blocks = walk(decl, Fortran2003.Type_Bound_Procedure_Part)
             if contains_blocks:
-                # First check there is only one CONTAINS section.
-                if len(contains_blocks) > 1:
-                    raise NotImplementedError(
-                        "Derived-type definition contains multiple CONTAINS "
-                        "statements.")
                 # Get it.
                 contains = contains_blocks[0]
-                # Check that it's indeed a CONTAINS statement.
-                if walk(contains, Fortran2003.Contains_Stmt) is None:
-                    raise NotImplementedError(
-                        "Derived-type definition contains a procedure "
-                        "without a CONTAINS statement.")
                 # Get all procedures in the CONTAINS section.
                 procedures = walk(contains, Fortran2003.Specific_Binding)
                 if procedures is None:

src/psyclone/tests/domain/gocean/kernel/gocean_kern_psyir_test.py

@@ -210,8 +210,8 @@ def test_goceankernelmetadata_create1(fortran_reader):
     symbol._datatype = REAL_TYPE
     with pytest.raises(InternalError) as info:
         _ = GOceanKernelMetadata.create_from_psyir(symbol)
-    assert ("Expected kernel metadata to be stored in the PSyIR as an "
-            "UnsupportedFortranType, but found ScalarType." in str(info.value))
+    assert ("Expected kernel metadata to be stored in the PSyIR as a "
+            "StructureType, but found ScalarType." in str(info.value))
 
 
 # create_from_fortran_string

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

@@ -373,8 +373,8 @@ def test_gen_typedecl_validation(fortran_writer, monkeypatch):
     tsymbol = DataTypeSymbol("my_type", UnresolvedType())
     with pytest.raises(VisitorError) as err:
         fortran_writer.gen_typedecl(tsymbol)
-    assert ("Local Symbol 'my_type' is of UnresolvedType and therefore no "
-            "declaration can be created for it." in str(err.value))
+    assert ("gen_typedecl expects a DataTypeSymbol with a StructureType "
+            "as its datatype but got: 'UnresolvedType'" in str(err.value))
 
 
 def test_gen_typedecl_unsupported_fortran_type(fortran_writer):
@@ -760,6 +760,10 @@ def test_fw_gen_vardecl_visibility(fortran_writer):
                       "end type var\n")
 
 
+def test_fw_gen_proceduredecl(fortran_writer):
+    pass
+
+
 def test_gen_default_access_stmt(fortran_writer):
     '''
     Tests for the gen_default_access_stmt method of FortranWriter.

src/psyclone/tests/psyir/symbols/data_type_symbol_test.py

@@ -60,6 +60,16 @@ def test_create_datatypesymbol_wrong_datatype():
         sym.datatype = "integer"
     assert ("datatype of a DataTypeSymbol must be specified using a "
             "DataType but got: 'str'" in str(err.value))
+
+
+def test_create_datatypesymbol_wrong_is_class():
+    ''' Check that attempting to specify the is_class attribute of a
+    DataTypeSymbol with an invalid type results in the expected error. '''
+    sym = DataTypeSymbol("my_type", UnresolvedType())
+    with pytest.raises(TypeError) as err:
+        sym.is_class = "integer"
+    assert ("The is_class attribute of a DataTypeSymbol must be a bool "
+            "but got: 'str'" in str(err.value))
 
 
 def test_datatypesymbol_copy():