Merge branch 'main' of https://github.com/compiler-explorer/infra into main

Author: partouf

bin/lib/ce_install.py

@@ -496,7 +496,7 @@ def build(
         else:
             print(f"Building {installable.name} ({platform.value}) for all")
 
-        if force or installable.should_build():
+        if force or installable.should_build() or (platform == LibraryPlatform.Windows):
             was_temp_installed = False
 
             if not installable.is_installed() and temp_install:
@@ -588,11 +588,25 @@ def generate_cpp_windows_props(context: CliContext):
 
 @cli.command(name="list-gh-build-commands")
 @click.pass_obj
+@click.option("--per-lib", is_flag=True, help="Group by library instead of version")
 @click.argument("filter_", metavar="FILTER", nargs=-1)
-def list_cmd(context: CliContext, filter_: List[str]):
-    """List installation targets matching FILTER."""
-    for installable in context.get_installables(filter_):
-        print(f'gh workflow run win-lib-build.yaml --field "library={installable.name}" -R github.com/compiler-explorer/infra')
+def list_gh_build_commands(context: CliContext, per_lib: bool, filter_: List[str]):
+    """List gh workflow commands matching FILTER."""
+    grouped = set()
+
+    if per_lib:
+        for installable in context.get_installables(filter_):
+            shorter_name = installable.name.replace("libraries/c++/", "").split(" ")[0]
+            grouped.add(shorter_name)
+
+        for group in grouped:
+            print(f'gh workflow run win-lib-build.yaml --field "library={group}" -R github.com/compiler-explorer/infra')
+    else:
+        for installable in context.get_installables(filter_):
+            shorter_name = installable.name.replace("libraries/c++/", "")
+            print(
+                f'gh workflow run win-lib-build.yaml --field "library={shorter_name}" -R github.com/compiler-explorer/infra'
+            )
 
 
 @cli.command()

bin/lib/installable/installable.py

@@ -272,6 +272,24 @@ def build(self, buildfor: str, popular_compilers_only: bool, platform: LibraryPl
                 return cppbuilder.makebuild(buildfor)
             elif self.build_config.build_type == "make":
                 return cppbuilder.makebuild(buildfor)
+        elif (
+            self.build_config.build_type == "none"
+            and self.build_config.lib_type == "headeronly"
+            and platform == LibraryPlatform.Windows
+        ):
+            sourcefolder = os.path.join(self.install_context.destination, self.install_path)
+            cppbuilder = LibraryBuilder(
+                _LOGGER,
+                self.language,
+                self.context[-1],
+                self.target_name,
+                sourcefolder,
+                self.install_context,
+                self.build_config,
+                popular_compilers_only,
+                platform,
+            )
+            return cppbuilder.makebuild(buildfor)
         elif self.build_config.build_type == "fpm":
             sourcefolder = os.path.join(self.install_context.destination, self.install_path)
             fbuilder = FortranLibraryBuilder(

bin/lib/library_build_config.py

@@ -1,7 +1,7 @@
 from typing import Optional, Dict, Any
 from lib.installation_context import is_windows
 
-valid_lib_types = ["static", "shared", "cshared"]
+valid_lib_types = ["static", "shared", "cshared", "headeronly"]
 
 
 class LibraryBuildConfig:
@@ -10,11 +10,15 @@ def __init__(self, config: Dict[str, Any]):
         self.build_type = self.config_get("build_type", "")
         self.build_fixed_arch = self.config_get("build_fixed_arch", "")
         self.build_fixed_stdlib = self.config_get("build_fixed_stdlib", "")
-        self.lib_type = self.config_get("lib_type", "static")
+        self.lib_type = self.config_get("lib_type", "headeronly")
         if not self.lib_type in valid_lib_types:
             raise RuntimeError(f"{self.lib_type} not a valid lib_type")
         self.staticliblink = self.config_get("staticliblink", [])
         self.sharedliblink = self.config_get("sharedliblink", [])
+        if self.lib_type == "headeronly" and (self.staticliblink != [] or self.sharedliblink != []):
+            raise RuntimeError(
+                f"Header-only libraries should not have staticliblink or sharedliblink {self.staticliblink} {self.sharedliblink}"
+            )
         self.url = "None"
         self.description = ""
         self.configure_flags = self.config_get("configure_flags", [])

bin/lib/library_builder.py

@@ -162,7 +162,7 @@ def completeBuildConfig(self):
                 self.buildconfig.sharedliblink = list(
                     set(self.buildconfig.sharedliblink + specificVersionDetails["liblink"])
                 )
-        else:
+        elif not self.buildconfig.lib_type == "headeronly":
             self.logger.debug("No specific library version information found")
 
         if self.buildconfig.lib_type == "static":
@@ -580,7 +580,7 @@ def writebuildscript(
 
             make_utility = self.buildconfig.make_utility
 
-            if self.buildconfig.build_type == "cmake":
+            if self.buildconfig.build_type == "cmake" or self.buildconfig.build_type == "none":
                 expanded_cmake_args = [
                     self.expand_make_arg(arg, compilerTypeOrGcc, buildtype, arch, stdver, stdlib)
                     for arg in self.buildconfig.extra_cmake_arg
@@ -741,6 +741,10 @@ def writebuildscript(
             self.setCurrentConanBuildParameters(
                 buildos, buildtype, "cshared", "cshared", libcxx, arch, stdver, extraflags
             )
+        elif self.buildconfig.lib_type == "headeronly":
+            self.setCurrentConanBuildParameters(
+                buildos, buildtype, "headeronly", "headeronly", libcxx, arch, stdver, extraflags
+            )
         else:
             self.setCurrentConanBuildParameters(
                 buildos, buildtype, compilerTypeOrGcc, compiler, libcxx, arch, stdver, extraflags
@@ -1336,6 +1340,16 @@ def makebuild(self, buildfor):
                 self.logger.error(
                     f"Unknown compiler {checkcompiler} to build cshared lib {self.buildconfig.sharedliblink}"
                 )
+        elif self.buildconfig.lib_type == "headeronly":
+            if self.platform == LibraryPlatform.Windows:
+                checkcompiler = "mingw64_ucrt_gcc_1220"
+                self.logger.info(
+                    f"Header-only library, but running on Windows, so attempting build with {checkcompiler}"
+                )
+                if checkcompiler not in self.compilerprops:
+                    self.logger.error(f"Unknown compiler {checkcompiler}")
+            else:
+                self.logger.info("Header-only library, no need to build")
         elif buildfor == "nonx86":
             self.forcebuild = True
             checkcompiler = ""

bin/yaml/libraries.yaml

@@ -840,6 +840,7 @@ libraries:
       - all
       package_install: true
       repo: kokkos/kokkos
+      lib_type: static
       staticliblink:
       - kokkoscore
       - kokkoscontainers

init/settings.yml

@@ -28,7 +28,10 @@ compiler:
         version: ANY
         libcxx: ANY
     cshared:
-        version: ANY
+        version: [cshared]
+        libcxx: ANY
+    headeronly:
+        version: [headeronly]
         libcxx: ANY
     llvmmos:
         version: ANY