(Closes #2612) add support for length and precision attributes in character type

doc/developer_guide/psyir_symbols.rst

@@ -80,19 +80,16 @@ explicitly listed may be assumed to be unsupported):
 +======================+====================+====================+
 |Variables             |ALLOCATABLE         |CLASS               |
 +----------------------+--------------------+--------------------+
-|                      |CHARACTER, DOUBLE   |COMPLEX, CHARACTER  |
-|                      |PRECISION, INTEGER, |with LEN or KIND    |
+|                      |CHARACTER, DOUBLE   |COMPLEX             |
+|                      |PRECISION, INTEGER, |                    |
 |                      |LOGICAL, REAL       |                    |
 +----------------------+--------------------+--------------------+
 |                      |Derived Types       |'extends',          |
 |                      |                    |'abstract' or with  |
 |                      |                    |CONTAINS; Operator  |
 |                      |                    |overloading         |
 +----------------------+--------------------+--------------------+
-|                      |DIMENSION           |Array extents       |
-|                      |                    |specified using     |
-|                      |                    |expressions;        |
-|                      |                    |Assumed-size arrays |
+|                      |DIMENSION           |Assumed-size arrays |
 +----------------------+--------------------+--------------------+
 |                      |INTENT, PARAMETER,  |VOLATILE, VALUE,    |
 |                      |SAVE                |POINTER             |
@@ -102,8 +99,8 @@ explicitly listed may be assumed to be unsupported):
 +----------------------+--------------------+--------------------+
 |                      |PUBLIC, PRIVATE     |                    |
 +----------------------+--------------------+--------------------+
-|Initialisation        |Explicit            |                    |
-|expressions           |initialisation      |                    |
+|Initialisation        |Explicit            | Implicit loops,    |
+|expressions           |initialisation      | array constructors |
 +----------------------+--------------------+--------------------+
 |                      |Data statements     |                    |
 |                      |(limited)           |                    |

src/psyclone/psyir/backend/fortran.py

@@ -40,6 +40,8 @@
 from a PSyIR tree. '''
 
 # pylint: disable=too-many-lines
+from typing import Union
+
 from psyclone.configuration import Config
 from psyclone.errors import InternalError
 from psyclone.psyir.backend.language_writer import LanguageWriter
@@ -48,13 +50,13 @@
     Fparser2Reader, TYPE_MAP_FROM_FORTRAN)
 from psyclone.psyir.nodes import (
     BinaryOperation, Call, Container, CodeBlock, DataNode, IntrinsicCall,
-    Literal, Node, OMPDependClause, OMPReductionClause, Operation, Range,
-    Routine, Schedule, UnaryOperation)
+    Literal, Member, Node, OMPDependClause, OMPReductionClause, Operation,
+    Range, Routine, Schedule, UnaryOperation)
 from psyclone.psyir.symbols import (
-    ArgumentInterface, ArrayType, ContainerSymbol, DataSymbol, DataTypeSymbol,
-    GenericInterfaceSymbol, IntrinsicSymbol, PreprocessorInterface,
-    RoutineSymbol, ScalarType, StructureType, Symbol, SymbolTable,
-    UnresolvedInterface, UnresolvedType, UnsupportedFortranType,
+    ArgumentInterface, ArrayType, ContainerSymbol, DataSymbol, DataType,
+    DataTypeSymbol, GenericInterfaceSymbol, IntrinsicSymbol,
+    PreprocessorInterface, RoutineSymbol, ScalarType, StructureType, Symbol,
+    SymbolTable, UnresolvedInterface, UnresolvedType, UnsupportedFortranType,
     UnsupportedType, TypedSymbol)
 
 
@@ -263,30 +265,26 @@ def _reverse_map(reverse_dict, op_map):
             if mapping_key not in reverse_dict:
                 reverse_dict[mapping_key] = mapping_value.upper()
 
-    def gen_datatype(self, datatype, name):
+    def gen_datatype(self,
+                     datatype: Union[DataType, DataTypeSymbol],
+                     name: str) -> str:
         '''Given a DataType instance as input, return the Fortran datatype
         of the symbol including any specific precision properties.
 
         :param datatype: the DataType or DataTypeSymbol describing the type of
                          the declaration.
-        :type datatype: :py:class:`psyclone.psyir.symbols.DataType` or
-                        :py:class:`psyclone.psyir.symbols.DataTypeSymbol`
-        :param str name: the name of the symbol being declared (only used for
-                         error messages).
+        :param name: the name of the symbol being declared (only used for
+                     error messages).
 
         :returns: the Fortran representation of the symbol's datatype
                   including any precision properties.
-        :rtype: str
 
         :raises NotImplementedError: if the symbol has an unsupported
             datatype.
         :raises VisitorError: if the symbol specifies explicit precision
             and this is not supported for the datatype.
         :raises VisitorError: if the size of the explicit precision is not
             supported for the datatype.
-        :raises VisitorError: if the size of the symbol is specified by
-            another variable and the datatype is not one that supports the
-            Fortran KIND option.
         :raises NotImplementedError: if the type of the precision object
             is an unsupported type.
 
@@ -296,9 +294,9 @@ def gen_datatype(self, datatype, name):
             return f"type({datatype.name})"
 
         if (isinstance(datatype, ArrayType) and
-                isinstance(datatype.intrinsic, DataTypeSymbol)):
+                isinstance(datatype.elemental_type, DataTypeSymbol)):
             # Symbol is an array of derived types
-            return f"type({datatype.intrinsic.name})"
+            return f"type({datatype.elemental_type.name})"
 
         try:
             fortrantype = TYPE_MAP_TO_FORTRAN[datatype.intrinsic]
@@ -308,6 +306,10 @@ def gen_datatype(self, datatype, name):
                 f"'{name}' found in gen_datatype().") from error
 
         precision = datatype.precision
+        if isinstance(datatype, ArrayType):
+            scalar_type = datatype.elemental_type
+        else:
+            scalar_type = datatype
 
         if isinstance(precision, int):
             if fortrantype not in ['real', 'integer', 'logical']:
@@ -330,6 +332,16 @@ def gen_datatype(self, datatype, name):
             # ISO_FORTRAN_ENV; type(type64) :: MyType.
             return f"{fortrantype}*{precision}"
 
+        len_str = ""
+        if scalar_type.intrinsic == ScalarType.Intrinsic.CHARACTER:
+            # Include length information for a character type.
+            if scalar_type.length == ScalarType.CharLengthParameter.ASTERISK:
+                len_str = "*"
+            elif scalar_type.length == ScalarType.CharLengthParameter.COLON:
+                len_str = ":"
+            else:
+                len_str = self._visit(scalar_type.length).strip()
+
         if isinstance(precision, ScalarType.Precision):
             # The precision information is not absolute so is either
             # machine specific or is specified via the compiler. Fortran
@@ -342,16 +354,18 @@ def gen_datatype(self, datatype, name):
                     f"ScalarType.Precision.DOUBLE is not supported for "
                     f"datatypes other than floating point numbers in "
                     f"Fortran, found '{fortrantype}'")
+            if len_str:
+                return f"{fortrantype}(len={len_str})"
             return fortrantype
 
         if isinstance(precision, DataNode):
-            if fortrantype not in ["real", "integer", "logical"]:
-                raise VisitorError(
-                    f"kind not supported for datatype '{fortrantype}' in "
-                    f"symbol '{name}' in Fortran backend.")
+            len_txt = ""
+            if len_str:
+                len_txt = f", len={len_str}"
             # The precision information is provided by a parameter,
             # so use KIND.
-            return f"{fortrantype}(kind={self._visit(precision)})"
+            return (f"{fortrantype}(kind={self._visit(precision).strip()}"
+                    f"{len_txt})")
 
         raise VisitorError(
             f"Unsupported precision type '{type(precision).__name__}' found "
@@ -499,18 +513,17 @@ def gen_use(self, symbol, symbol_table):
                     f"{renames}\n")
         return f"{self._nindent}use{intrinsic_str}{symbol.name}\n"
 
-    def gen_vardecl(self, symbol, include_visibility=False):
+    def gen_vardecl(self,
+                    symbol: Union[DataSymbol, Member],
+                    include_visibility: bool = False) -> str:
         '''Create and return the Fortran variable declaration for this Symbol
         or derived-type member.
 
         :param symbol: the symbol or member instance.
-        :type symbol: :py:class:`psyclone.psyir.symbols.DataSymbol` or
-            :py:class:`psyclone.psyir.nodes.MemberReference`
-        :param bool include_visibility: whether to include the visibility of
+        :param include_visibility: whether to include the visibility of
             the symbol in the generated declaration (default False).
 
         :returns: the Fortran variable declaration as a string.
-        :rtype: str
 
         :raises VisitorError: if the symbol is not typed.
         :raises VisitorError: if the symbol is of UnresolvedType.