add support of moduleonly targets with c++.moduleonly rule

4 files changed, 172 insertions, 77 deletions

diff --git a/xmake/rules/c++/modules/modules_support/builder.lua b/xmake/rules/c++/modules/modules_support/builder.lua
index 1f014abde..b3426736f 100644
--- a/xmake/rules/c++/modules/modules_support/builder.lua
+++ b/xmake/rules/c++/modules/modules_support/builder.lua
@@ -21,6 +21,7 @@
 -- imports
 import("core.base.json")
 import("core.base.option")
+import("async.runjobs")
 import("private.async.buildjobs")
 import("core.tool.compiler")
 import("core.project.config")
@@ -305,6 +306,34 @@ function build_headerunits_for_batchcmds(target, batchcmds, sourcebatch, modules
     end
 end
 
+function generate_metadata(target, modules)
+    local public_modules
+
+    for _, module in pairs(modules) do
+        local _, _, cppfile = compiler_support.get_provided_module(module)
+        local fileconfig = target:fileconfig(cppfile)
+        local public = fileconfig and fileconfig.public
+        if public then
+            public_modules = public_modules or {}
+            table.insert(public_modules, module)
+        end
+    end
+
+    if not public_modules then
+        return
+    end
+
+    local jobs = option.get("jobs") or os.default_njob()
+    runjobs(target:name() .. "_install_modules", function(index) 
+        local module = public_modules[index]
+        local name, _, cppfile = compiler_support.get_provided_module(module)
+        local metafilepath = compiler_support.get_metafile(target, cppfile)
+        progress.show((index * 100) / #public_modules, "${color.build.target}<%s> generating.module.metadata %s", target:name(), name)
+        local metadata = _generate_meta_module_info(target, name, cppfile, module.requires)
+        json.savefile(metafilepath, metadata)
+    end, {comax = jobs, total = #public_modules})
+end
+
 -- flush target module mapper keys
 function flush_target_module_mapper_keys(target)
     local memcache = compiler_support.memcache()
diff --git a/xmake/rules/c++/modules/modules_support/compiler_support.lua b/xmake/rules/c++/modules/modules_support/compiler_support.lua
index d9d849454..d7e8a0bd8 100644
--- a/xmake/rules/c++/modules/modules_support/compiler_support.lua
+++ b/xmake/rules/c++/modules/modules_support/compiler_support.lua
@@ -116,14 +116,14 @@ end
 -- this target contains module files?
 function contains_modules(target)
     -- we can not use `"c++.build.builder"`, because it contains sourcekind/cxx.
-    local target_with_modules = target:sourcebatches()["c++.build.modules"] and true or false
+    local target_with_modules = (target:sourcebatches()["c++.moduleonly"] or target:sourcebatches()["c++.build.modules"]) and true or false
     if not target_with_modules then
         target_with_modules = target:policy("build.c++.modules")
     end
     if not target_with_modules then
         for _, dep in ipairs(target:orderdeps()) do
             local sourcebatches = dep:sourcebatches()
-            if sourcebatches["c++.build.modules"] then
+            if sourcebatches["c++.moduleonly"] or sourcebatches["c++.build.modules"] then
                 target_with_modules = true
                 break
             end
diff --git a/xmake/rules/c++/modules/modules_support/dependency_scanner.lua b/xmake/rules/c++/modules/modules_support/dependency_scanner.lua
index 0b02292ef..e4e6783bd 100644
--- a/xmake/rules/c++/modules/modules_support/dependency_scanner.lua
+++ b/xmake/rules/c++/modules/modules_support/dependency_scanner.lua
@@ -438,7 +438,7 @@ end
 function get_targetdeps_modules(target)
     local sourcefiles
     for _, dep in ipairs(target:orderdeps()) do
-        local sourcebatch = dep:sourcebatches()["c++.build.modules.builder"]
+        local sourcebatch = dep:sourcebatches()["c++.moduleonly"] or dep:sourcebatches()["c++.build.modules.builder"]
         if sourcebatch and sourcebatch.sourcefiles then
             for _, sourcefile in ipairs(sourcebatch.sourcefiles) do
                 local fileconfig = dep:fileconfig(sourcefile)
diff --git a/xmake/rules/c++/modules/xmake.lua b/xmake/rules/c++/modules/xmake.lua
index 62fb37205..6db349873 100644
--- a/xmake/rules/c++/modules/xmake.lua
+++ b/xmake/rules/c++/modules/xmake.lua
@@ -52,6 +52,14 @@ rule("c++.build.modules")
 
             -- mark this target with modules
             target:data_set("cxx.has_modules", true)
+
+            -- moduleonly modules are implicitly public
+            if target:rule("c++.moduleonly") then
+                local sourcebatch = target:sourcebatches()["c++.moduleonly"]
+                for _, sourcefile in ipairs(sourcebatch.sourcefiles) do
+                    target:fileconfig_add(sourcefile, {public = true})
+                end
+            end
         end
     end)
 
@@ -62,111 +70,123 @@ rule("c++.build.modules.builder")
 
     -- parallel build support to accelerate `xmake build` to build modules
     before_build_files(function(target, batchjobs, sourcebatch, opt)
-        if target:data("cxx.has_modules") then
-            import("modules_support.compiler_support")
-            import("modules_support.dependency_scanner")
-            import("modules_support.builder")
+        if not target:rule("c++.moduleonly") then
+            if target:data("cxx.has_modules") then
+                import("modules_support.compiler_support")
+                import("modules_support.dependency_scanner")
+                import("modules_support.builder")
 
-            -- add target deps modules
-            if target:orderdeps() then
-                local deps_sourcefiles = dependency_scanner.get_targetdeps_modules(target)
-                if deps_sourcefiles then
-                    table.join2(sourcebatch.sourcefiles, deps_sourcefiles)
+                -- add target deps modules
+                if target:orderdeps() then
+                    local deps_sourcefiles = dependency_scanner.get_targetdeps_modules(target)
+                    if deps_sourcefiles then
+                        table.join2(sourcebatch.sourcefiles, deps_sourcefiles)
+                    end
                 end
-            end
 
-            -- append std module
-            local std_modules = compiler_support.get_stdmodules(target)
-            if std_modules then
-                table.join2(sourcebatch.sourcefiles, std_modules)
-                target:fileconfig_set(std_modules[1], {external = true})
-                target:fileconfig_set(std_modules[2], {external = true})
-            end
+                -- append std module
+                local std_modules = compiler_support.get_stdmodules(target)
+                if std_modules then
+                    table.join2(sourcebatch.sourcefiles, std_modules)
+                    target:fileconfig_set(std_modules[1], {external = true})
+                    target:fileconfig_set(std_modules[2], {external = true})
+                end
 
-            -- extract packages modules dependencies
-            local package_modules_data = dependency_scanner.get_all_packages_modules(target, opt)
-            if package_modules_data then
-                -- append to sourcebatch
-                for _, package_module_data in table.orderpairs(package_modules_data) do
-                    table.insert(sourcebatch.sourcefiles, package_module_data.file)
-                    target:fileconfig_set(package_module_data.file, {external = true, defines = package_module_data.metadata.defines})
+                -- extract packages modules dependencies
+                local package_modules_data = dependency_scanner.get_all_packages_modules(target, opt)
+                if package_modules_data then
+                    -- append to sourcebatch
+                    for _, package_module_data in table.orderpairs(package_modules_data) do
+                        table.insert(sourcebatch.sourcefiles, package_module_data.file)
+                        target:fileconfig_set(package_module_data.file, {external = true, defines = package_module_data.metadata.defines})
+                    end
                 end
-            end
 
-            opt.batchjobs = true
+                opt.batchjobs = true
 
-            compiler_support.patch_sourcebatch(target, sourcebatch, opt)
-            local modules = dependency_scanner.get_module_dependencies(target, sourcebatch, opt)
+                compiler_support.patch_sourcebatch(target, sourcebatch, opt)
+                local modules = dependency_scanner.get_module_dependencies(target, sourcebatch, opt)
 
-            -- avoid building non referenced modules
-            sourcebatch.objectfiles = dependency_scanner.sort_modules_by_dependencies(target, sourcebatch.objectfiles, modules)
+                -- avoid building non referenced modules
+                sourcebatch.objectfiles = dependency_scanner.sort_modules_by_dependencies(target, sourcebatch.objectfiles, modules)
 
-            -- build modules
-            builder.build_modules_for_batchjobs(target, batchjobs, sourcebatch, modules, opt)
+                -- build modules
+                builder.build_modules_for_batchjobs(target, batchjobs, sourcebatch, modules, opt)
 
-            -- build headerunits and we need to do it before building modules
-            builder.build_headerunits_for_batchjobs(target, batchjobs, sourcebatch, modules, opt)
+                -- build headerunits and we need to do it before building modules
+                builder.build_headerunits_for_batchjobs(target, batchjobs, sourcebatch, modules, opt)
 
-            -- cull external modules objectfile
-            compiler_support.cull_objectfiles(target, modules, sourcebatch)
+                -- cull external modules objectfile
+                compiler_support.cull_objectfiles(target, modules, sourcebatch)
+            else
+                -- avoid duplicate linking of object files of non-module programs
+                sourcebatch.objectfiles = {}
+            end
         else
-            -- avoid duplicate linking of object files of non-module programs
+            sourcebatch.sourcefiles = {}
             sourcebatch.objectfiles = {}
+            sourcebatch.dependfiles = {}
         end
     end, {batch = true})
 
     -- serial compilation only, usually used to support project generator
     before_buildcmd_files(function(target, batchcmds, sourcebatch, opt)
-        if target:data("cxx.has_modules") then
-            import("modules_support.compiler_support")
-            import("modules_support.dependency_scanner")
-            import("modules_support.builder")
+        if not target:rule("c++.moduleonly") then
+            if target:data("cxx.has_modules") then
+                import("modules_support.compiler_support")
+                import("modules_support.dependency_scanner")
+                import("modules_support.builder")
 
-            -- add target deps modules
-            if target:orderdeps() then
-                local deps_sourcefiles = dependency_scanner.get_targetdeps_modules(target)
-                if deps_sourcefiles then
-                    table.join2(sourcebatch.sourcefiles, deps_sourcefiles)
+                -- add target deps modules
+                if target:orderdeps() then
+                    local deps_sourcefiles = dependency_scanner.get_targetdeps_modules(target)
+                    if deps_sourcefiles then
+                        table.join2(sourcebatch.sourcefiles, deps_sourcefiles)
+                    end
                 end
-            end
 
-            -- append std module
-            local std_modules = compiler_support.get_stdmodules(target)
-            if std_modules then
-                table.join2(sourcebatch.sourcefiles, std_modules)
-                target:fileconfig_set(std_modules[1], {external = true})
-                target:fileconfig_set(std_modules[2], {external = true})
-            end
+                -- append std module
+                local std_modules = compiler_support.get_stdmodules(target)
+                if std_modules then
+                    table.join2(sourcebatch.sourcefiles, std_modules)
+                    target:fileconfig_set(std_modules[1], {external = true})
+                    target:fileconfig_set(std_modules[2], {external = true})
+                end
 
-            -- extract packages modules dependencies
-            local package_modules_data = dependency_scanner.get_all_packages_modules(target, opt)
-            if package_modules_data then
-                -- append to sourcebatch
-                for _, package_module_data in table.orderpairs(package_modules_data) do
-                    table.insert(sourcebatch.sourcefiles, package_module_data.file)
-                    target:fileconfig_set(package_module_data.file, {external = true, defines = package_module_data.metadata.defines})
+                -- extract packages modules dependencies
+                local package_modules_data = dependency_scanner.get_all_packages_modules(target, opt)
+                if package_modules_data then
+                    -- append to sourcebatch
+                    for _, package_module_data in table.orderpairs(package_modules_data) do
+                        table.insert(sourcebatch.sourcefiles, package_module_data.file)
+                        target:fileconfig_set(package_module_data.file, {external = true, defines = package_module_data.metadata.defines})
+                    end
                 end
-            end
 
-            opt.batchjobs = false
+                opt.batchjobs = false
 
-            compiler_support.patch_sourcebatch(target, sourcebatch, opt)
-            local modules = dependency_scanner.get_module_dependencies(target, sourcebatch, opt)
+                compiler_support.patch_sourcebatch(target, sourcebatch, opt)
+                local modules = dependency_scanner.get_module_dependencies(target, sourcebatch, opt)
 
-            -- avoid building non referenced modules
-            sourcebatch.objectfiles = dependency_scanner.sort_modules_by_dependencies(target, sourcebatch.objectfiles, modules)
+                -- avoid building non referenced modules
+                sourcebatch.objectfiles = dependency_scanner.sort_modules_by_dependencies(target, sourcebatch.objectfiles, modules)
 
-            -- build headerunits
-            builder.build_headerunits_for_batchcmds(target, batchcmds, sourcebatch, modules, opt)
+                -- build headerunits
+                builder.build_headerunits_for_batchcmds(target, batchcmds, sourcebatch, modules, opt)
 
-            -- build modules
-            builder.build_modules_for_batchcmds(target, batchcmds, sourcebatch, modules, opt)
+                -- build modules
+                builder.build_modules_for_batchcmds(target, batchcmds, sourcebatch, modules, opt)
 
-            -- cull external modules objectfile
-            -- compiler_support.cull_objectfiles(target, modules, sourcebatch)
+                -- cull external modules objectfile
+                -- compiler_support.cull_objectfiles(target, modules, sourcebatch)
+            else
+                -- avoid duplicate linking of object files of non-module programs
+                sourcebatch.objectfiles = {}
+            end
         else
-            -- avoid duplicate linking of object files of non-module programs
+            sourcebatch.sourcefiles = {}
             sourcebatch.objectfiles = {}
+            sourcebatch.dependfiles = {}
         end
     end)
 
@@ -187,16 +207,62 @@ rule("c++.build.modules.builder")
         end
     end)
 
+-- moduleonly
+rule("c++.moduleonly")
+    add_deps("c++.build.modules.install")
+    set_extensions(".mpp", ".mxx", ".cppm", ".ixx", ".cpp")
+
+    before_build(function(target)
+        if target:data("cxx.has_modules") then
+            import("modules_support.compiler_support")
+            import("modules_support.dependency_scanner")
+
+            local sourcebatch = target:sourcebatches()["c++.moduleonly"]
+
+            -- add target deps modules
+            if target:orderdeps() then
+                local deps_sourcefiles = dependency_scanner.get_targetdeps_modules(target)
+                if deps_sourcefiles then
+                    table.join2(sourcebatch.sourcefiles, deps_sourcefiles)
+                end
+            end
+
+            -- append std module
+            table.join2(sourcebatch.sourcefiles, compiler_support.get_stdmodules(target) or {})
+
+            -- extract packages modules dependencies
+            local package_modules_data = dependency_scanner.get_all_packages_modules(target, opt)
+            if package_modules_data then
+                -- append to sourcebatch
+                for _, package_module_data in table.orderpairs(package_modules_data) do
+                    table.insert(sourcebatch.sourcefiles, package_module_data.file)
+                    target:fileconfig_add(package_module_data.file, {external = true, defines = package_module_data.metadata.defines})
+                end
+            end
+
+            local opt = {batchjobs = true}
+
+            compiler_support.patch_sourcebatch(target, sourcebatch, opt)
+            local modules = dependency_scanner.get_module_dependencies(target, sourcebatch, opt)
+            compiler_support.localcache():set2(target:name(), "c++.modules", modules)
+            compiler_support.localcache():save()
+        end
+    end)
+
 -- install modules
 rule("c++.build.modules.install")
     set_extensions(".mpp", ".mxx", ".cppm", ".ixx")
 
     before_install(function (target)
         import("modules_support.compiler_support")
+        import("modules_support.builder")
 
         -- we cannot use target:data("cxx.has_modules"),
         -- because on_config will be not called when installing targets
         if compiler_support.contains_modules(target) then
+            local modules = compiler_support.localcache():get2(target:name(), "c++.modules")
+            builder.generate_metadata(target, modules)
+  
             compiler_support.install_module_target(target)
         end
     end)