#1786 Actioned @TeranIvy changes

doc/user_guide/dynamo0p3.rst

@@ -3271,19 +3271,13 @@ elements, e.g. in Fortran this would be: ``Y = INT(X, kind=i_<prec>)``.
 Here ``Y`` is an ``integer``-valued field and ``X`` is the
 ``real``-valued field being converted::
 
-  ifield2(:) = INT(field1(:), kind=i_def)
+  ifield2(:) = INT(field1(:), kind=i_<prec>)
 
-where **ifield2** is the only currently supported ``integer_field_type``
-(``i_def`` precision) and a ``real``-valued field *field1* can be of
-any :ref:`supported precisions <lfric-mixed-precision>` for ``GH_REAL``
-fields (e.g. ``r_tran`` for ``r_tran_field_type``).
-
-Built-ins which take a ``real`` field element for conversion to
-a field of different datatype or precision prefixed with the keyword
-**real** and are denoted by the datatype that the input ``real`` field will
-be converted to. A Built-in that converts a ``real`` to an ``integer``
-field is denoted by the keyword **int**. Likewise, a Built-in that
-converts a ``real`` to a ``real`` field is denoted by the keyword **real**.
+where **ifield2** is currently the only supported ``integer``-valued field
+type in LFRic (``integer_field_type`` of ``i_def`` precision) and a ``real``
+-valued field *field1* can be of any :ref:`supported precisions
+<lfric-mixed-precision>` for ``GH_REAL`` fields (e.g. ``r_tran`` for
+``r_tran_field_type``).
 
 .. _real-to-real-built-in:
 
@@ -3298,12 +3292,19 @@ e.g. in Fortran this would be: ``Y = REAL(X, kind=r_<prec>)``. Here ``Y``
 and ``X`` are both ``real``-valued fields, with ``X`` being converted
 to the precision of ``Y``::
 
-field2(:) = REAL(field1(:), kind=r_<prec>)
+  field2(:) = REAL(field1(:), kind=r_<prec>)
 
 **field2** and *field1* are ``real``-valued fields of any :ref:`supported
 precisions <lfric-mixed-precision>` for ``GH_REAL`` fields (e.g. ``r_tran``
 for ``r_tran_field_type``).
 
+Built-ins which take a ``real`` field for conversion to a field of
+a different datatype or precision are denoted by the datatype that the
+input ``real`` field will be converted to. A Built-in that converts a
+``real`` to an ``integer`` field is denoted by the keyword **int**.
+Likewise, a Built-in that converts a ``real`` to a ``real`` field is 
+denoted by the keyword **real**.
+
 .. _lfric-built-ins-int:
 
 Built-in operations on ``integer``-valued fields
@@ -3604,7 +3605,8 @@ Here ``Y`` is a ``real``-valued field and ``X`` is the
 
   field2(:) = REAL(ifield1(:), kind=r_<prec>)
 
-where *ifield1* is an ``integer_field_type`` of ``i_def`` precision.
+where **ifield1** is currently the only supported ``integer``-valued
+field type in LFRic (``integer_field_type`` of ``i_def`` precision).
 The ``real``-valued **field1** can be of any :ref:`supported
 precisions <lfric-mixed-precision>` for ``GH_REAL`` fields, hence
 ``r_<prec>`` is determined from the algorithm layer (e.g.

src/psyclone/tests/domain/lfric/builtins/real_to_real_x_test.py

@@ -88,8 +88,6 @@ def test_real_to_real_x(tmpdir, monkeypatch, annexed, dist_mem):
     # Test code generation
     code = str(psy.gen)
 
-    print(code)
-
     # Check that the correct field types and constants are used
     output = (
         "    USE constants_mod, ONLY: r_tran, r_solver, r_def, i_def\n"
@@ -116,7 +114,7 @@ def test_real_to_real_x(tmpdir, monkeypatch, annexed, dist_mem):
         "      END DO\n"
         )
     assert output in code
-    
+
     # Check built-in loop for 'r_solver'
     output = (
         "      DO df=loop2_start,loop2_stop\n"

src/psyclone/tests/test_files/dynamo0p3/15.10.8_real_to_real_X_builtin.f90

@@ -47,8 +47,8 @@ program single_invoke
   type(r_tran_field_type)   :: f2
   type(r_solver_field_type) :: f3
 
-  call invoke( real_to_real_X(f2, f1),&
-               real_to_real_X(f1, f3),&
+  call invoke( real_to_real_X(f2, f1), &
+               real_to_real_X(f1, f3), &
                real_to_real_X(f3, f2) )
 
 end program single_invoke