Can a package add source files to a target?

[MeanSquaredError]

I am progressing nicely with my overhaul of the CMake package manager as described here
#7072 (comment)
After the overhaul, it will be possible to import CMake packages that define C++20 modules.
However I have a problem with the importing of source files. Currently C++20 module BMI/CMI files are not really portable, so a module must export its interface in the form of modules interface files that have the .cppm, .mpp, or some other similar extension.

However I don't see a way for a package manager to export C++ source files. More specifically the CMake package manager seems to export the following properties:

links
ldflags
linkdirs
defines
libfiles
includedirs

Is there a way for the package manager to attach some source files to a package mypkg, so that the corresponding add_packages("mypkg") under some target would also add these source files to that target. Afterwards, when this target is built, the added source files would be built as part of the target.

I am not able to find a way to attach the sources to a package. Is that possible at all?

[waruqi]

Currently, only packages maintained by xmake.lua support module distribution. (https://github.com/xmake-io/xmake-repo/blob/b1a575857278fff55bb8722fec6cf7d2a688ecee/packages/m/magic_enum/xmake.lua#L43)

[MeanSquaredError]

OK, thanks for the information. But as far as I can see it shouldn't be too difficult to add distribution of source files to the packages created by the different package managers in https://github.com/xmake-io/xmake/tree/dev/xmake/modules/package/manager. right? After all only the generic high-level code would need to be updated and then each package manager could add support for modules at leisure whenever the corresponding maintainers find the time for that.

Or am I missing something important?

[waruqi]

No. First of all, there is currently no standard for the distribution format of standard modules; there is only a draft that may reach a consensus. https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2577r2.pdf

https://github.com/cplusplus/modules-ecosystem-tr/files/10071184/iso_cpp_modules_ecosystem_technical_report.pdf

Currently, I haven't seen any build tools implement it; xmake currently only uses an internal proprietary format and scheme for module distribution.

It only works for xmake packages, and there's currently no documentation or specification to describe it. Perhaps some changes will be made in the future.

You can see source codes.

xmake/xmake/rules/c++/modules/install.lua

Lines 25 to 33 in 766a7a8

	function install(target)
	-- we cannot use target:data("cxx.has_modules"),
	-- because on_config will be not called when installing targets
	if support.contains_modules(target) then
	local modules = scanner.get_modules(target)
	builder.generate_metadata(target, modules)
	support.add_installfiles_for_modules(target, modules)
	end
	end

In addition to installing files such as .cppm, it is also necessary to generate metadata file.

@Arthapz might know more about module distribution.

[MeanSquaredError]

I am providing a bit of background information for @Arthapz, in case he would like to comment on this issue.

I decided to overhaul the Xmake code that imports CMake packages, in order to allow Xmake to also read the information about the exported C++20 module interface files, that CMake provides in their generated import scripts (more specifically in the target files that are part of the import scripts). So far the overhauled Xmake code is avaiable here:
https://github.com/MeanSquaredError/xmake/tree/cmake_find_package

CMake passes information about the C++20 module interface files in their import files. I've created a basic library called mylib and the generated target file (mylib-targets.cmake) has the following code:

if(NOT CMAKE_VERSION VERSION_LESS "3.23.0")
  target_sources(mylib::mylib
    INTERFACE
      FILE_SET "CXX_MODULES"
      TYPE "CXX_MODULES"
      BASE_DIRS "/usr/local/modules/mylib"
      FILES "/usr/local/modules/mylib/mylib.cppm"
  )
else()
  ...
endif()

When someone uses the CMake import files, the imported target mylib::mylib will have the file set CXX_MODULES with the attached module interface file /usr/local/modules/mylib/mylib.cppm.
That information is nicely exported using their cmake-file-api. I use that the cmake-file-api in the overhauled Xmake code to extract the CMake module information with the locations of the attached C++20 module interface files.

From waruqi's explanation and the link he provided I understand that Xmake does something quite similar to CMake when it comes to attaching C++20 module interface files to packages. CMake uses target_sources() to attach the .cppm files to the import targets and Xmake uses add_files:

                target("magic_enum")
                    ...
                    add_files("module/**.cppm", {public = true})

So my goal at the moment is quite modest: I want to somehow allow Xmake to propagate that information internally, without physically installing the imported package anywhere. I just want to be able to do the following in my xmake.lua:

add_requires (
    "cmake::mylib",
    {
        system = true,
        configs = {
            presets = {CMAKE_EXPERIMENTAL_CXX_IMPORT_STD = "d0edc3af-4c50-42ea-a356-e2862fe7a444"},
            link_libraries = {"mylib::mylib"}
        }
    }
)

and then later in my code to do this:

target("my_target")
    ...
    add_packages("mylib")

and then to have all mylib dependencies added to my_target. The added dependencies should include all the C++20 module interface files, which should be added as sources to my_target. So I am looking into the Xmake code trying to find a way to propagate the C++20 module information that was extracted by my overhauled code to the package that was imported by Xmake, so that the call add_packages("mylib") would add the C++20 module interface files to the target my_target