Update parsing: to detect subprograms outside modules

Sources files are only designated as FPM_UNIT_MODULE if they only contain modules. Non-program sources that contain subprograms not in modules are designated as FPM_UNIT_SUBPROGRAM.

Author: LKedward

src/fpm_model.f90

@@ -14,6 +14,23 @@
 !> __Source type:__ `FPM_UNIT_*`
 !> Describes the type of source file — determines build target generation
 !>
+!> The logical order of precedence for assigning `unit_type` is as follows:
+!>
+!>```
+!> if source-file contains program then
+!>   unit_type = FPM_UNIT_PROGRAM
+!> else if source-file contains non-module subroutine/function then
+!>   unit_type = FPM_UNIT_SUBPROGRAM
+!> else if source-file contains submodule then
+!>   unit_type = FPM_UNIT_SUBMODULE
+!> else if source-file contains module then
+!>   unit_type = FPM_UNIT_MODULE
+!> end if
+!>```
+!>
+!> @note A source file is only designated `FPM_UNIT_MODULE` if it **only** contains modules - no non-module subprograms.
+!> (This allows tree-shaking/pruning of build targets based on unused module dependencies.)
+!>
 !> __Source scope:__ `FPM_SCOPE_*`
 !> Describes the scoping rules for using modules — controls module dependency resolution
 !>
@@ -34,13 +51,13 @@ module fpm_model
 
 !> Source type unknown
 integer, parameter :: FPM_UNIT_UNKNOWN = -1
-!> Source type is fortran program
+!> Source contains a fortran program
 integer, parameter :: FPM_UNIT_PROGRAM = 1
-!> Source type is fortran module
+!> Source **only** contains one or more fortran modules
 integer, parameter :: FPM_UNIT_MODULE = 2
-!> Source type is fortran submodule
+!> Source contains one or more fortran submodules
 integer, parameter :: FPM_UNIT_SUBMODULE = 3
-!> Source type is fortran subprogram
+!> Source contains one or more fortran subprogram not within modules
 integer, parameter :: FPM_UNIT_SUBPROGRAM = 4
 !> Source type is c source file
 integer, parameter :: FPM_UNIT_CSOURCE = 5

src/fpm_source_parsing.f90

@@ -76,6 +76,7 @@ function parse_f_source(f_filename,error) result(f_source)
     type(srcfile_t) :: f_source
     type(error_t), allocatable, intent(out) :: error
 
+    logical :: inside_module
     integer :: stat
     integer :: fh, n_use, n_include, n_mod, i, j, ic, pass
     type(string_t), allocatable :: file_lines(:), file_lines_lower(:)
@@ -103,6 +104,7 @@ function parse_f_source(f_filename,error) result(f_source)
         n_use = 0
         n_include = 0
         n_mod = 0
+        inside_module = .false.
         file_loop: do i=1,size(file_lines_lower)
 
             ! Skip comment lines
@@ -242,7 +244,11 @@ function parse_f_source(f_filename,error) result(f_source)
                     f_source%modules_provided(n_mod) = string_t(mod_name)
                 end if
 
-                f_source%unit_type = FPM_UNIT_MODULE
+                if (f_source%unit_type == FPM_UNIT_UNKNOWN) then
+                    f_source%unit_type = FPM_UNIT_MODULE
+                end if
+
+                inside_module = .true.
 
                 cycle
 
@@ -274,11 +280,15 @@ function parse_f_source(f_filename,error) result(f_source)
                           file_lines_lower(i)%s)
                     return
                 end if
-
-                f_source%unit_type = FPM_UNIT_SUBMODULE
+                
+                if (f_source%unit_type /= FPM_UNIT_PROGRAM) then
+                    f_source%unit_type = FPM_UNIT_SUBMODULE
+                end if
 
                 n_use = n_use + 1
 
+                inside_module = .true.
+
                 if (pass == 2) then
 
                     if (index(temp_string,':') > 0) then
@@ -323,15 +333,34 @@ function parse_f_source(f_filename,error) result(f_source)
                 f_source%unit_type = FPM_UNIT_PROGRAM
 
                 cycle
-                
+
             end if
 
-        end do file_loop
+            ! Parse end module statement
+            !  (to check for code outside of modules)
+            if (index(file_lines_lower(i)%s,'end') == 1) then
 
-        ! Default to subprogram unit type
-        if (f_source%unit_type == FPM_UNIT_UNKNOWN) then
-            f_source%unit_type = FPM_UNIT_SUBPROGRAM
-        end if
+                temp_string = split_n(file_lines_lower(i)%s,n=2,delims=' ',stat=stat)
+
+                if (stat == 0) then
+                    if (temp_string == 'module' .or. temp_string == 'submodule') then
+
+                        inside_module = .false.
+                        cycle
+
+                    end if
+                end if
+
+            end if
+
+            ! Any statements not yet parsed are assumed to be other code statements
+            if (.not.inside_module .and. f_source%unit_type /= FPM_UNIT_PROGRAM) then
+
+                f_source%unit_type = FPM_UNIT_SUBPROGRAM
+
+            end if
+
+        end do file_loop
 
         if (pass == 1) then
             allocate(f_source%modules_used(n_use))

test/fpm_test/test_source_parsing.f90

@@ -26,6 +26,7 @@ subroutine collect_source_parsing(testsuite)
             & new_unittest("include-stmt", test_include_stmt), &
             & new_unittest("program", test_program), &
             & new_unittest("module", test_module), &
+            & new_unittest("module-with-subprogram", test_module_with_subprogram), &
             & new_unittest("program-with-module", test_program_with_module), &
             & new_unittest("submodule", test_submodule), &
             & new_unittest("submodule-ancestor", test_submodule_ancestor), &
@@ -335,7 +336,8 @@ subroutine test_module(error)
             & 'string = " &', &
             & 'module name !"', &
             & 'end function i', &
-            & 'end module test'
+            & 'end module test', &
+            & '! A trailing comment outside of module'
         close(unit)
 
         f_source = parse_f_source(temp_file,error)
@@ -371,6 +373,55 @@ subroutine test_module(error)
     end subroutine test_module
 
 
+    !> Try to parse fortran module with subroutine outside of module
+    !>  (this should be detected as FPM_UNIT_SUBPROGRAM not FPM_UNIT_MODULE)
+    subroutine test_module_with_subprogram(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: unit
+        character(:), allocatable :: temp_file
+        type(srcfile_t), allocatable :: f_source
+
+        allocate(temp_file, source=get_temp_filename())
+
+        open(file=temp_file, newunit=unit)
+        write(unit, '(a)') &
+            & 'module  my_mod', &
+            & 'contains', &
+            & 'module subroutine f()', &
+            & 'end subroutine f', &
+            & 'module function g()', &
+            & 'end function g', &
+            & 'end module test',&
+            & 'function h()', &
+            & 'end function'
+        close(unit)
+
+        f_source = parse_f_source(temp_file,error)
+        if (allocated(error)) then
+            return
+        end if
+
+        if (f_source%unit_type /= FPM_UNIT_SUBPROGRAM) then
+            call test_failed(error,'Wrong unit type detected - expecting FPM_UNIT_SUBPROGRAM')
+            return
+        end if
+
+        if (size(f_source%modules_provided) /= 1) then
+            call test_failed(error,'Unexpected modules_provided - expecting one')
+            return
+        end if
+
+        if (size(f_source%modules_used) /= 0) then
+            call test_failed(error,'Incorrect number of modules_used - expecting zero')
+            return
+        end if
+
+    end subroutine test_module_with_subprogram
+
+
     !> Try to parse combined fortran module and program
     !>  Check that parsed unit type is FPM_UNIT_PROGRAM
     subroutine test_program_with_module(error)