[WIP] Support installation of C++20 modules (with non-ROOT functionality)

.cppcheck-suppressions.txt

@@ -1,4 +1,5 @@
 noExplicitConstructor:*
+*:*.ixx
 unusedFunction:*
 missingInclude:*
 missingIncludeSystem:*

.github/workflows/pre-commit.yml

@@ -29,6 +29,7 @@ jobs:
             --preset ci-build \
             -DENABLE_JULIA=ON \
             -DENABLE_ARROW=ON \
+            -DPODIO_ENABLE_CXX_MODULES=ON \
             -DUSE_EXTERNAL_CATCH2=OFF
           ln -s build/compile_commands.json compile_commands.json
           echo "::endgroup::"

.github/workflows/test.yml

@@ -40,6 +40,8 @@ jobs:
             -DENABLE_RNTUPLE=$([[ ${{ matrix.LCG }} == LCG_104/* ]] && echo "OFF" || echo "ON") \
             -DPODIO_RUN_STRACE_TEST=$([[ ${{ matrix.LCG }} == LCG_104/* ]] && echo "OFF" || echo "ON") \
             -DCMAKE_INSTALL_PREFIX=$(pwd)/install \
+            -DCMAKE_CXX_STANDARD=$([[ ${{ matrix.LCG }} == *-gcc15-* ]] && echo "23" || echo "20") \
+            -DPODIO_ENABLE_CXX_MODULES=$([[ ${{ matrix.LCG }} == *-gcc15-* ]] && echo "ON" || echo "OFF") \
             -DUSE_EXTERNAL_CATCH2=AUTO
           echo "::endgroup::"
           echo "::group::Build"

.pre-commit-config.yaml

@@ -37,5 +37,5 @@ repos:
         name: clang-tidy
         entry: .github/scripts/clang-tidy-hook
         types: [c++]
-        exclude: (tests/(datamodel|src|extra_code)/.*(h|cc)|podioVersion.in.h)
+        exclude: (tests/(datamodel|src|extra_code)/.*(h|cc)|podioVersion.in.h|.*\.ixx|tests/test_module_import\.cpp)
         language: system

CMakeLists.txt

@@ -127,6 +127,9 @@ podio_python_setup()
 #--- enable podio macros--------------------------------------------------------
 include(cmake/podioMacros.cmake)
 
+#--- enable C++20 module support (if requested) --------------------------------
+include(cmake/podioModules.cmake)
+
 # optionally build with SIO -------------------------------------------------
 if(ENABLE_SIO)
   find_package( SIO REQUIRED)

cmake/podioConfig.cmake.in

@@ -25,6 +25,7 @@ set(PODIO_IO_HANDLERS "@PODIO_IO_HANDLERS@")
 
 include(CMakeFindDependencyMacro)
 find_dependency(ROOT @ROOT_VERSION@)
+find_dependency(Threads REQUIRED)
 if(NOT "@REQUIRE_PYTHON_VERSION@" STREQUAL "")
   find_dependency(Python3 @REQUIRE_PYTHON_VERSION@ COMPONENTS Interpreter Development)
 else()

cmake/podioMacros.cmake

@@ -135,6 +135,12 @@ function(PODIO_GENERATE_DATAMODEL datamodel YAML_FILE RETURN_HEADERS RETURN_SOUR
     set(VERSION_ARG "--datamodel-version=${ARG_VERSION}")
   endif()
 
+  # Check if C++20 modules should be generated
+  set(MODULES_ARG "")
+  if(PODIO_ENABLE_CXX_MODULES)
+    set(MODULES_ARG "--enable-modules")
+  endif()
+
   # Make sure that we re run the generation process every time either the
   # templates or the yaml file changes.
   include(${podio_PYTHON_DIR}/templates/CMakeLists.txt)
@@ -155,7 +161,7 @@ function(PODIO_GENERATE_DATAMODEL datamodel YAML_FILE RETURN_HEADERS RETURN_SOUR
   message(STATUS "Creating '${datamodel}' datamodel")
   # we need to bootstrap the data model, so this has to be executed in the cmake run
   execute_process(
-    COMMAND ${Python3_EXECUTABLE} ${podio_PYTHON_DIR}/podio_class_generator.py ${CLANG_FORMAT_ARG}  ${SCHEMA_EVOLUTION_ARG} ${UPSTREAM_EDM_ARG} ${YAML_FILE} ${ARG_OUTPUT_FOLDER} ${datamodel} ${ARG_IO_BACKEND_HANDLERS} ${LANGUAGE_ARG} ${VERSION_ARG} ${OLD_DESCRIPTION_ARG}
+    COMMAND ${Python3_EXECUTABLE} ${podio_PYTHON_DIR}/podio_class_generator.py ${CLANG_FORMAT_ARG}  ${SCHEMA_EVOLUTION_ARG} ${UPSTREAM_EDM_ARG} ${YAML_FILE} ${ARG_OUTPUT_FOLDER} ${datamodel} ${ARG_IO_BACKEND_HANDLERS} ${LANGUAGE_ARG} ${VERSION_ARG} ${MODULES_ARG} ${OLD_DESCRIPTION_ARG}
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     RESULT_VARIABLE podio_generate_command_retval
     )
@@ -211,6 +217,21 @@ function(PODIO_ADD_DATAMODEL_CORE_LIB lib_name HEADERS SOURCES)
     CXX_CLANG_TIDY "" # Do not run clang-tidy on generated sources
                       # TODO: Update generation to generate compliant code already
     )
+
+  # Add C++20 module interface if it was generated
+  if(PODIO_ENABLE_CXX_MODULES)
+    # Check if module files were generated
+    include(${ARG_OUTPUT_FOLDER}/podio_generated_files.cmake)
+    if(DEFINED module_files AND module_files)
+      message(STATUS "Adding C++20 module interface to ${lib_name}")
+      target_sources(${lib_name}
+        PUBLIC
+          FILE_SET CXX_MODULES
+          BASE_DIRS ${ARG_OUTPUT_FOLDER}
+          FILES ${module_files}
+      )
+    endif()
+  endif()
 endfunction()
 
 

cmake/podioModules.cmake

@@ -0,0 +1,99 @@
+#---------------------------------------------------------------------------------------------------
+# CMake support for C++20 modules in podio
+#
+# This file provides macros and options for generating and using C++20 module interfaces
+# for podio-generated datamodels.
+#---------------------------------------------------------------------------------------------------
+
+# Option to enable C++20 module generation
+option(PODIO_ENABLE_CXX_MODULES "Generate C++20 module interface files (.ixx) for datamodels" OFF)
+
+# Check if modules are actually supported
+if(PODIO_ENABLE_CXX_MODULES)
+  # Check CMake version
+  if(CMAKE_VERSION VERSION_LESS 3.29)
+    message(WARNING "C++20 modules require CMake 3.29 or later (found ${CMAKE_VERSION}). Disabling module support.")
+    set(PODIO_ENABLE_CXX_MODULES OFF CACHE BOOL "C++20 modules disabled due to CMake version" FORCE)
+  endif()
+
+  # Check generator
+  if(CMAKE_GENERATOR STREQUAL "Unix Makefiles")
+    message(WARNING "C++20 modules are not supported with the Unix Makefiles generator. Please use Ninja. Disabling module support.")
+    set(PODIO_ENABLE_CXX_MODULES OFF CACHE BOOL "C++20 modules disabled due to generator" FORCE)
+  endif()
+
+  # Check compiler support
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.0)
+      message(WARNING "C++20 modules require GCC 14 or later (found ${CMAKE_CXX_COMPILER_VERSION}). Disabling module support.")
+      set(PODIO_ENABLE_CXX_MODULES OFF CACHE BOOL "C++20 modules disabled due to compiler version" FORCE)
+    endif()
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
+      message(WARNING "C++20 modules require Clang 18 or later (found ${CMAKE_CXX_COMPILER_VERSION}). Disabling module support.")
+      set(PODIO_ENABLE_CXX_MODULES OFF CACHE BOOL "C++20 modules disabled due to compiler version" FORCE)
+    endif()
+  else()
+    message(WARNING "C++20 modules have only been tested with GCC 14+ and Clang 18+. Found ${CMAKE_CXX_COMPILER_ID}. Proceed at your own risk.")
+  endif()
+endif()
+
+if(PODIO_ENABLE_CXX_MODULES)
+  message(STATUS "C++20 module support is ENABLED for podio datamodels")
+  message(STATUS "  - CMake version: ${CMAKE_VERSION}")
+  message(STATUS "  - Generator: ${CMAKE_GENERATOR}")
+  message(STATUS "  - Compiler: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
+else()
+  message(STATUS "C++20 module support is DISABLED for podio datamodels")
+endif()
+
+#---------------------------------------------------------------------------------------------------
+# PODIO_ADD_MODULE_INTERFACE( target module_name module_file )
+#
+# Add a C++20 module interface to a target
+#
+# Arguments:
+#   target      - The target to which the module should be added
+#   module_name - The name of the module (e.g., "podio.core")
+#   module_file - The .ixx file implementing the module interface
+#---------------------------------------------------------------------------------------------------
+function(PODIO_ADD_MODULE_INTERFACE target module_name module_file)
+  if(NOT PODIO_ENABLE_CXX_MODULES)
+    return()
+  endif()
+
+  message(STATUS "Adding C++20 module '${module_name}' to target '${target}'")
+
+  # Add the module file to the target as a CXX_MODULES file set
+  # Use PUBLIC so the module gets installed and can be used by downstream projects
+  target_sources(${target}
+    PUBLIC
+      FILE_SET CXX_MODULES
+      BASE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}
+      FILES ${module_file}
+  )
+endfunction()
+
+#---------------------------------------------------------------------------------------------------
+# PODIO_GENERATE_MODULE_INTERFACE( datamodel OUTPUT_FILE )
+#
+# Generate a C++20 module interface for a podio datamodel
+# This is currently a placeholder - actual generation will be added later
+#
+# Arguments:
+#   datamodel   - Name of the datamodel (e.g., "TestDataModel")
+#   OUTPUT_FILE - Variable name to store the generated .ixx file path
+#---------------------------------------------------------------------------------------------------
+function(PODIO_GENERATE_MODULE_INTERFACE datamodel OUTPUT_FILE)
+  if(NOT PODIO_ENABLE_CXX_MODULES)
+    set(${OUTPUT_FILE} "" PARENT_SCOPE)
+    return()
+  endif()
+
+  # For now, just set the expected output location
+  # Actual generation will be implemented in the template
+  set(module_file "${CMAKE_CURRENT_BINARY_DIR}/${datamodel}_module.ixx")
+  set(${OUTPUT_FILE} ${module_file} PARENT_SCOPE)
+
+  message(STATUS "Will generate module interface: ${module_file}")
+endfunction()