Replace duplicated dispatch test suite with focused smoke tests. (#918)

The dispatch variant re-compiled all 174 tests through dlopen function
pointers, doubling CI time without proportional coverage. The inline
wrappers are trivial forwards — if one works, they all work.

Replace with 14 targeted tests in a standalone DispatchTests binary
that does not link libclangCppInterOp, verifying true RTLD_LOCAL
isolation: 3 mechanism tests (dlGetProcAddress lookup, missing symbols,
load/unload cycle) and 11 smoke tests covering interpreter, scopes,
types, functions, variables, templates, construct/destruct, enums,
demangle, and version.

A ctest guard (ldd/otool) verifies the binary is not directly linked
against the library, catching regressions in dispatch isolation.

Split CppInterOp.h into CppInterOpTypes.h (types, enums, JitCall) and
CppInterOp.h (types + generated declarations). Dispatch.h now includes
only CppInterOpTypes.h, making CppInterOp.h and Dispatch.h mutually
exclusive with a compile-time #error guard.

Author: vgvassilev

.readthedocs.yaml

@@ -11,6 +11,7 @@ build:
   apt_packages:
     - clang-20
     - cmake
+    - doxygen
     - libclang-20-dev
     - llvm-20-dev
     - llvm-20-tools

docs/conf.py

@@ -54,4 +54,6 @@
          -DLLVM_DIR=/usr/lib/llvm-20/build/lib/cmake/llvm -DCPPINTEROP_ENABLE_DOXYGEN=ON\
          -DCPPINTEROP_INCLUDE_DOCS=ON'.format(CPPINTEROP_ROOT)
 subprocess.call(command, shell=True)
+# Generate .inc files so doxygen can find the API declarations in CppInterOp.h.
+subprocess.call('cmake --build {0}/build --target CppInterOpTableGen'.format(CPPINTEROP_ROOT), shell=True)
 subprocess.call('doxygen {0}/build/docs/doxygen.cfg'.format(CPPINTEROP_ROOT), shell=True)

docs/doxygen.cfg.in

@@ -1617,7 +1617,8 @@ SEARCH_INCLUDES        = YES
 # contain include files that are not input files but should be processed by 
 # the preprocessor.
 
-INCLUDE_PATH           = @CMAKE_SOURCE_DIR@/include
+INCLUDE_PATH           = @CMAKE_SOURCE_DIR@/include \
+                         @CMAKE_BINARY_DIR@/include
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
 # patterns (like *.h and *.hpp) to filter out the header-files in the 

include/CppInterOp/CppInterOp.h

@@ -14,341 +14,15 @@
 #ifndef CPPINTEROP_CPPINTEROP_H
 #define CPPINTEROP_CPPINTEROP_H
 
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <set>
-#include <string>
-#include <sys/types.h>
-#include <vector>
-
-// The cross-platform CPPINTEROP_API macro definition
-#if defined _WIN32 || defined __CYGWIN__
-#define CPPINTEROP_API __declspec(dllexport)
-#else
-#ifdef __GNUC__
-#define CPPINTEROP_API __attribute__((__visibility__("default")))
-#else
-#define CPPINTEROP_API
+#ifdef CPPINTEROP_DISPATCH_H
+#error "CppInterOp.h and Dispatch.h are mutually exclusive — include only one."
 #endif
-#endif
-
-namespace CppImpl {
-using TCppIndex_t = size_t;
-using TCppScope_t = void*;
-using TCppConstScope_t = const void*;
-using TCppType_t = void*;
-using TCppConstType_t = const void*;
-using TCppFunction_t = void*;
-using TCppConstFunction_t = const void*;
-using TCppFuncAddr_t = void*;
-using TInterp_t = void*;
-using TCppObject_t = void*;
-
-enum Operator : unsigned char {
-  OP_None,
-  OP_New,
-  OP_Delete,
-  OP_Array_New,
-  OP_Array_Delete,
-  OP_Plus,
-  OP_Minus,
-  OP_Star,
-  OP_Slash,
-  OP_Percent,
-  OP_Caret,
-  OP_Amp,
-  OP_Pipe,
-  OP_Tilde,
-  OP_Exclaim,
-  OP_Equal,
-  OP_Less,
-  OP_Greater,
-  OP_PlusEqual,
-  OP_MinusEqual,
-  OP_StarEqual,
-  OP_SlashEqual,
-  OP_PercentEqual,
-  OP_CaretEqual,
-  OP_AmpEqual,
-  OP_PipeEqual,
-  OP_LessLess,
-  OP_GreaterGreater,
-  OP_LessLessEqual,
-  OP_GreaterGreaterEqual,
-  OP_EqualEqual,
-  OP_ExclaimEqual,
-  OP_LessEqual,
-  OP_GreaterEqual,
-  OP_Spaceship,
-  OP_AmpAmp,
-  OP_PipePipe,
-  OP_PlusPlus,
-  OP_MinusMinus,
-  OP_Comma,
-  OP_ArrowStar,
-  OP_Arrow,
-  OP_Call,
-  OP_Subscript,
-  OP_Conditional,
-  OP_Coawait,
-};
-
-enum OperatorArity : unsigned char { kUnary = 1, kBinary, kBoth };
-enum Signedness : unsigned char { kSigned = 1, kUnsigned };
-
-/// Enum modelling CVR qualifiers.
-enum QualKind : unsigned char {
-  Const = 1 << 0,
-  Volatile = 1 << 1,
-  Restrict = 1 << 2,
-  All = Const | Volatile | Restrict
-};
-
-/// Enum modelling programming languages.
-enum class InterpreterLanguage : unsigned char {
-  Unknown,
-  Asm,
-  CIR,
-  LLVM_IR,
-  C,
-  CPlusPlus,
-  ObjC,
-  ObjCPlusPlus,
-  OpenCL,
-  OpenCLCXX,
-  CUDA,
-  HIP,
-  HLSL
-};
-
-/// Enum modelling language standards.
-enum class InterpreterLanguageStandard : unsigned char {
-  c89,
-  c94,
-  gnu89,
-  c99,
-  gnu99,
-  c11,
-  gnu11,
-  c17,
-  gnu17,
-  c23,
-  gnu23,
-  c2y,
-  gnu2y,
-  cxx98,
-  gnucxx98,
-  cxx11,
-  gnucxx11,
-  cxx14,
-  gnucxx14,
-  cxx17,
-  gnucxx17,
-  cxx20,
-  gnucxx20,
-  cxx23,
-  gnucxx23,
-  cxx26,
-  gnucxx26,
-  opencl10,
-  opencl11,
-  opencl12,
-  opencl20,
-  opencl30,
-  openclcpp10,
-  openclcpp2021,
-  hlsl,
-  hlsl2015,
-  hlsl2016,
-  hlsl2017,
-  hlsl2018,
-  hlsl2021,
-  hlsl202x,
-  hlsl202y,
-  lang_unspecified
-};
-inline QualKind operator|(QualKind a, QualKind b) {
-  return static_cast<QualKind>(static_cast<unsigned char>(a) |
-                               static_cast<unsigned char>(b));
-}
-
-enum class ValueKind : std::uint8_t {
-  None,
-  LValue,
-  RValue,
-};
-
-/// A class modeling function calls for functions produced by the interpreter
-/// in compiled code. It provides an information if we are calling a standard
-/// function, constructor or destructor.
-class JitCall {
-public:
-  friend CPPINTEROP_API JitCall MakeFunctionCallable(TInterp_t I,
-                                                     TCppConstFunction_t func);
-  enum Kind : char {
-    kUnknown = 0,
-    kGenericCall,
-    kConstructorCall,
-    kDestructorCall,
-  };
-  struct ArgList {
-    void** m_Args = nullptr;
-    size_t m_ArgSize = 0;
-    // Clang struggles with =default...
-    ArgList() {}
-    ArgList(void** Args, size_t ArgSize) : m_Args(Args), m_ArgSize(ArgSize) {}
-  };
-  // FIXME: Figure out how to unify the wrapper signatures.
-  // FIXME: Hide these implementation details by moving wrapper generation in
-  // this class.
-  // (self, nargs, args, result, nary)
-  using GenericCall = void (*)(void*, size_t, void**, void*);
-  // (result, nary, nargs, args, is_arena)
-  using ConstructorCall = void (*)(void*, size_t, size_t, void**, void*);
-  // (self, nary, withFree)
-  using DestructorCall = void (*)(void*, size_t, int);
-
-private:
-  union {
-    GenericCall m_GenericCall;
-    ConstructorCall m_ConstructorCall;
-    DestructorCall m_DestructorCall;
-  };
-  Kind m_Kind;
-  TCppConstFunction_t m_FD;
-  JitCall() : m_GenericCall(nullptr), m_Kind(kUnknown), m_FD(nullptr) {}
-  JitCall(Kind K, GenericCall C, TCppConstFunction_t FD)
-      : m_GenericCall(C), m_Kind(K), m_FD(FD) {}
-  JitCall(Kind K, ConstructorCall C, TCppConstFunction_t Ctor)
-      : m_ConstructorCall(C), m_Kind(K), m_FD(Ctor) {}
-  JitCall(Kind K, DestructorCall C, TCppConstFunction_t Dtor)
-      : m_DestructorCall(C), m_Kind(K), m_FD(Dtor) {}
-
-  /// Checks if the passed arguments are valid for the given function.
-  CPPINTEROP_API bool AreArgumentsValid(void* result, ArgList args, void* self,
-                                        size_t nary) const;
 
-  /// This function is used for debugging, it reports when the function was
-  /// called.
-  CPPINTEROP_API void ReportInvokeStart(void* result, ArgList args,
-                                        void* self) const;
-  CPPINTEROP_API void ReportInvokeStart(void* object, unsigned long nary,
-                                        int withFree) const;
-  void ReportInvokeEnd() const;
+#include "CppInterOp/CppInterOpTypes.h"
 
-public:
-  Kind getKind() const { return m_Kind; }
-  bool isValid() const { return getKind() != kUnknown; }
-  bool isInvalid() const { return !isValid(); }
-  explicit operator bool() const { return isValid(); }
-
-  // Specialized for calling void functions.
-  void Invoke(ArgList args = {}, void* self = nullptr) const {
-    Invoke(/*result=*/nullptr, args, self);
-  }
-
-  /// Makes a call to a generic function or method.
-  ///\param[in] result - the location where the return result will be placed.
-  ///\param[in] args - a pointer to a argument list and argument size.
-  ///\param[in] self - the 'this pointer' of the object.
-  // FIXME: Adjust the arguments and their types: args_size can be unsigned;
-  // self can go in the end and be nullptr by default; result can be a nullptr
-  // by default. These changes should be synchronized with the wrapper if we
-  // decide to directly.
-  void Invoke(void* result, ArgList args = {}, void* self = nullptr) const {
-    // NOLINTBEGIN(*-type-union-access)
-    // Its possible the JitCall object deals with structor decls but went
-    // through Invoke
-
-    switch (m_Kind) {
-    case kUnknown:
-      assert(0 && "Attempted to call an invalid function declaration");
-      break;
-
-    case kGenericCall:
-#ifndef NDEBUG
-      // We pass 1UL to nary which is only relevant for structors
-      assert(AreArgumentsValid(result, args, self, 1UL) && "Invalid args!");
-      ReportInvokeStart(result, args, self);
-#endif // NDEBUG
-      m_GenericCall(self, args.m_ArgSize, args.m_Args, result);
-      break;
-
-    case kConstructorCall:
-      // Forward if we intended to call a constructor (nary cannot be inferred,
-      // so we stick to constructing a single object)
-      InvokeConstructor(result, /*nary=*/1UL, args, self);
-      break;
-    case kDestructorCall:
-      // Forward if we intended to call a dtor with only 1 parameter.
-      assert(!args.m_Args && "Destructor called with arguments");
-      InvokeDestructor(result, /*nary=*/0UL, /*withFree=*/true);
-      break;
-    }
-    // NOLINTEND(*-type-union-access)
-  }
-  /// Makes a call to a destructor.
-  ///\param[in] object - the pointer of the object whose destructor we call.
-  ///\param[in] nary - the count of the objects we destruct if we deal with an
-  ///           array of objects.
-  ///\param[in] withFree - true if we should call operator delete or false if
-  ///           we should call only the destructor.
-  // FIXME: Change the type of withFree from int to bool in the wrapper code.
-  void InvokeDestructor(void* object, unsigned long nary = 0,
-                        int withFree = true) const {
-    assert(m_Kind == kDestructorCall && "Wrong overload!");
-#ifndef NDEBUG
-    ReportInvokeStart(object, nary, withFree);
-#endif // NDEBUG
-    m_DestructorCall(object, nary, withFree);
-  }
-
-  /// Makes a call to a constructor.
-  ///\param[in] result - the memory address at which we construct the object
-  ///           (placement new).
-  ///\param[in] nary - Use array new if we have to construct an array of
-  ///           objects (nary > 1).
-  ///\param[in] args - a pointer to a argument list and argument size.
-  ///\param[in] is_arena - a pointer that indicates if placement new is to be
-  /// used
-  // FIXME: Change the type of withFree from int to bool in the wrapper code.
-  void InvokeConstructor(void* result, unsigned long nary = 1,
-                         ArgList args = {}, void* is_arena = nullptr) const {
-    assert(m_Kind == kConstructorCall && "Wrong overload!");
-#ifndef NDEBUG
-    assert(AreArgumentsValid(result, args, /*self=*/nullptr, nary) &&
-           "Invalid args!");
-    ReportInvokeStart(result, args, nullptr);
-#endif // NDEBUG
-    m_ConstructorCall(result, nary, args.m_ArgSize, args.m_Args, is_arena);
-  }
-};
-
-/// Holds information for instantiating a template.
-struct TemplateArgInfo {
-  TCppType_t m_Type;
-  const char* m_IntegralValue;
-  TemplateArgInfo(TCppScope_t type, const char* integral_value = nullptr)
-      : m_Type(type), m_IntegralValue(integral_value) {}
-};
-
-// FIXME: Rework GetDimensions to make this enum redundant.
-namespace DimensionValue {
-enum : long int {
-  UNKNOWN_SIZE = -1,
-};
-} // namespace DimensionValue
-
-/// @name Stream Redirection
-///@{
-
-enum CaptureStreamKind : char {
-  kStdOut = 1, ///< stdout
-  kStdErr,     ///< stderr
-};
+#include <sys/types.h>
 
-///@}
+namespace CppImpl {
 
 // Public API function declarations. Generated by cppinterop-tblgen
 // from CppInterOp.td. Do not edit this section by hand.
@@ -362,8 +36,6 @@ CPPINTEROP_API pid_t GetExecutorPID();
 
 } // namespace CppImpl
 
-#ifndef CPPINTEROP_DISPATCH_H
 // NOLINTNEXTLINE(misc-unused-alias-decls)
 namespace Cpp = CppImpl;
-#endif
 #endif // CPPINTEROP_CPPINTEROP_H