feat: deduce C/CXX if possible

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

src/cython_cmake/cmake/UseCython.cmake

@@ -8,7 +8,7 @@
 # using cython.
 #
 #   Cython_compile_pyx(<pyx_file>
-#                     LANGUAGE C | CXX
+#                     [LANGUAGE C | CXX]
 #                     [CYTHON_ARGS <args> ...]
 #                     [OUTPUT <OutputFile>]
 #                     [OUTPUT_VARIABLE <OutputVariable>]
@@ -17,7 +17,8 @@
 # Options:
 #
 # ``LANGUAGE [C | CXX]``
-#   Force the generation of either a C or C++ file. Required.
+#   Force the generation of either a C or C++ file. Recommended; will attempt
+#   to be deduced if not specified, defaults to C unless only CXX is enabled.
 #
 # ``CYTHON_ARGS <args>``
 #   Specify additional arguments for the cythonization process. Will default to
@@ -75,14 +76,21 @@ if(CMAKE_VERSION VERSION_LESS "3.7")
   message(FATAL_ERROR "CMake 3.7 required for DEPFILE")
 endif()
 
-function(Cython_compile_pyx INPUT)
+
+function(Cython_compile_pyx)
   cmake_parse_arguments(
-    PARSE_ARGV 1
+    PARSE_ARGV 0
     CYTHON
     ""
     "OUTPUT;LANGUAGE;OUTPUT_VARIABLE"
     "CYTHON_ARGS"
     )
+  set(ALL_INPUT ${CYTHON_UNPARSED_ARGUMENTS})
+  list(LENGTH ALL_INPUT INPUT_LENGTH)
+  if(NOT INPUT_LENGTH EQUAL 1)
+    message(FATAL_ERROR "One and only one input file must be specified, got '${ALL_INPUT}'")
+  endif()
+  list(GET ALL_INPUT 0 INPUT)
 
   if(DEFINED CYTHON_EXECUTABLE)
     set(_cython_command "${CYTHON_EXECUTABLE}")
@@ -99,34 +107,51 @@ function(Cython_compile_pyx INPUT)
     set(CYTHON_CYTHON_ARGS "${CYTHON_ARGS}")
   endif()
 
-  # Set target language (required)
+  # Set target language
+  if(NOT CYTHON_LANGUAGE)
+    get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+
+    if("C" IN_LIST _languages AND "CXX" IN_LIST _languages)
+      # Try to compute language. Returns falsy if not found.
+      _cython_compute_language(CYTHON_LANGUAGE ${INPUT})
+      message(STATUS "${CYTHON_LANGUAGE}")
+    elseif("C" IN_LIST _languages)
+      # If only C is enabled globally, assume C
+      set(CYTHON_LANGUAGE C)
+    elseif("CXX" IN_LIST _languages)
+      # Likewise for CXX
+      set(CYTHON_LANGUAGE CXX)
+    else()
+      message(FATAL_ERROR "LANGUAGE keyword required if neither C nor CXX enabled globally")
+    endif()
+  endif()
+
+  # Default to C if not found
   if(NOT CYTHON_LANGUAGE)
-    message(SEND_ERROR "cython_compile_pyx LANGUAGE keyword is required")
-  elseif(CYTHON_LANGUAGE STREQUAL C)
+    set(CYTHON_LANGUAGE C)
+  endif()
+
+  if(CYTHON_LANGUAGE STREQUAL C)
     set(language_arg "")
     set(language_ext ".c")
   elseif(CYTHON_LANGUAGE STREQUAL CXX)
     set(language_arg "--cplus")
     set(language_ext ".cxx")
   else()
-    message(SEND_ERROR "cython_compile_pyx LANGUAGE must be one of C or CXX")
+    message(FATAL_ERROR "cython_compile_pyx LANGUAGE must be one of C or CXX")
   endif()
 
   # Place the cython files in the current binary dir if no path given
   # Can use cmake_path for CMake 3.20+
   if(NOT CYTHON_OUTPUT)
-    # cmake_path(GET INPUT STEM basename)
     get_filename_component(basename "${INPUT}" NAME_WE)
 
-    # cmake_path(APPEND CMAKE_CURRENT_BINARY_DIR "${basename}${language_ext}" OUTPUT_VARIABLE CYTHON_OUTPUT)
     set(CYTHON_OUPUT "${CMAKE_CURRENT_BINARY_DIR}/${basename}${language_ext}")
   endif()
 
-  # cmake_path(ABSOLUTE_PATH CYTHON_OUTPUT)
   get_filename_component(CYTHON_OUTPUT "${CYTHON_OUPUT}" ABSOLUTE)
 
   # Normalize the input path
-  # cmake_path(ABSOLUTE_PATH INPUT)
   get_filename_component(INPUT "${INPUT}" ABSOLUTE)
   set_source_files_properties("${INPUT}" PROPERTIES GENERATED TRUE)
 
@@ -155,7 +180,7 @@ function(Cython_compile_pyx INPUT)
       --depfile
       "${INPUT}"
       --output-file "${CYTHON_OUTPUT}"
-    DEPENDS
+    MAIN_DEPENDENCY
       "${INPUT}"
     DEPFILE
       "${depfile_path}"
@@ -165,3 +190,12 @@ function(Cython_compile_pyx INPUT)
   )
 
 endfunction()
+
+function(_cython_compute_language OUTPUT_VARIABLE FILENAME)
+  file(READ "${FILENAME}" FILE_CONTENT)
+  set(REGEX_PATTERN [=[^[[:space:]]*#[[:space:]]*distutils:.*language[[:space:]]*=[[:space:]]*(c\\+\\+|c)]=])
+  string(REGEX MATCH "${REGEX_PATTERN}" MATCH_RESULT "${FILE_CONTENT}")
+  string(TOUPPER "${MATCH_RESULT}" LANGUAGE_NAME)
+  string(REPLACE "+" "X" LANGUAGE_NAME "${LANGUAGE_NAME}")
+  set(${OUTPUT_VARIABLE} ${LANGUAGE_NAME} PARENT_SCOPE)
+endfunction()

tests/test_package.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib.metadata
+import shutil
 import zipfile
 from pathlib import Path
 
@@ -15,7 +16,7 @@ def test_version():
     assert importlib.metadata.version("cython_cmake") == m.__version__
 
 
-def test_scikit_build_core(monkeypatch, tmp_path):
+def test_simple(monkeypatch, tmp_path):
     monkeypatch.chdir(DIR / "packages/simple")
     build_dir = tmp_path / "build"
 
@@ -30,3 +31,59 @@ def test_scikit_build_core(monkeypatch, tmp_path):
     build_files = {x.name for x in build_dir.iterdir()}
     assert "simple.c.dep" in build_files
     assert "simple.c" in build_files
+
+
+def test_implicit_cxx(monkeypatch, tmp_path):
+    package_dir = tmp_path / "pkg2"
+    shutil.copytree(DIR / "packages/simple", package_dir)
+    monkeypatch.chdir(package_dir)
+
+    cmakelists = Path("CMakeLists.txt")
+    txt = (
+        cmakelists.read_text()
+        .replace("LANGUAGE C", "")
+        .replace("LANGUAGES C", "LANGUAGES CXX")
+    )
+    cmakelists.write_text(txt)
+
+    wheel = build_wheel(
+        str(tmp_path), {"build-dir": "build", "wheel.license-files": []}
+    )
+
+    with zipfile.ZipFile(tmp_path / wheel) as f:
+        file_names = set(f.namelist())
+    assert len(file_names) == 4
+
+    build_files = {x.name for x in Path("build").iterdir()}
+    assert "simple.cxx.dep" in build_files
+    assert "simple.cxx" in build_files
+
+
+def test_directive_cxx(monkeypatch, tmp_path):
+    package_dir = tmp_path / "pkg3"
+    shutil.copytree(DIR / "packages/simple", package_dir)
+    monkeypatch.chdir(package_dir)
+
+    cmakelists = Path("CMakeLists.txt")
+    txt = (
+        cmakelists.read_text()
+        .replace("LANGUAGE C", "")
+        .replace("LANGUAGES C", "LANGUAGES CXX")
+    )
+    cmakelists.write_text(txt)
+
+    simple = Path("simple.pyx")
+    txt = simple.read_text()
+    simple.write_text(f"# distutils: language=c++\n{txt}")
+
+    wheel = build_wheel(
+        str(tmp_path), {"build-dir": "build", "wheel.license-files": []}
+    )
+
+    with zipfile.ZipFile(tmp_path / wheel) as f:
+        file_names = set(f.namelist())
+    assert len(file_names) == 4
+
+    build_files = {x.name for x in Path("build").iterdir()}
+    assert "simple.cxx.dep" in build_files
+    assert "simple.cxx" in build_files