create compile_commands.json on dry run fpm build --list

Author: perazz

src/fpm.f90

@@ -461,10 +461,11 @@ subroutine cmd_build(settings)
     do i=1,size(targets)
         write(stderr,*) targets(i)%ptr%output_file
     enddo
-else if (settings%show_model) then
+endif
+if (settings%show_model) then
     call show_model(model)
 else
-    call build_package(targets,model,verbose=settings%verbose)
+    call build_package(targets,model,verbose=settings%verbose,dry_run=settings%list)
 endif
 
 end subroutine cmd_build
@@ -573,7 +574,7 @@ subroutine cmd_run(settings,test)
 
     end if
 
-    call build_package(targets,model,verbose=settings%verbose)
+    call build_package(targets,model,verbose=settings%verbose,dry_run=settings%list)
 
     if (settings%list) then
          call compact_list()

src/fpm/cmd/install.f90

@@ -53,7 +53,7 @@ subroutine cmd_install(settings)
     end if
 
     if (.not.settings%no_rebuild) then
-      call build_package(targets,model,verbose=settings%verbose)
+      call build_package(targets,model,verbose=settings%verbose,dry_run=settings%list)
     end if
 
     call new_installer(installer, prefix=settings%prefix, &

src/fpm_backend.F90

@@ -54,11 +54,15 @@ function c_isatty() bind(C, name = 'c_isatty')
 contains
 
 !> Top-level routine to build package described by `model`
-subroutine build_package(targets,model,verbose)
+subroutine build_package(targets,model,verbose,dry_run)
     type(build_target_ptr), intent(inout) :: targets(:)
     type(fpm_model_t), intent(in) :: model
     logical, intent(in) :: verbose
-
+    
+    !> If dry_run, the build process is only mocked, but the list of compile_commands 
+    !> is still created
+    logical, intent(in) :: dry_run
+ 
     integer :: i, j
     type(build_target_ptr), allocatable :: queue(:)
     integer, allocatable :: schedule_ptr(:), stat(:)
@@ -81,7 +85,7 @@ subroutine build_package(targets,model,verbose)
     end do
 
     do i = 1, size(build_dirs)
-       call mkdir(build_dirs(i)%s,verbose)
+       if (.not.dry_run) call mkdir(build_dirs(i)%s,verbose)
     end do
 
     ! Perform depth-first topological sort of targets
@@ -95,14 +99,13 @@ subroutine build_package(targets,model,verbose)
     call schedule_targets(queue, schedule_ptr, targets)
 
     ! Check if queue is empty
-    if (.not.verbose .and. size(queue) < 1) then
+    if (.not.verbose .and. size(queue) < 1 .and. .not.dry_run) then
         write(stderr, '(a)') 'Project is up to date'
         return
     end if
 
     ! Initialise build status flags
-    allocate(stat(size(queue)))
-    stat(:) = 0
+    allocate(stat(size(queue)),source=0)
     build_failed = .false.
 
     ! Set output mode
@@ -126,9 +129,10 @@ subroutine build_package(targets,model,verbose)
             skip_current = build_failed
 
             if (.not.skip_current) then
-                call progress%compiling_status(j)
-                call build_target(model,queue(j)%ptr,verbose,progress%compile_commands,stat(j))
-                call progress%completed_status(j,stat(j))
+                if (.not.dry_run) call progress%compiling_status(j)
+                call build_target(model,queue(j)%ptr,verbose,dry_run, &
+                                  progress%compile_commands,stat(j))
+                if (.not.dry_run) call progress%completed_status(j,stat(j))
             end if
 
             ! Set global flag if this target failed to build
@@ -157,7 +161,7 @@ subroutine build_package(targets,model,verbose)
 
     end do
 
-    call progress%success()
+    if (.not.dry_run) call progress%success()
     call progress%dump_commands(error)
     if (allocated(error)) call fpm_stop(1,'error writing compile_commands.json: '//trim(error%message))
 
@@ -304,17 +308,19 @@ end subroutine schedule_targets
 !>
 !> If successful, also caches the source file digest to disk.
 !>
-subroutine build_target(model,target,verbose,table,stat)
+subroutine build_target(model,target,verbose,dry_run,table,stat)
     type(fpm_model_t), intent(in) :: model
     type(build_target_t), intent(in), target :: target
     logical, intent(in) :: verbose
+    !> If dry_run, the build process is only mocked, but compile_commands are still created
+    logical, intent(in) :: dry_run    
     type(compile_command_table_t), intent(inout) :: table
     integer, intent(out) :: stat
 
     integer :: fh
 
     !$omp critical
-    if (.not.exists(dirname(target%output_file))) then
+    if (.not.exists(dirname(target%output_file)) .and. .not.dry_run) then
         call mkdir(dirname(target%output_file),verbose)
     end if
     !$omp end critical
@@ -343,7 +349,7 @@ subroutine build_target(model,target,verbose,table,stat)
 
     end select
 
-    if (stat == 0 .and. allocated(target%source)) then
+    if (stat == 0 .and. allocated(target%source) .and. .not.dry_run) then
         open(newunit=fh,file=target%output_file//'.digest',status='unknown')
         write(fh,*) target%source%digest
         close(fh)

src/fpm_compiler.F90

@@ -1104,7 +1104,7 @@ end subroutine new_archiver
 
 
 !> Compile a Fortran object
-subroutine compile_fortran(self, input, output, args, log_file, stat, table)
+subroutine compile_fortran(self, input, output, args, log_file, stat, table, dry_run)
     !> Instance of the compiler object
     class(compiler_t), intent(in) :: self
     !> Source file input
@@ -1119,16 +1119,25 @@ subroutine compile_fortran(self, input, output, args, log_file, stat, table)
     integer, intent(out) :: stat
     !> Optional compile_commands table
     type(compile_command_table_t), optional, intent(inout) :: table    
+    !> Optional mocking
+    logical, optional, intent(in) :: dry_run
 
     character(len=:), allocatable :: command 
     type(error_t), allocatable :: error
+    logical :: mock
+    
+    ! Check if we're actually building this file
+    mock = .false.
+    if (present(dry_run)) mock = dry_run
 
     ! Set command
     command = self%fc // " -c " // input // " " // args // " -o " // output
 
     ! Execute command
-    call run(command, echo=self%echo, verbose=self%verbose, redirect=log_file, exitstat=stat)
-    if (stat/=0) return
+    if (.not.mock) then 
+       call run(command, echo=self%echo, verbose=self%verbose, redirect=log_file, exitstat=stat)
+       if (stat/=0) return
+    endif
 
     ! Optionally register compile command 
     if (present(table)) then 
@@ -1140,7 +1149,7 @@ end subroutine compile_fortran
 
 
 !> Compile a C object
-subroutine compile_c(self, input, output, args, log_file, stat, table)
+subroutine compile_c(self, input, output, args, log_file, stat, table, dry_run)
     !> Instance of the compiler object
     class(compiler_t), intent(in) :: self
     !> Source file input
@@ -1155,16 +1164,25 @@ subroutine compile_c(self, input, output, args, log_file, stat, table)
     integer, intent(out) :: stat
     !> Optional compile_commands table
     type(compile_command_table_t), optional, intent(inout) :: table    
+    !> Optional mocking
+    logical, optional, intent(in) :: dry_run    
 
     character(len=:), allocatable :: command 
     type(error_t), allocatable :: error
+    logical :: mock
+    
+    ! Check if we're actually building this file
+    mock = .false.
+    if (present(dry_run)) mock = dry_run    
 
     ! Set command
     command = self%cc // " -c " // input // " " // args // " -o " // output
 
     ! Execute command
-    call run(command, echo=self%echo, verbose=self%verbose, redirect=log_file, exitstat=stat)
-    if (stat/=0) return
+    if (.not.mock) then 
+       call run(command, echo=self%echo, verbose=self%verbose, redirect=log_file, exitstat=stat)
+       if (stat/=0) return
+    endif
 
     ! Optionally register compile command 
     if (present(table)) then 
@@ -1175,7 +1193,7 @@ subroutine compile_c(self, input, output, args, log_file, stat, table)
 end subroutine compile_c
 
 !> Compile a CPP object
-subroutine compile_cpp(self, input, output, args, log_file, stat, table)
+subroutine compile_cpp(self, input, output, args, log_file, stat, table, dry_run)
     !> Instance of the compiler object
     class(compiler_t), intent(in) :: self
     !> Source file input
@@ -1190,16 +1208,25 @@ subroutine compile_cpp(self, input, output, args, log_file, stat, table)
     integer, intent(out) :: stat
     !> Optional compile_commands table
     type(compile_command_table_t), optional, intent(inout) :: table    
+    !> Optional mocking
+    logical, optional, intent(in) :: dry_run    
 
     character(len=:), allocatable :: command 
     type(error_t), allocatable :: error
+    logical :: mock
+        
+    ! Check if we're actually building this file
+    mock = .false.
+    if (present(dry_run)) mock = dry_run        
 
     ! Set command
     command = self%cxx // " -c " // input // " " // args // " -o " // output
 
     ! Execute command
-    call run(command, echo=self%echo, verbose=self%verbose, redirect=log_file, exitstat=stat)
-    if (stat/=0) return
+    if (.not.mock) then 
+       call run(command, echo=self%echo, verbose=self%verbose, redirect=log_file, exitstat=stat)
+       if (stat/=0) return
+    endif
 
     ! Optionally register compile command 
     if (present(table)) then 
@@ -1210,7 +1237,7 @@ subroutine compile_cpp(self, input, output, args, log_file, stat, table)
 end subroutine compile_cpp
 
 !> Link an executable
-subroutine link_executable(self, output, args, log_file, stat)
+subroutine link_executable(self, output, args, log_file, stat, dry_run)
     !> Instance of the compiler object
     class(compiler_t), intent(in) :: self
     !> Output file of object
@@ -1221,13 +1248,21 @@ subroutine link_executable(self, output, args, log_file, stat)
     character(len=*), intent(in) :: log_file
     !> Status flag
     integer, intent(out) :: stat
+    !> Optional mocking
+    logical, optional, intent(in) :: dry_run    
 
     character(len=:), allocatable :: command 
+    logical :: mock
+        
+    ! Check if we're actually linking
+    mock = .false.
+    if (present(dry_run)) mock = dry_run                
 
     ! Set command
     command = self%fc // " " // args // " -o " // output    
 
     ! Execute command
+    if (.not.mock) &
     call run(command, echo=self%echo, verbose=self%verbose, redirect=log_file, exitstat=stat)
 
 end subroutine link_executable
@@ -1236,7 +1271,7 @@ end subroutine link_executable
 !> @todo For Windows OS, use the local `delete_file_win32` in stead of `delete_file`.
 !> This may be related to a bug in Mingw64-openmp and is expected to be resolved in the future,
 !> see issue #707, #708 and #808.
-subroutine make_archive(self, output, args, log_file, stat)
+subroutine make_archive(self, output, args, log_file, stat, dry_run)
     !> Instance of the archiver object
     class(archiver_t), intent(in) :: self
     !> Name of the archive to generate
@@ -1247,6 +1282,16 @@ subroutine make_archive(self, output, args, log_file, stat)
     character(len=*), intent(in) :: log_file
     !> Status flag
     integer, intent(out) :: stat
+    !> Optional mocking
+    logical, optional, intent(in) :: dry_run    
+    
+    logical :: mock
+        
+    ! Check if we're actually linking
+    mock = .false.
+    if (present(dry_run)) mock = dry_run            
+    
+    if (mock) return
 
     if (self%use_response_file) then
         call write_response_file(output//".resp" , args)