Merge branch 'swig:master' into pr-1262

Author: willadsen

CHANGES.current

@@ -7,6 +7,16 @@ the issue number to the end of the URL: https://github.com/swig/swig/issues/
 Version 4.5.0 (in progress)
 ===========================
 
+2025-11-08: wsfulton
+            Fix handling of typedef to void in class methods/constructor's parameter
+            lists, such as:
+
+              typedef void VOID_TYPE;
+              struct S {
+                 S(VOID_TYPE);
+                 int f(VOID_TYPE) const;
+              };
+
 2025-11-06: olly
 	    [Octave, Ruby] #3281 `FALSE` and `TRUE` are no longer treated as
 	    aliases of `false` and `true` when generating documentation comments.

Examples/test-suite/python/voidtest_runme.py

@@ -1,11 +1,18 @@
 import voidtest
 
 voidtest.globalfunc()
+voidtest.globalfunc_typedef()
 f = voidtest.Foo()
 f.memberfunc()
 
 voidtest.Foo.staticmemberfunc()
 
+fv = voidtest.FooVoidTypedef()
+fv.memberfunc()
+fv.memberfunc_const()
+fv.memberfunc_const_voidptr()
+
+voidtest.FooVoidTypedef.staticmemberfunc()
 
 def fvoid():
     pass

Examples/test-suite/voidtest.i

@@ -1,9 +1,11 @@
 %module voidtest
 
 %inline %{
+void globalfunc(void) {}
 
-void globalfunc(void) {
-}
+typedef void VOID_TP;
+typedef VOID_TP VOID_TYPE;
+void globalfunc_typedef(VOID_TYPE) {}
 
 class Foo {
 public:
@@ -13,6 +15,15 @@ public:
    static void staticmemberfunc(void) { }
 };
 
+class FooVoidTypedef {
+public:
+   FooVoidTypedef(VOID_TYPE) { }
+   void memberfunc(VOID_TYPE) { }
+   void memberfunc_const(VOID_TYPE) const { }
+   void *memberfunc_const_voidptr(VOID_TYPE) const { return 0; }
+   virtual ~FooVoidTypedef() { }
+   static void staticmemberfunc(VOID_TYPE) { }
+};
 
 void *vfunc1(void *f) { return f; }
 void *vfunc2(Foo *f) { return f; }

Source/CParse/cparse.h

@@ -57,7 +57,6 @@ extern "C" {
 /* util.c */
   extern void Swig_cparse_replace_descriptor(String *s);
   extern SwigType *Swig_cparse_smartptr(Node *n);
-  extern void cparse_normalize_void(Node *);
   extern Parm *Swig_cparse_parm(String *s);
   extern ParmList *Swig_cparse_parms(String *s, Node *file_line_node);
   extern Node *Swig_cparse_new_node(const_String_or_char_ptr tag);

Source/CParse/parser.y

@@ -407,9 +407,6 @@ static void add_symbols(Node *n) {
   String *decl;
   String *wrn = 0;
 
-  if (inclass && n) {
-    cparse_normalize_void(n);
-  }
   while (n) {
     String *symname = 0;
     String *old_prefix = 0;

Source/CParse/util.c

@@ -92,25 +92,6 @@ SwigType *Swig_cparse_smartptr(Node *n) {
     return smart;
 }
 
-/* -----------------------------------------------------------------------------
- * cparse_normalize_void()
- *
- * This function is used to replace arguments of the form (void) with empty
- * arguments in C++
- * ----------------------------------------------------------------------------- */
-
-void cparse_normalize_void(Node *n) {
-  String *decl = Getattr(n, "decl");
-  Parm *parms = Getattr(n, "parms");
-
-  if (SwigType_isfunction(decl)) {
-    if ((ParmList_len(parms) == 1) && (SwigType_type(Getattr(parms, "type")) == T_VOID)) {
-      Replaceall(decl, "f(void).", "f().");
-      Delattr(n, "parms");
-    }
-  }
-}
-
 /* -----------------------------------------------------------------------------
  * Swig_cparse_new_node()
  *

Source/Modules/directors.cxx

@@ -46,6 +46,7 @@ String *Swig_csuperclass_call(String *base, String *method, ParmList *l) {
     else
       Printv(call, parm_name, NIL);
     Delete(pname_created);
+    Delete(rpt);
   }
   Printf(call, ")");
   return call;

Source/Modules/typepass.cxx

@@ -48,6 +48,32 @@ class TypePass:private Dispatcher {
     normalize(0) {
   }
 
+  /* -----------------------------------------------------------------------------
+   * normalize_void()
+   *
+   * This function is used to replace arguments of the form (void) with empty
+   * arguments in C++ class constructors and methods only (not global functions).
+   * ----------------------------------------------------------------------------- */
+
+  void normalize_void(Node *n) {
+    String *decl = Getattr(n, "decl");
+    Parm *parms = Getattr(n, "parms");
+
+    if (SwigType_isfunction(decl)) {
+      if ((ParmList_len(parms) == 1) && (SwigType_type(Getattr(parms, "type")) == T_VOID)) {
+	String *qualifiers = SwigType_pop_function_qualifiers(decl);
+	String *func = SwigType_pop_function(decl);
+	SwigType_add_function(decl, 0);
+	SwigType_push(decl, qualifiers);
+
+	Delattr(n, "parms");
+
+	Delete(func);
+	Delete(qualifiers);
+      }
+    }
+  }
+
   /* Normalize a type. Replaces type with fully qualified version */
   void normalize_type(SwigType *ty) {
     SwigType *qty;
@@ -749,6 +775,9 @@ class TypePass:private Dispatcher {
     }
 
     /* Normalize types. */
+    if (inclass) {
+      normalize_void(n);
+    }
     SwigType *ty = Getattr(n, "type");
     if (!ty) {
       return SWIG_OK;
@@ -819,6 +848,10 @@ class TypePass:private Dispatcher {
       Delattr(n, "throws");
     }
 
+    /* Normalize types. */
+    if (inclass) {
+      normalize_void(n);
+    }
     normalize_parms(Getattr(n, "parms"));
     normalize_parms(Getattr(n, "throws"));
 

Source/Swig/cwrap.c

@@ -393,8 +393,8 @@ String *Swig_cfunction_call(const_String_or_char_ptr name, ParmList *parms) {
 
   while (p) {
     SwigType *pt = Getattr(p, "type");
-    SwigType *rpt = SwigType_typedef_resolve_all(pt);
-    if ((SwigType_type(rpt) != T_VOID)) {
+    if ((SwigType_type(pt) != T_VOID)) {
+      SwigType *rpt = SwigType_typedef_resolve_all(pt);
       String *pname = Swig_cparm_name(p, i);
       String *rcaststr = SwigType_rcaststr(rpt, pname);
       if (comma)
@@ -431,6 +431,7 @@ static String *Swig_cmethod_call(const_String_or_char_ptr name, ParmList *parms,
   String *func, *nname;
   int i = 0;
   Parm *p = parms;
+  SwigType *pt;
   int comma = 0;
 
   func = NewStringEmpty();
@@ -455,7 +456,7 @@ static String *Swig_cmethod_call(const_String_or_char_ptr name, ParmList *parms,
     Replaceall(func, "this", rcaststr);
     Delete(rcaststr);
   } else {
-    SwigType *pt = Getattr(p, "type");
+    pt = Getattr(p, "type");
 
     /* If the method is invoked through a dereferenced pointer, we don't add any casts
        (needed for smart pointers).  Otherwise, we cast to the appropriate type */
@@ -491,14 +492,13 @@ static String *Swig_cmethod_call(const_String_or_char_ptr name, ParmList *parms,
   i++;
   p = nextSibling(p);
   while (p) {
-    SwigType *pt = Getattr(p, "type");
-    SwigType *rpt = SwigType_typedef_resolve_all(pt);
-    if ((SwigType_type(rpt) != T_VOID)) {
+    pt = Getattr(p, "type");
+    if ((SwigType_type(pt) != T_VOID)) {
       String *pname = Swig_cparm_name(p, i);
       String *rcaststr = SwigType_rcaststr(pt, pname);
       if (comma)
 	Append(func, ",");
-      if (cparse_cplusplus && SwigType_type(rpt) == T_USER)
+      if (cparse_cplusplus && SwigType_type(pt) == T_USER)
 	Printv(func, "SWIG_STD_MOVE(", rcaststr, ")", NIL);
       else
 	Printv(func, rcaststr, NIL);
@@ -547,6 +547,7 @@ static String *Swig_cppconstructor_base_call(const_String_or_char_ptr name, Parm
   int i = 0;
   int comma = 0;
   Parm *p = parms;
+  SwigType *pt;
   if (skip_self) {
     if (p)
       p = nextSibling(p);
@@ -556,9 +557,8 @@ static String *Swig_cppconstructor_base_call(const_String_or_char_ptr name, Parm
   func = NewStringEmpty();
   Printf(func, "new %s(", nname);
   while (p) {
-    SwigType *pt = Getattr(p, "type");
-    SwigType *rpt = SwigType_typedef_resolve_all(pt);
-    if ((SwigType_type(rpt) != T_VOID)) {
+    pt = Getattr(p, "type");
+    if ((SwigType_type(pt) != T_VOID)) {
       String *rcaststr = 0;
       String *pname = 0;
       if (comma)
@@ -574,7 +574,7 @@ static String *Swig_cppconstructor_base_call(const_String_or_char_ptr name, Parm
 	  pname = Copy(Getattr(p, "name"));
       }
       rcaststr = SwigType_rcaststr(pt, pname);
-      if (cparse_cplusplus && SwigType_type(rpt) == T_USER)
+      if (cparse_cplusplus && SwigType_type(pt) == T_USER)
 	Printv(func, "SWIG_STD_MOVE(", rcaststr, ")", NIL);
       else
 	Printv(func, rcaststr, NIL);