How to include target include directories transitive through multiple linked libraries

we are working on an embedded project in C/C++ and currently some special needs appeared. Background is there are two compiled libraries which define the same symbols. The compiler allows to create relocatable output modules (with partial linking) and to hide symbols for other compilation units when linking. This also means the output module does not need to have all the symbols defined, this will be done in the final linking. Compiler used is TI LTS1.3.0. I will link directly to the relocatable-section of the manual: https://software-dl.ti.com/codegen/docs/tiarmclang/rel1_3_0_LTS/compiler_manual/linker_description/04_linker_options/linker-output-options.html#stdz0756429

The other part of the project is hardly built on CMake with static libraries which are linked against each other via target_link_libraries.

To get this working I created an "add_executable"-target for each of those both output modules with the same symbols. To those I pass the static-libraries by CMake and get the linked with target_link_libraries.
But now I have a problem. All contents of the static libraries are compiled in each of those output modules. This is unwanted behaviour since as said the final linking does the job of linking the missing stuff - so the static-libraries - to it. This should be done with another add_executable command via CMake as well.

using the target include directories property is not suitable since it only adds the include directories of the given target itself but not of the target the target will include and link against.

So e.g. if you have (pseudo code):

#library A
function( create_libA )
  add_library( libA src/A.c )
  target_include_directories( libA PUBLIC /inc ) #contains A.h
endfunction()

#library B. different location
function( create_libB LIBA )
  add_library( libB src/B.c )
  target_link_libraries( libB PUBLIC ${LIBA} )
  target_include_directories( libB PUBLIC /inc ) #contains B.h
endfunction()

#target output module with partial linking. Only should link and compile LIBTOBELINKEDIN, not libB. different location.

function( build_part_module LIBB LIBTOBELINKEDIN )
  add_executable( outputModuleA src/func.c ) #func.c does include A.h
  #following would cause libA and libB also to be compiled and linked in the output due to transitive stuff as I understood, which is unwanted.
  target_link_libraries( outputModuleA PUBLIC ${LIBB} ${LIBTOBELINKEDIN} ) 
  #trying this
  get_target_property(libBInc ${LIBB} INTERFACE_INCLUDE_DIRECTORIES)
  #will only include B.h but not A.h. compilation will fail.
target_include_directories(outputModuleA /inc ${libBInc})

I did not find any solution in Cmake itself to solve this problem. It's confusing me since all the include-directories must be known when the libraries are passed transitive, which is stated in the documentation. But I understand that getting the target include directories of just the passed lib does not include the other ones.

Since target_link_libraries does also not work this way I can only think of a maybe recursive solution? But for that my knowledge is just non-existent.

target_link_libraries with something like HEADERS_ONLY would be helpfull for this job.

Also one can say: if the output module contains all the definitions it won't be a problem, since the linker then knows them and will do its magic.
But this is also unwanted, since we use the generated static-libraries to place them into sections in different regions of the RAM directly. This would then mean to create another linker-script for partial linking which defines sections which then can be again moved. But the more we go this direction, the less we need CMake for it.

Instead of get_target_property use $<TARGET_PROPERTY> generator expression: the property's value, extracted by that expression, already includes transitive propagation:

target_include_directories(outputModuleA PRIVATE
    $<TARGET_PROPERTY:libB,INTERFACE_INCLUDE_DIRECTORIES>
)

Note, that generator expressions has limited usage: not all functions expects them. Documentation for target_include_directories clearly states that the command supports generator expressions.