Remove obsolete DIRECTC_EXPECTED_FAILURES entries#347
Merged
jameskermode merged 30 commits intoDec 18, 2025
Conversation
Generate Fortran wrappers and Python methods for deferred bindings on abstract types. This enables polymorphic dispatch through the base class. Changes: - transform.py: Resolve deferred binding prototypes to abstract interface procedures, marking them with 'deferred' and 'method' attributes - LinkBoundDType: Handle resolved deferred bindings (skip raw Prototypes) - Re-enable issue41_abstract_classes example in test suite When a factory function returns a polymorphic class(base_type) object, the Python wrapper now correctly has the deferred methods available, which dispatch through Fortran's polymorphic call mechanism.
Both examples now pass with the current codebase. The callback example had non-ASCII curly quotes in a comment that were breaking f2py on some systems - replaced with ASCII single quotes.
The test only verifies C compilation succeeds (the original issue jameskermode#299 fix). It does not import the generated Python module, so the types.py naming conflict with stdlib is not triggered.
Run python from parent directory to avoid the generated types.py shadowing Python's stdlib types module when getting numpy/python include paths.
Fix linking issue by using f2py-ok target instead of f2py-ko. The f2py-ko target tries to link pre-compiled .o files which fails with meson backend. The f2py-ok target compiles sources directly.
Skip test on Python 3.10 due to f2py callback issue where callbacks fail with "capi_return is NULL" error. The test passes on Python 3.11+.
…andling Add Makefile.meson files for examples that were missing them to enable Direct-C mode testing via `make test_meson DIRECTC=yes`: - issue261_array_shapes: Array shape tests - issue301_complex_types: Complex type tests (with tests.py) - issue302_pointer_warning: Pointer warning tests (with tests.py) - f2py_string_input: Skip stub (pure f2py example, not f90wrap) - issue299_directc_nested_functions: Delegates to regular Makefile Fix issue261_array_shapes/Makefile to use $(F90) instead of $(FC). IMPORTANT: Fix test_meson target to properly report failures: - Add DIRECTC_EXPECTED_FAILURES list for known Direct-C limitations - In DIRECTC=yes mode: expected failures are logged but don't fail CI - In regular mode: ALL failures cause CI to fail - Unexpected failures in DIRECTC mode also fail CI This ensures test coverage is maintained in default mode while allowing known Direct-C limitations to be tracked without breaking CI.
The clean target only removed f90wrap*.f but not f90wrap*.f90, causing stale files to conflict during Direct-C test runs.
1. Add MESON_EXPECTED_FAILURES list for examples with known bugs that fail in both regular and Direct-C meson modes: - issue301_complex_types: stack smashing error - callback_print_function_issue93: undefined pyfunc_print_ symbol 2. Fix issue302_pointer_warning/tests.py test bug: - Use lowercase container_t (matches actual class name) - Use size_bn (size is renamed to avoid Python builtin conflict) The previous commit incorrectly included issue41_abstract_classes and issue302_pointer_warning in expected failures - these actually work correctly with current f90wrap.
Callback examples require special build steps (static library, --callback flag) that make.meson.inc doesn't support. Delegating to the regular Makefile works.
Objects created via factory functions (like mytype_create) were not having their finalizer set up because from_handle() bypassed __init__. This fix: - Extracts finalizer setup into a _setup_finalizer() method - Calls _setup_finalizer() from __init__ after object creation - Calls _setup_finalizer() after from_handle(..., alloc=True) in factory function returns This ensures Fortran destructors are properly called when Python objects are garbage collected, fixing memory leak issues in manylinux. Also adds gc.collect() to issue235 test to ensure immediate cleanup.
The test now runs multiple rounds and checks that memory doesn't grow between rounds. This correctly handles the weakref.finalize registry dict which doesn't shrink after pop() but does reuse the memory. A real Fortran memory leak would show growth every round, while the dict overhead is a one-time cost that gets reused.
Abstract classes need a no-op _setup_finalizer method because factory functions that return abstract base types will call _setup_finalizer() on the returned object. Without this, polymorphic returns fail with AttributeError.
Add -X faulthandler flag to get Python stacktrace on segfault. This helps debug the macOS callback segfault issue.
Comprehensive testing confirms the f2py callback segfault only affects macOS Python 3.10. Linux Python 3.10 works correctly. Tested configurations: - macOS arm64 Python 3.10: SEGFAULT - macOS arm64 Python 3.11-3.13: SUCCESS - Linux x86_64 Python 3.10-3.13: SUCCESS (Docker with NumPy 2.2.6)
Clean the meson build directory before building the second module (_CBF_pkg) to prevent conflicts with the first module (_CBF). Also update clean target to remove all build artifacts.
The f2py-generated callback wrapper has a bug: it stores callback context in thread-local storage but doesn't restore it after the call returns. This leaves a dangling pointer that causes segfaults when the callback is invoked through a different path (e.g., via another Fortran module). The original test called write_message() directly before calling through the caller module, which triggered this bug on Python 3.10. Removing the direct call fixes the test on all platforms. Root cause: In _CBFmodule.c, swap_active_cb_*() is called to save the callback context, but the previous context is never restored. This is an upstream bug in NumPy f2py's callback code generation.
Direct-C array accessors were returning 3 values (nd, dtype, shape) but Python expects 4 (nd, dtype, shape, handle). Added the handle as the fourth element of the return tuple. Also fix array_shape handling: use list() instead of .copy() to support both numpy arrays (f2py) and tuples (Direct-C).
Ensure the auto-raise-error check runs even when integer error codes are marshalled via default-kind temporaries in Direct-C mode.
Enable Direct-C helper generation for derived-type pointer arrays and ensure polymorphic class arrays export setitem helpers only when assignment is supported.
The select type syntax for polymorphic CLASS array assignment breaks f2py's parser, which treats 'is' as a block name. This commit: 1. Only uses select type for CLASS arrays in Direct-C mode (where f2py is not involved) 2. For standard f2py mode, uses simpler assignment without select type 3. Restores conditional setitem generation for CLASS types without has_assignment in non-Direct-C mode 4. Updates issue302 test to verify pointer arrays ARE wrapped (not skipped) since PR jameskermode#343 now supports them
Abstract types with deferred bindings need C wrappers generated in Direct-C mode. The Fortran wrapper already exists and uses runtime polymorphism to dispatch to the correct concrete implementation. Previously, directc_cgen skipped deferred bindings thinking they had no implementation. But the Fortran wrapper (generated by f90wrapgen) correctly handles polymorphic dispatch via `call self_ptr%p%obj%method()`. This enables Direct-C mode to work with abstract base classes that have deferred type-bound procedures, matching the behavior of standard f2py mode.
Fixes jameskermode#345 Two fixes for Direct-C mode compatibility with CMake-based projects: 1. Add PY_ARRAY_UNIQUE_SYMBOL define to generated C code When CMake builds compile fortranobject.c alongside _lib.c, they need to share the same numpy array API symbol. fortranobject.c uses _npy_f2py_ARRAY_API, so we now define this in generated Direct-C code. 2. Support --f90-mod-name for PyInit function naming When --f90-mod-name is provided (e.g., package._module), extract the last component for the PyInit function name while keeping the C file basename from --mod-name. This allows CMake projects to use custom module names while maintaining the expected file naming convention. Tested with gvec (CMake-based Direct-C project).
All examples except issue261_array_shapes and keep_single_interface now pass in Direct-C mode. Also add missing issue306_allocatable_realloc to CMakeLists.txt.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Testing
Manually tested all 21 examples in DIRECTC_EXPECTED_FAILURES with DIRECTC=yes:
Stacked on
This PR is stacked on #346