Corrected bug

Author: mzecc

Makefile

@@ -52,8 +52,8 @@ test:  ## run the tests (re-installs the package every time so you might want to
 	uv run --no-sync python scripts/inject-srcs-into-meson-build.py
 	uv run --no-sync python -c 'from pathlib import Path; import example_fgen_basic' || ( echo "Run make virtual-environment first" && false )
 	COV_DIR=$$(uv run --no-sync python -c 'from pathlib import Path; import example_fgen_basic; print(Path(example_fgen_basic.__file__).parent)'); \
-		# uv run --no-editable --reinstall-package example-fgen-basic pytest -s -r a -v tests/unit/test_result_dp.py --doctest-modules --doctest-report ndiff --cov=$$COV_DIR
-		uv run --no-editable --reinstall-package example-fgen-basic pytest -s -r a -v tests/unit/test_result_dp.py src --doctest-modules --doctest-report ndiff --cov=$$COV_DIR
+		uv run --no-editable --reinstall-package example-fgen-basic pytest -s -r a -v tests src --doctest-modules --doctest-report ndiff --cov=$$COV_DIR
+		# uv run --no-editable --reinstall-package example-fgen-basic pytest -s -r a -v tests/unit/test_result_dp.py src --doctest-modules --doctest-report ndiff --cov=$$COV_DIR
 
 # Note on code coverage and testing:
 # You must specify cov=src.

src/example_fgen_basic/error_v/creation.py

@@ -53,7 +53,6 @@ def create_error(inv: int) -> ErrorV:
 
     # Initialise the result from the received index
     res = ErrorV.from_instance_index(instance_index)
-
     # Tell Fortran to finalise the object on the Fortran side
     # (all data has been copied to Python now)
     m_error_v_w.finalise_instance(instance_index)

src/example_fgen_basic/error_v/creation_wrapper.f90

@@ -74,7 +74,7 @@ function create_errors(invs, n) result(res_instance_indexes)
         ! This is the major trick for wrapping.
         ! We return instance indexes (integers) to Python rather than the instance itself.
         type(ErrorV) :: err
-        type(ErrorV), dimension(n) :: res
+        type(ErrorV), allocatable, dimension(:) :: res
 
         integer :: i, tmp
 
@@ -83,7 +83,13 @@ function create_errors(invs, n) result(res_instance_indexes)
         ! Just do something stupid for now to see the pattern.
         call error_v_manager_ensure_instance_array_size_is_at_least(n)
 
+        allocate(res(n))
         ! Do the Fortran call
+        ! MZ: somenthing funny happens wheb res is an automatic array and
+        ! not an allocatable one. LLMs and internet resorces I found are not
+        ! completely clear to me. What seems to happen is that returning an array of derived types with allocatable
+        ! components may generate hidden temporary arrays whose allocatable components
+        ! become undefined (or the heap address gets corrupted) after the function returns.
         res = o_create_errors(invs, n)
 
         do i = 1, n

src/example_fgen_basic/error_v/error_v.f90

@@ -22,6 +22,7 @@ module m_error_v
         !! Error code
 
         character(len=:), allocatable :: message
+
         !! Error message
         ! TODO: think about making the message allocatable to handle long messages
 

src/example_fgen_basic/error_v/error_v.py

@@ -53,7 +53,6 @@ def from_instance_index(cls, instance_index: int) -> ErrorV:
 
         # Integer is very simple
         code = m_error_v_w.get_code(instance_index)
-
         # String requires decode
         message = m_error_v_w.get_message(instance_index).decode()
 

src/example_fgen_basic/error_v/error_v_manager.f90

@@ -103,7 +103,9 @@ function get_instance(instance_index) result(err_inst)
         err_check_index_claimed = check_index_claimed(instance_index)
 
         if (err_check_index_claimed % code == 0) then
+
             err_inst = instance_array(instance_index)
+
         else
             write(idx_str, "(I0)") instance_index
             msg = "Error at get_instance -> " // trim(adjustl(idx_str))
@@ -130,8 +132,6 @@ function set_instance_index_to(instance_index, val) result(err)
 
         err_check_index_claimed = check_index_claimed(instance_index)
 
-        instance_array(instance_index) = val
-
         if(err_check_index_claimed%code /= NO_ERROR_CODE) then
             ! MZ: here we do not set if the index has not been claimed.
             ! Must be harmonised with Results type
@@ -149,6 +149,7 @@ function set_instance_index_to(instance_index, val) result(err)
             ! But calling finalise(): guarantees immediate release, handles non-allocatable resources,
             ! avoids temporary double memory
             call instance_array(instance_index)%finalise()
+
             ! Reassigning the slot
             call instance_array(instance_index)%build(code=val%code, message=val%message, cause=val%cause)
 

src/example_fgen_basic/error_v/error_v_wrapper.f90

@@ -118,13 +118,19 @@ subroutine get_message( &
         integer, intent(in) :: instance_index
 
         ! TODO: make this variable length
+        ! MZ attempts to put allocatable lead to segfault
         character(len=128), intent(out) :: message
 
         type(ErrorV)  :: instance
 
         instance = error_v_manager_get_instance(instance_index)
 
-        message = instance % message
+        if (allocated(instance%message)) then
+            message = instance % message
+!        else !MZ what to do??
+!!            message = "Invalid query: message not allocated"
+!            message = ""
+        end if
 
     end subroutine get_message
 

src/example_fgen_basic/result/result_dp_wrapper.f90

@@ -187,7 +187,7 @@ end function data_v_is_set
     function get_data_v(instance_index) result(data_v)
 
         integer, intent(in) :: instance_index
-
+        integer, parameter :: dp = selected_real_kind(15, 307)
         real(kind=dp) :: data_v
 
         type(ResultDP)  :: instance

tests/unit/test_error_v_creation.py

@@ -48,12 +48,11 @@ def test_create_error_lots_of_repeated_calls():
 
 def test_create_multiple_errors():
     res = create_errors(np.arange(6))
+
     for i, v in enumerate(res):
         if i % 2 == 0:
-            print(v.code, v.message)
             assert v.code == 1
             assert v.message == "Even number supplied"
         else:
-            print(v.code, v.message)
             assert v.code == 0
             assert v.message == ""