diff --git a/Doc/Manual/Php.html b/Doc/Manual/Php.html
index 813368ec3..a887471f3 100644
--- a/Doc/Manual/Php.html
+++ b/Doc/Manual/Php.html
@@ -346,6 +346,79 @@ $c = bar(3.5);  # Use default argument for 2nd parameter
 
 </pre></div>
 
+<p>
+SWIG generates PHP type declarations for function parameters and return
+types for PHP 8 and later (we don't try to support PHP 7's more limited type
+declarations and the generated wrappers compiled for PHP 7 will not have any
+type declarations).
+</p>
+
+<p>
+You can control the generation of PHP type declarations using
+the "php:type" %feature.  This has three settings:
+</p>
+
+<ul>
+    <li> <p>If unset or set to "0" then no type declarations are generated, e.g.: <tt>%feature("php:type", "0");</tt>
+	</p></li>
+    <li> <p>If set to "1" then type declarations are generated for both parameters and return types, e.g.: <tt>%feature("php:type", "1");</tt>
+	</p></li>
+    <li> <p>The default setting is "compat", which is the same as "1" except no
+	return type declarations are generated for virtual methods for which
+	directors are enabled.  This provides better compatibility for PHP
+	subclasses of wrapped virtual methods in existing SWIG-generated bindings, e.g.: <tt>%feature("php:type", "compat");</tt>
+	</p></li>
+</ul>
+
+<p>
+If you have an existing PHP interface and are upgrading to SWIG &gt;= 4.1.0
+then the default "compat" setting should work well.
+</p>
+
+<p>
+If you're writing a new set of bindings and <b>only targetting PHP8 or newer</b>
+then enabling type declarations everywhere probably makes sense.  It will
+only actually make a difference if you enable directors and are wrapping C++
+classes with virtual methods, but doing it anyway means you won't forget to if
+the code you are wrapping later evolves to have such classes and methods.
+</p>
+
+<p>
+The type declaration information will make the generated source code and
+compiler extension module larger, so you might want to turn off type
+declarations if keeping these small is important to you.  If you find you
+need to turn off type declarations to fix a problem, please let us know
+via our github issue tracker.
+</p>
+
+<p>
+Note that being a SWIG feature this can be specified globally (like above) or
+per class, per method, etc.  See the <a
+href="Customization.html#Customization_features">%feature directives</a>
+section for full details of how to control at a fine-grained level.
+</p>
+
+<p>
+The PHP type information is specified via a "phptype" attribute on "in" and
+"out" typemaps, and these have been added for all the typemaps we supply for
+PHP.  We don't currently support this for "argout" templates, but probably
+will in a future version.
+</p>
+
+<p>
+If you have written custom SWIG typemaps for PHP and want to add PHP type
+declarations, then the syntax is very like how you'd specify the type in
+PHP code, e.g. <tt>%typemap(in, phptype="int|string|Foo")</tt> means the
+typemap accepts a PHP int or string or an object of class Foo,
+<tt>%typemap(in, phptype="?int")</tt> means a PHP int or NULL, etc.
+As well as the standard PHP type declaration types, SWIG also understands the
+special type "SWIGTYPE" as an entry in phptype, which means the PHP type
+corresponding to the type that this typemap matched on - for a object this
+will give you the PHP class for the object, and for a pointer to a non-class
+type it will give you the name of the PHP class SWIG created for that
+pointer type.
+</p>
+
 <!-- This isn't correct for 1.3.30 and needs rewriting to reflect reality
 <p>
 Because PHP is a dynamically typed language, the default typemaps
diff --git a/Examples/test-suite/li_factory.i b/Examples/test-suite/li_factory.i
index 233c9c36b..0de3791b3 100644
--- a/Examples/test-suite/li_factory.i
+++ b/Examples/test-suite/li_factory.i
@@ -16,7 +16,8 @@
   struct Geometry {
     enum GeomType{
       POINT,
-      CIRCLE
+      CIRCLE,
+      SHAPELESS
     };
 
     virtual ~Geometry() {}
diff --git a/Examples/test-suite/php/argout_runme.php b/Examples/test-suite/php/argout_runme.php
index d233cf0f6..554d07756 100644
--- a/Examples/test-suite/php/argout_runme.php
+++ b/Examples/test-suite/php/argout_runme.php
@@ -20,11 +20,14 @@ $tr=copy_intp(4);
 check::equal(4,inctr($tr),"4==incr($tr)");
 check::equal(5,intp_value($tr),"5==$tr");
 
-# Check the voidhandle call, first with null
+# Check the voidhandle call, first with NULL and then with the SWIG\p_void we
+# get from the first call.
 $handle=NULL;
-voidhandle($handle);
-check::equal(get_class($handle),"SWIG\\_p_void",'$handle is not _p_void');
-$handledata=handle($handle);
-check::equal($handledata,"Here it is","\$handledata != \"Here it is\"");
+for ($i=0; $i != 1; $i++) {
+  voidhandle($handle);
+  check::equal(get_class($handle),"SWIG\\_p_void",'$handle is not _p_void');
+  $handledata=handle($handle);
+  check::equal($handledata,"Here it is","\$handledata != \"Here it is\"");
+}
 
 check::done();
diff --git a/Examples/test-suite/php/li_factory_runme.php b/Examples/test-suite/php/li_factory_runme.php
index 3ccdd035f..18545fec7 100644
--- a/Examples/test-suite/php/li_factory_runme.php
+++ b/Examples/test-suite/php/li_factory_runme.php
@@ -17,4 +17,7 @@ $point = Geometry::create(Geometry::POINT);
 $w = $point->width();
 check::equal($w, 1.0, "w failed");
 
+$point = Geometry::create(Geometry::SHAPELESS);
+check::equal($point, NULL, "NULL failed");
+
 check::done();
diff --git a/Lib/php/factory.i b/Lib/php/factory.i
index 5a1f9dc06..5f2b397ec 100644
--- a/Lib/php/factory.i
+++ b/Lib/php/factory.i
@@ -100,7 +100,7 @@ if (!dcast) {
 }%enddef
 
 %define %factory(Method,Types...)
-%typemap(out) Method {
+%typemap(out, phptype="?SWIGTYPE") Method {
   int dcast = 0;
   %formacro(%_factory_dispatch, Types)
   if (!dcast) {
diff --git a/Lib/php/php.swg b/Lib/php/php.swg
index b8722ace8..1120f226e 100644
--- a/Lib/php/php.swg
+++ b/Lib/php/php.swg
@@ -4,6 +4,11 @@
  * PHP configuration file
  * ----------------------------------------------------------------------------- */
 
+// Default to generating PHP type declarations (for PHP >= 8) except for
+// cases which are liable to cause compatibility issues with existing
+// bindings.
+%feature("php:type", "compat");
+
 %runtime "swigrun.swg"  // Common C API type-checking code
 %runtime "swigerrors.swg"    // SWIG errors
 %runtime "phprun.swg"	// PHP runtime functions
@@ -34,56 +39,56 @@
 
 %include <utils.i>
 
-%pass_by_val(bool,CONVERT_BOOL_IN);
+%pass_by_val(bool, "bool", CONVERT_BOOL_IN);
 
-%pass_by_val(size_t, CONVERT_INT_IN);
+%pass_by_val(size_t, "int", CONVERT_INT_IN);
 
-%pass_by_val(enum SWIGTYPE, CONVERT_INT_IN);
+%pass_by_val(enum SWIGTYPE, "int", CONVERT_INT_IN);
 
-%pass_by_val(signed int, CONVERT_INT_IN);
-%pass_by_val(int,CONVERT_INT_IN);
-%pass_by_val(unsigned int,CONVERT_INT_IN);
+%pass_by_val(signed int, "int", CONVERT_INT_IN);
+%pass_by_val(int,"int", CONVERT_INT_IN);
+%pass_by_val(unsigned int,"int", CONVERT_INT_IN);
 
-%pass_by_val(signed short, CONVERT_INT_IN);
-%pass_by_val(short,CONVERT_INT_IN);
-%pass_by_val(unsigned short, CONVERT_INT_IN);
+%pass_by_val(signed short, "int", CONVERT_INT_IN);
+%pass_by_val(short,"int", CONVERT_INT_IN);
+%pass_by_val(unsigned short, "int", CONVERT_INT_IN);
 
-%pass_by_val(signed long, CONVERT_INT_IN);
-%pass_by_val(long, CONVERT_INT_IN);
-%pass_by_val(unsigned long, CONVERT_INT_IN);
+%pass_by_val(signed long, "int", CONVERT_INT_IN);
+%pass_by_val(long, "int", CONVERT_INT_IN);
+%pass_by_val(unsigned long, "int", CONVERT_INT_IN);
 
-%pass_by_val(signed long long, CONVERT_LONG_LONG_IN);
-%pass_by_val(long long, CONVERT_LONG_LONG_IN);
-%pass_by_val(unsigned long long, CONVERT_UNSIGNED_LONG_LONG_IN);
+%pass_by_val(signed long long, "int|string", CONVERT_LONG_LONG_IN);
+%pass_by_val(long long, "int|string", CONVERT_LONG_LONG_IN);
+%pass_by_val(unsigned long long, "int|string", CONVERT_UNSIGNED_LONG_LONG_IN);
 
-%pass_by_val(signed char, CONVERT_INT_IN);
-%pass_by_val(char, CONVERT_CHAR_IN);
-%pass_by_val(unsigned char, CONVERT_INT_IN);
+%pass_by_val(signed char, "int", CONVERT_INT_IN);
+%pass_by_val(char, "string", CONVERT_CHAR_IN);
+%pass_by_val(unsigned char, "int", CONVERT_INT_IN);
 
-%pass_by_val(float, CONVERT_FLOAT_IN);
+%pass_by_val(float, "float", CONVERT_FLOAT_IN);
 
-%pass_by_val(double, CONVERT_FLOAT_IN);
+%pass_by_val(double, "float", CONVERT_FLOAT_IN);
 
-%pass_by_val(char *, CONVERT_STRING_IN);
+%pass_by_val(char *, "string", CONVERT_STRING_IN);
 %typemap(in) char *& = const char *&;
 %typemap(directorout) char *& = const char *&;
 
 // char array can be in/out, though the passed string may not be big enough...
 // so we have to size it
-%typemap(in) char[ANY]
+%typemap(in, phptype="string") char[ANY]
 %{
    convert_to_string(&$input);
    $1 = ($1_ltype) Z_STRVAL($input);
 %}
 
-%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) %{
+%typemap(in, phptype="string") (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) %{
    convert_to_string(&$input);
    $1 = ($1_ltype) Z_STRVAL($input);
    $2 = ($2_ltype) Z_STRLEN($input);
 %}
 
 /* Object passed by value. Convert to a pointer */
-%typemap(in) SWIGTYPE ($&1_ltype tmp)
+%typemap(in, phptype="SWIGTYPE") SWIGTYPE ($&1_ltype tmp)
 %{
   if (SWIG_ConvertPtr(&$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
     zend_type_error("Expected $&1_descriptor for argument $argnum of $symname");
@@ -101,7 +106,7 @@
   $result = *tmp;
 %}
 
-%typemap(in) SWIGTYPE *,
+%typemap(in, phptype="?SWIGTYPE") SWIGTYPE *,
 	     SWIGTYPE []
 %{
   if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
@@ -120,7 +125,7 @@
   swig_acquire_ownership_obj((void*)$result, own);
 %}
 
-%typemap(in) SWIGTYPE &,
+%typemap(in, phptype="SWIGTYPE") SWIGTYPE &,
              SWIGTYPE &&
 %{
   if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
@@ -139,7 +144,7 @@
   $result = tmp;
 %}
 
-%typemap(in) SWIGTYPE *const& ($*ltype temp)
+%typemap(in, phptype="?SWIGTYPE") SWIGTYPE *const& ($*ltype temp)
 %{
   if (SWIG_ConvertPtr(&$input, (void **) &temp, $*1_descriptor, 0) < 0) {
     zend_type_error("Expected $*1_descriptor for argument $argnum of $symname");
@@ -148,7 +153,7 @@
   $1 = ($1_ltype)&temp;
 %}
 
-%typemap(in) SWIGTYPE *DISOWN
+%typemap(in, phptype="?SWIGTYPE") SWIGTYPE *DISOWN
 %{
   if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN) < 0) {
     zend_type_error("Expected $1_descriptor for argument $argnum of $symname");
@@ -161,7 +166,7 @@
                  SWIGTYPE &,
                  SWIGTYPE &&;
 
-%typemap(in) void *
+%typemap(in, phptype="?SWIGTYPE") void *
 %{
   if (SWIG_ConvertPtr(&$input, (void **) &$1, 0, 0) < 0) {
     /* Allow NULL from php for void* */
@@ -176,7 +181,7 @@
 
 /* Special case when void* is passed by reference so it can be made to point
    to opaque api structs */
-%typemap(in, byref=1) void ** ($*1_ltype ptr, int force),
+%typemap(in, phptype="?SWIG\\_p_void", byref=1) void ** ($*1_ltype ptr, int force),
              void *& ($*1_ltype ptr, int force)
 {
   /* If they pass NULL by reference, make it into a void*
@@ -211,7 +216,8 @@
 
 /* Typemap for output values */
 
-%typemap(out) int,
+%typemap(out, phptype="int")
+              int,
               unsigned int,
               short,
               unsigned short,
@@ -224,12 +230,12 @@
   RETVAL_LONG($1);
 %}
 
-%typemap(out) enum SWIGTYPE
+%typemap(out, phptype="int") enum SWIGTYPE
 %{
   RETVAL_LONG((long)$1);
 %}
 
-%typemap(out) long long
+%typemap(out, phptype="int|string") long long
 %{
   if ((long long)LONG_MIN <= $1 && $1 <= (long long)LONG_MAX) {
     RETVAL_LONG((long)($1));
@@ -239,7 +245,7 @@
     RETVAL_STRING(temp);
   }
 %}
-%typemap(out) unsigned long long
+%typemap(out, phptype="int|string") unsigned long long
 %{
   if ($1 <= (unsigned long long)LONG_MAX) {
     RETVAL_LONG((long)($1));
@@ -250,7 +256,8 @@
   }
 %}
 
-%typemap(out) const int &,
+%typemap(out, phptype="int")
+              const int &,
               const unsigned int &,
               const short &,
               const unsigned short &,
@@ -264,17 +271,17 @@
   RETVAL_LONG(*$1);
 %}
 
-%typemap(out) const enum SWIGTYPE &
+%typemap(out, phptype="int") const enum SWIGTYPE &
 %{
   RETVAL_LONG((long)*$1);
 %}
 
-%typemap(out) const enum SWIGTYPE &&
+%typemap(out, phptype="int") const enum SWIGTYPE &&
 %{
   RETVAL_LONG((long)*$1);
 %}
 
-%typemap(out) const long long &
+%typemap(out, phptype="int|string") const long long &
 %{
   if ((long long)LONG_MIN <= *$1 && *$1 <= (long long)LONG_MAX) {
     RETVAL_LONG((long)(*$1));
@@ -284,7 +291,7 @@
     RETVAL_STRING(temp);
   }
 %}
-%typemap(out) const unsigned long long &
+%typemap(out, phptype="int|string") const unsigned long long &
 %{
   if (*$1 <= (unsigned long long)LONG_MAX) {
     RETVAL_LONG((long)(*$1));
@@ -323,12 +330,12 @@
     }
 %}
 
-%typemap(out) bool
+%typemap(out, phptype="bool") bool
 %{
   RETVAL_BOOL(($1) ? 1 : 0);
 %}
 
-%typemap(out) const bool &
+%typemap(out, phptype="bool") const bool &
 %{
   RETVAL_BOOL((*$1) ? 1 : 0);
 %}
@@ -338,13 +345,13 @@
   ZVAL_BOOL($input, ($1) ? 1 : 0);
 %}
 
-%typemap(out) float,
+%typemap(out, phptype="float") float,
               double
 %{
   RETVAL_DOUBLE($1);
 %}
 
-%typemap(out) const float &,
+%typemap(out, phptype="float") const float &,
               const double &
 %{
   RETVAL_DOUBLE(*$1);
@@ -356,18 +363,22 @@
   ZVAL_DOUBLE($input, $1);
 %}
 
-%typemap(out) char
+%typemap(out, phptype="string") char
 %{
   RETVAL_STRINGL(&$1, 1);
 %}
 
-%typemap(out) const char &
+%typemap(out, phptype="string") const char &
 %{
   RETVAL_STRINGL(&*$1, 1);
 %}
 
-%typemap(out) char *,
-              char []
+%typemap(out, phptype="string") char []
+%{
+  RETVAL_STRING((const char *)$1);
+%}
+
+%typemap(out, phptype="?string") char *
 %{
   if (!$1) {
     RETVAL_NULL();
@@ -376,7 +387,7 @@
   }
 %}
 
-%typemap(out) char *&
+%typemap(out, phptype="?string") char *&
 %{
   if (!*$1) {
     RETVAL_NULL();
@@ -385,7 +396,12 @@
   }
 %}
 
-%typemap(out) SWIGTYPE *,
+%typemap(out, phptype="?SWIGTYPE") SWIGTYPE *
+%{
+  SWIG_SetPointerZval($result, (void *)$1, $1_descriptor, $owner);
+%}
+
+%typemap(out, phptype="SWIGTYPE")
               SWIGTYPE [],
               SWIGTYPE &,
               SWIGTYPE &&
@@ -393,7 +409,7 @@
   SWIG_SetPointerZval($result, (void *)$1, $1_descriptor, $owner);
 %}
 
-%typemap(out) SWIGTYPE *const&
+%typemap(out, phptype="?SWIGTYPE") SWIGTYPE *const&
 %{
   SWIG_SetPointerZval($result, (void *)*$1, $*1_descriptor, $owner);
 %}
@@ -406,27 +422,32 @@
   SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, $owner);
 %}
 
-%typemap(out) SWIGTYPE (CLASS::*)
+%typemap(out, phptype="SWIGTYPE") SWIGTYPE (CLASS::*)
 {
   void * p = emalloc(sizeof($1));
   memcpy(p, &$1, sizeof($1));
   SWIG_SetPointerZval($result, (void *)p, $&1_descriptor, 1);
 }
 
-%typemap(in) SWIGTYPE (CLASS::*)
+%typemap(in, phptype="SWIGTYPE") SWIGTYPE (CLASS::*)
 {
   void * p = SWIG_Z_FETCH_OBJ_P(&$input)->ptr;
   memcpy(&$1, p, sizeof($1));
 }
 
-%typemap(out) SWIGTYPE *DYNAMIC,
-              SWIGTYPE &DYNAMIC
+%typemap(out, phptype="?SWIGTYPE") SWIGTYPE *DYNAMIC
 {
   swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
   SWIG_SetPointerZval($result, (void *)$1, ty, $owner);
 }
 
-%typemap(out) SWIGTYPE
+%typemap(out, phptype="SWIGTYPE") SWIGTYPE &DYNAMIC
+{
+  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
+  SWIG_SetPointerZval($result, (void *)$1, ty, $owner);
+}
+
+%typemap(out, phptype="SWIGTYPE") SWIGTYPE
 {
 #ifdef __cplusplus
   $&1_ltype resultobj = new $1_ltype((const $1_ltype &) $1);
@@ -442,9 +463,9 @@
   SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1);
 %}
 
-%typemap(out) void "";
+%typemap(out, phptype="void") void "";
 
-%typemap(out) char [ANY]
+%typemap(out, phptype="string") char [ANY]
 {
   size_t len = 0;
   while (len < $1_dim0 && $1[len]) ++len;
diff --git a/Lib/php/phppointers.i b/Lib/php/phppointers.i
index 8b4e75e60..a4ff3c0bd 100644
--- a/Lib/php/phppointers.i
+++ b/Lib/php/phppointers.i
@@ -1,5 +1,5 @@
-%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
-%typemap(in, byref=1) TYPE *REF ($*1_ltype tmp),
+%define %pass_by_ref( TYPE, PHP_TYPE, CONVERT_IN, CONVERT_OUT )
+%typemap(in,byref=1,phptype=PHP_TYPE) TYPE *REF ($*1_ltype tmp),
              TYPE &REF ($*1_ltype tmp)
 %{
   if (Z_ISREF($input)) {
@@ -18,25 +18,25 @@
 %}
 %enddef
 
-%pass_by_ref( size_t, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( size_t, "int", CONVERT_INT_IN, ZVAL_LONG );
 
-%pass_by_ref( signed int, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( int, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( unsigned int, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( signed int, "int", CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( int, "int", CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned int, "int", CONVERT_INT_IN, ZVAL_LONG );
 
-%pass_by_ref( signed short, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( short, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( unsigned short, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( signed short, "int", CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( short, "int", CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned short, "int", CONVERT_INT_IN, ZVAL_LONG );
 
-%pass_by_ref( signed long, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( long, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( unsigned long, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( signed long, "int", CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( long, "int", CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( unsigned long, "int", CONVERT_INT_IN, ZVAL_LONG );
 
-%pass_by_ref( signed char, CONVERT_INT_IN, ZVAL_LONG );
-%pass_by_ref( char, CONVERT_CHAR_IN, ZVAL_STRING );
-%pass_by_ref( unsigned char, CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( signed char, "int", CONVERT_INT_IN, ZVAL_LONG );
+%pass_by_ref( char, "string", CONVERT_CHAR_IN, ZVAL_STRING );
+%pass_by_ref( unsigned char, "int", CONVERT_INT_IN, ZVAL_LONG );
 
-%pass_by_ref( float, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
-%pass_by_ref( double, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
+%pass_by_ref( float, "float", CONVERT_FLOAT_IN, ZVAL_DOUBLE );
+%pass_by_ref( double, "float", CONVERT_FLOAT_IN, ZVAL_DOUBLE );
 
-%pass_by_ref( char *, CONVERT_CHAR_IN, ZVAL_STRING );
+%pass_by_ref( char *, "string", CONVERT_CHAR_IN, ZVAL_STRING );
diff --git a/Lib/php/phprun.swg b/Lib/php/phprun.swg
index 69b00bc4b..a24b2551c 100644
--- a/Lib/php/phprun.swg
+++ b/Lib/php/phprun.swg
@@ -20,6 +20,27 @@ extern "C" {
 #include "zend_exceptions.h"
 #include "zend_inheritance.h"
 
+#if PHP_MAJOR_VERSION == 7
+/* These macros were new in PHP 8.0.  For PHP 7.x we define them to give the
+ * same result except without any type declarations.  PHP 7.x supports type
+ * declarations, but not for the return type, and alternate types aren't
+ * supported, so we don't try to support these.
+ */
+# define ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(name, byref, num_req, classes, types) \
+    ZEND_BEGIN_ARG_INFO_EX(name, 0, byref, num_req)
+# define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(name, byref, num_req, types) \
+    ZEND_BEGIN_ARG_INFO_EX(name, 0, byref, num_req)
+
+/* NB We can just ignore `default` here we currently always pass NULL for it
+ * (this mechnism for specifying default parameter values was new in PHP 8.0
+ * so it's not useful while we still want to support PHP7 too).
+ */
+# define ZEND_ARG_OBJ_TYPE_MASK(byref, name, classes, types, default) \
+    ZEND_ARG_INFO(byref, name)
+# define ZEND_ARG_TYPE_MASK(byref, name, types, default) \
+    ZEND_ARG_INFO(byref, name)
+#endif
+
 #include <stdlib.h> /* for abort(), used in generated code. */
 
 #define SWIG_BOOL_CONSTANT(N, V) REGISTER_BOOL_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
diff --git a/Lib/php/std_string.i b/Lib/php/std_string.i
index 082a32ce1..081efe3a3 100644
--- a/Lib/php/std_string.i
+++ b/Lib/php/std_string.i
@@ -27,7 +27,7 @@ namespace std {
         $1 = (Z_TYPE($input) == IS_STRING) ? 1 : 0;
     %}
 
-    %typemap(in) string %{
+    %typemap(in, phptype="string") string %{
         convert_to_string(&$input);
         $1.assign(Z_STRVAL($input), Z_STRLEN($input));
     %}
@@ -37,7 +37,7 @@ namespace std {
         $result.assign(Z_STRVAL_P($input), Z_STRLEN_P($input));
     %}
 
-    %typemap(out) string %{
+    %typemap(out, phptype="string") string %{
         ZVAL_STRINGL($result, $1.data(), $1.size());
     %}
 
@@ -45,7 +45,7 @@ namespace std {
         ZVAL_STRINGL($input, $1.data(), $1.size());
     %}
 
-    %typemap(out) const string & %{
+    %typemap(out, phptype="string") const string & %{
         ZVAL_STRINGL($result, $1->data(), $1->size());
     %}
 
@@ -54,7 +54,7 @@ namespace std {
         return;
     %}
 
-    %typemap(in) const string & ($*1_ltype temp) %{
+    %typemap(in, phptype="string") const string & ($*1_ltype temp) %{
         convert_to_string(&$input);
         temp.assign(Z_STRVAL($input), Z_STRLEN($input));
         $1 = &temp;
@@ -62,7 +62,7 @@ namespace std {
 
     /* These next two handle a function which takes a non-const reference to
      * a std::string and modifies the string. */
-    %typemap(in,byref=1) string & ($*1_ltype temp) %{
+    %typemap(in,byref=1, phptype="string") string & ($*1_ltype temp) %{
         {
           zval * p = Z_ISREF($input) ? Z_REFVAL($input) : &$input;
           convert_to_string(p);
diff --git a/Lib/php/typemaps.i b/Lib/php/typemaps.i
index 3cfa3f0f7..321b1202c 100644
--- a/Lib/php/typemaps.i
+++ b/Lib/php/typemaps.i
@@ -25,7 +25,7 @@
  * ----------------------------------------------------------------------------- */
 
 %define BOOL_TYPEMAP(TYPE)
-%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%typemap(in, phptype="bool") TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
 %{
   convert_to_boolean(&$input);
   temp = (Z_TYPE($input) == IS_TRUE);
@@ -39,7 +39,7 @@
   ZVAL_BOOL(&o, temp$argnum);
   t_output_helper($result, &o);
 }
-%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
+%typemap(in, phptype="float") TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
 %{
   convert_to_boolean($input);
   lvalue = (Z_TYPE_P($input) == IS_TRUE);
@@ -52,7 +52,7 @@
 %enddef
 
 %define DOUBLE_TYPEMAP(TYPE)
-%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%typemap(in, phptype="float") TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
 %{
   temp = (TYPE) zval_get_double(&$input);
   $1 = &temp;
@@ -65,7 +65,7 @@
   ZVAL_DOUBLE(&o, temp$argnum);
   t_output_helper($result, &o);
 }
-%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
+%typemap(in, phptype="float") TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
 %{
   dvalue = (TYPE) zval_get_double(&$input);
   $1 = &dvalue;
@@ -77,7 +77,7 @@
 %enddef
 
 %define INT_TYPEMAP(TYPE)
-%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%typemap(in, phptype="int") TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
 %{
   temp = (TYPE) zval_get_long(&$input);
   $1 = &temp;
@@ -90,7 +90,7 @@
   ZVAL_LONG(&o, temp$argnum);
   t_output_helper($result, &o);
 }
-%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
+%typemap(in, phptype="int") TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
 %{
   lvalue = (TYPE) zval_get_long(&$input);
   $1 = &lvalue;
@@ -128,7 +128,7 @@ INT_TYPEMAP(long long);
   }
   t_output_helper($result, &o);
 }
-%typemap(in) TYPE *REFERENCE (long long lvalue)
+%typemap(in, phptype="int|string") TYPE *REFERENCE (long long lvalue)
 %{
   CONVERT_LONG_LONG_IN(lvalue, long long, $input)
   $1 = &lvalue;
@@ -167,7 +167,7 @@ INT_TYPEMAP(unsigned long long);
   }
   t_output_helper($result, &o);
 }
-%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
+%typemap(in, phptype="int|string") TYPE *REFERENCE (unsigned long long lvalue)
 %{
   CONVERT_UNSIGNED_LONG_LONG_IN(lvalue, unsigned long long, $input)
   $1 = &lvalue;
@@ -253,7 +253,7 @@ INT_TYPEMAP(unsigned long long);
 %typemap(argout) unsigned long long &INOUT = unsigned long long *OUTPUT;
 %typemap(argout) signed char &INOUT = signed char *OUTPUT;
 
-%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
+%typemap(in, phptype="string") char INPUT[ANY] ( char temp[$1_dim0] )
 %{
   convert_to_string(&$input);
   strncpy(temp, Z_STRVAL($input), $1_dim0);
@@ -268,7 +268,7 @@ INT_TYPEMAP(unsigned long long);
   t_output_helper($result, &o);
 }
 
-%typemap(in,numinputs=0) void **OUTPUT (int force),
+%typemap(in,numinputs=0,phptype="?SWIGTYPE") void **OUTPUT (int force),
                          void *&OUTPUT (int force)
 %{
   /* If they pass NULL by reference, make it into a void*
diff --git a/Lib/php/utils.i b/Lib/php/utils.i
index b8fd9091d..2ed3532a4 100644
--- a/Lib/php/utils.i
+++ b/Lib/php/utils.i
@@ -63,12 +63,12 @@
   }
 %enddef
 
-%define %pass_by_val( TYPE, CONVERT_IN )
-%typemap(in) TYPE
+%define %pass_by_val( TYPE, PHP_TYPE, CONVERT_IN )
+%typemap(in, phptype=PHP_TYPE) TYPE
 %{
   CONVERT_IN($1,$1_ltype,$input);
 %}
-%typemap(in) const TYPE & ($*1_ltype temp)
+%typemap(in, phptype=PHP_TYPE) const TYPE & ($*1_ltype temp)
 %{
   CONVERT_IN(temp,$*1_ltype,$input);
   $1 = &temp;
diff --git a/Source/Modules/php.cxx b/Source/Modules/php.cxx
index 4320032d3..1887bba3c 100644
--- a/Source/Modules/php.cxx
+++ b/Source/Modules/php.cxx
@@ -176,7 +176,95 @@ static void SwigPHP_emit_pointer_type_registrations() {
   }
 }
 
+// Class encapsulating the machinery to add PHP type declarations.
+class PHPTypes {
+  Hash *phptypes;
+
+  // List with an entry for each parameter and one for the return type.
+  //
+  // We assemble the types in here before emitting them so for an overloaded
+  // function we combine the type declarations from each overloaded form.
+  List *merged_types;
+
+  // List with an entry for each parameter which is passed "byref" in any
+  // overloaded form.  We use this to pass such parameters by reference in
+  // the dispatch function.  If NULL, no parameters are passed by reference.
+  List *byref;
+
+public:
+  PHPTypes() : phptypes(NewHash()), merged_types(NULL), byref(NULL) {
+    Setattr(phptypes, "array", "MAY_BE_ARRAY");
+    Setattr(phptypes, "bool", "MAY_BE_BOOL");
+    Setattr(phptypes, "callable", "MAY_BE_CALLABLE");
+    Setattr(phptypes, "float", "MAY_BE_DOUBLE");
+    Setattr(phptypes, "int", "MAY_BE_LONG");
+    Setattr(phptypes, "iterable", "MAY_BE_ITERABLE");
+    Setattr(phptypes, "mixed", "MAY_BE_MIXED");
+    Setattr(phptypes, "null", "MAY_BE_NULL");
+    Setattr(phptypes, "object", "MAY_BE_OBJECT");
+    Setattr(phptypes, "resource", "MAY_BE_RESOURCE");
+    Setattr(phptypes, "string", "MAY_BE_STRING");
+    Setattr(phptypes, "void", "MAY_BE_VOID");
+  }
+
+  void reset() {
+    Delete(merged_types);
+    merged_types = NewList();
+    Delete(byref);
+    byref = NULL;
+  }
+
+  // key is 0 for return type, or >= 1 for parameters numbered from 1
+  void process_phptype(Node *n, int key, const String_or_char *attribute_name);
+
+  String *get_phptype(int key, String *classtypes) {
+    Clear(classtypes);
+    DOH *types = Getitem(merged_types, key);
+    String *result = NewStringEmpty();
+    if (types != None) {
+      SortList(types, NULL);
+      String *prev = NULL;
+      for (Iterator i = First(types); i.item; i = Next(i)) {
+	if (prev && Equal(prev, i.item)) {
+	  // Skip duplicates when merging.
+	  continue;
+	}
+	String *c = Getattr(phptypes, i.item);
+	if (c) {
+	  if (Len(result) > 0) Append(result, "|");
+	  Append(result, c);
+	} else {
+	  if (Len(classtypes) > 0) Append(classtypes, "|");
+	  Append(classtypes, i.item);
+	}
+	prev = i.item;
+      }
+    }
+    // Make the mask 0 if there are only class names specified.
+    if (Len(result) == 0) {
+      Append(result, "0");
+    }
+    return result;
+  }
+
+  void set_byref(int key) {
+    if (!byref) {
+      byref = NewList();
+    }
+    while (Len(byref) <= key) {
+      Append(byref, None);
+    }
+    Setitem(byref, key, ""); // Just needs to be something != None.
+  }
+
+  int get_byref(int key) const {
+    return byref && key < Len(byref) && Getitem(byref, key) != None;
+  }
+};
+
 class PHP : public Language {
+  PHPTypes phptypes;
+
 public:
   PHP() {
     director_language = 1;
@@ -572,124 +660,165 @@ public:
   }
 
   /* Just need to append function names to function table to register with PHP. */
-  void create_command(String *cname, String *fname, Node *n, bool overload, String *modes = NULL) {
+  void create_command(String *cname, String *fname, Node *n, bool dispatch, String *modes = NULL) {
     // This is for the single main zend_function_entry record
-    bool has_this = false;
+    ParmList *l = Getattr(n, "parms");
     if (cname && Cmp(Getattr(n, "storage"), "friend") != 0) {
       Printf(f_h, "PHP_METHOD(%s%s,%s);\n", prefix, cname, fname);
-      has_this = (wrapperType != staticmemberfn) &&
-		 (wrapperType != staticmembervar) &&
-		 (Cmp(fname, "__construct") != 0);
+      if (wrapperType != staticmemberfn &&
+	  wrapperType != staticmembervar &&
+	  !Equal(fname, "__construct")) {
+	// Skip the first entry in the parameter list which is the this pointer.
+	l = Getattr(l, "tmap:in:next");
+	// FIXME: does this throw the phptype key value off?
+      }
     } else {
-      if (overload) {
+      if (dispatch) {
 	Printf(f_h, "ZEND_NAMED_FUNCTION(%s);\n", fname);
       } else {
 	Printf(f_h, "PHP_FUNCTION(%s);\n", fname);
       }
     }
+
+    int num_required = emit_num_required(l);
+
     // We want to only emit each different arginfo once, as that reduces the
     // size of both the generated source code and the compiled extension
     // module.  The parameters at this level are just named arg1, arg2, etc
-    // so we generate an arginfo name with the number of parameters and a
-    // bitmap value saying which (if any) are passed by reference.
-    ParmList *l = Getattr(n, "parms");
-    unsigned long bitmap = 0, bit = 1;
-    bool overflowed = false;
-    bool skip_this = has_this;
-    for (Parm *p = l; p; p = Getattr(p, "tmap:in:next")) {
-      if (skip_this) {
-	skip_this = false;
-	continue;
+    // so the arginfo will be the same for any function with the same number
+    // of parameters and (if present) PHP type declarations for parameters and
+    // return type.
+    //
+    // We generate the arginfo we want (taking care to normalise, e.g. the
+    // lists of types are unique and in sorted order), then use the
+    // arginfo_used Hash to see if we've already generated it.
+
+    // Don't add a return type declaration for a constructor (because there
+    // is no return type as far as PHP is concerned).
+    String *out_phptype = NULL;
+    String *out_phpclasses = NewStringEmpty();
+    if (!Equal(fname, "__construct")) {
+      String *php_type_flag = GetFlagAttr(n, "feature:php:type");
+      if (Equal(php_type_flag, "1") ||
+	  (php_type_flag && !Getattr(n, "directorNode"))) {
+	// We provide a simple way to generate PHP return type declarations
+	// except for directed methods.  The point of directors is to allow
+	// subclassing in the target language, and if the wrapped method has
+	// a return type declaration then an overriding method in user code
+	// needs to have a compatible declaration.
+	//
+	// The upshot of this is that enabling return type declarations for
+	// existing bindings would break compatibility with user code written
+	// for an older version.  For parameters however the situation is
+	// different because if the parent class declares types for parameters
+	// a subclass overriding the function will be compatible whether it
+	// declares them or not.
+	//
+	// directorNode being present seems to indicate if this method or one
+	// it inherits from is directed, which is what we care about here.
+	// Using (!is_member_director(n)) would get it wrong for testcase
+	// director_frob.
+	out_phptype = phptypes.get_phptype(0, out_phpclasses);
       }
+    }
+
+    // ### in arginfo_code will be replaced with the id once that is known.
+    String *arginfo_code = NewStringEmpty();
+    if (out_phptype) {
+      if (Len(out_phpclasses)) {
+	Replace(out_phpclasses, "\\", "\\\\", DOH_REPLACE_ANY);
+	Printf(arginfo_code, "ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(swig_arginfo_###, 0, %d, %s, %s)\n", num_required, out_phpclasses, out_phptype);
+      } else {
+	Printf(arginfo_code, "ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_arginfo_###, 0, %d, %s)\n", num_required, out_phptype);
+      }
+    } else {
+      Printf(arginfo_code, "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_###, 0, 0, %d)\n", num_required);
+    }
+
+    int param_count = 0;
+    for (Parm *p = l; p; p = Getattr(p, "tmap:in:next")) {
       String *tmap_in_numinputs = Getattr(p, "tmap:in:numinputs");
       // tmap:in:numinputs is unset for varargs, which we don't count here.
       if (!tmap_in_numinputs || Equal(tmap_in_numinputs, "0")) {
 	/* Ignored parameter */
 	continue;
       }
-      if (GetFlag(p, "tmap:in:byref")) {
-	  bitmap |= bit;
-	  if (bit == 0) overflowed = true;
-      }
-      bit <<= 1;
-    }
-    int num_arguments = emit_num_arguments(l);
-    int num_required = emit_num_required(l);
-    if (has_this) {
-      --num_arguments;
-      --num_required;
-    }
-    String *arginfo_code;
-    if (overflowed) {
-      // We overflowed the bitmap so just generate a unique name - this only
-      // happens for a function with more parameters than bits in a long
-      // where a high numbered parameter is passed by reference, so should be
-      // rare in practice.
-      static int overflowed_counter = 0;
-      arginfo_code = NewStringf("z%d", ++overflowed_counter);
-    } else if (bitmap == 0) {
-      // No parameters passed by reference.
-      if (num_required == num_arguments) {
-	  arginfo_code = NewStringf("%d", num_arguments);
-      } else {
-	  arginfo_code = NewStringf("%d_%d", num_required, num_arguments);
-      }
-    } else {
-      if (num_required == num_arguments) {
-	  arginfo_code = NewStringf("%d_r%lx", num_arguments, bitmap);
-      } else {
-	  arginfo_code = NewStringf("%d_%d_r%lx", num_required, num_arguments, bitmap);
-      }
-    }
 
-    if (!GetFlag(arginfo_used, arginfo_code)) {
-      // Not had this one before so emit it.
-      SetFlag(arginfo_used, arginfo_code);
-      Printf(s_arginfo, "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_%s, 0, 0, %d)\n", arginfo_code, num_required);
-      bool skip_this = has_this;
-      int param_count = 0;
-      for (Parm *p = l; p; p = Getattr(p, "tmap:in:next")) {
-	if (skip_this) {
-	  skip_this = false;
-	  continue;
-	}
-	String *tmap_in_numinputs = Getattr(p, "tmap:in:numinputs");
-	// tmap:in:numinputs is unset for varargs, which we don't count here.
-	if (!tmap_in_numinputs || Equal(tmap_in_numinputs, "0")) {
-	  /* Ignored parameter */
-	  continue;
-	}
-	Printf(s_arginfo, " ZEND_ARG_INFO(%d,arg%d)\n", GetFlag(p, "tmap:in:byref"), ++param_count);
+      ++param_count;
+
+      String *phpclasses = NewStringEmpty();
+      String *phptype = NULL;
+      if (GetFlag(n, "feature:php:type")) {
+	phptypes.get_phptype(param_count, phpclasses);
+      }
+
+      int byref;
+      if (!dispatch) {
+	byref = GetFlag(p, "tmap:in:byref");
+	if (byref) phptypes.set_byref(param_count);
+      } else {
+	// If any overload takes a particular parameter by reference then the
+	// dispatch function also needs to take that parameter by reference.
+	byref = phptypes.get_byref(param_count);
+      }
+
+      // FIXME: Should we be doing byref for return value as well?
+
+      if (phptype) {
+	if (Len(phpclasses)) {
+	  // We need to double any backslashes (which are PHP namespace
+	  // separators) in the PHP class names as they get turned into
+	  // C strings by the ZEND_ARG_OBJ_TYPE_MASK macro.
+	  Replace(phpclasses, "\\", "\\\\", DOH_REPLACE_ANY);
+	  Printf(arginfo_code, " ZEND_ARG_OBJ_TYPE_MASK(%d,arg%d,%s,%s,NULL)\n", byref, param_count, phpclasses, phptype);
+	} else {
+	  Printf(arginfo_code, " ZEND_ARG_TYPE_MASK(%d,arg%d,%s,NULL)\n", byref, param_count, phptype);
+	}
+      } else {
+	Printf(arginfo_code, " ZEND_ARG_INFO(%d,arg%d)\n", byref, param_count);
       }
-      Printf(s_arginfo, "ZEND_END_ARG_INFO()\n");
     }
+    Printf(arginfo_code, "ZEND_END_ARG_INFO()\n");
+
+    String *arginfo_id_new = Getattr(n, "sym:name");
+    String *arginfo_id = Getattr(arginfo_used, arginfo_code);
+    if (arginfo_id) {
+      Printf(s_arginfo, "#define swig_arginfo_%s swig_arginfo_%s\n", arginfo_id_new, arginfo_id);
+    } else {
+      // Not had this arginfo before.
+      Setattr(arginfo_used, arginfo_code, arginfo_id_new);
+      arginfo_code = Copy(arginfo_code);
+      Replace(arginfo_code, "###", arginfo_id_new, DOH_REPLACE_FIRST);
+      Append(s_arginfo, arginfo_code);
+    }
+    Delete(arginfo_code);
+    arginfo_code = NULL;
 
     String *s = cs_entry;
     if (!s) s = s_entry;
     if (cname && Cmp(Getattr(n, "storage"), "friend") != 0) {
-      Printf(all_cs_entry, " PHP_ME(%s%s,%s,swig_arginfo_%s,%s)\n", prefix, cname, fname, arginfo_code, modes);
+      Printf(all_cs_entry, " PHP_ME(%s%s,%s,swig_arginfo_%s,%s)\n", prefix, cname, fname, arginfo_id_new, modes);
     } else {
-      if (overload) {
+      if (dispatch) {
 	if (wrap_nonclass_global) {
-	  Printf(s, " ZEND_NAMED_FE(%(lower)s,%s,swig_arginfo_%s)\n", Getattr(n, "sym:name"), fname, arginfo_code);
+	  Printf(s, " ZEND_NAMED_FE(%(lower)s,%s,swig_arginfo_%s)\n", Getattr(n, "sym:name"), fname, arginfo_id_new);
 	}
 
 	if (wrap_nonclass_fake_class) {
 	  (void)fake_class_name();
-	  Printf(fake_cs_entry, " ZEND_NAMED_ME(%(lower)s,%s,swig_arginfo_%s,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)\n", Getattr(n, "sym:name"), fname, arginfo_code);
+	  Printf(fake_cs_entry, " ZEND_NAMED_ME(%(lower)s,%s,swig_arginfo_%s,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)\n", Getattr(n, "sym:name"), fname, arginfo_id_new);
 	}
       } else {
 	if (wrap_nonclass_global) {
-	  Printf(s, " PHP_FE(%s,swig_arginfo_%s)\n", fname, arginfo_code);
+	  Printf(s, " PHP_FE(%s,swig_arginfo_%s)\n", fname, arginfo_id_new);
 	}
 
 	if (wrap_nonclass_fake_class) {
 	  String *fake_class = fake_class_name();
-	  Printf(fake_cs_entry, " PHP_ME(%s,%s,swig_arginfo_%s,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)\n", fake_class, fname, arginfo_code);
+	  Printf(fake_cs_entry, " PHP_ME(%s,%s,swig_arginfo_%s,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)\n", fake_class, fname, arginfo_id_new);
 	}
       }
     }
-    Delete(arginfo_code);
   }
 
   /* ------------------------------------------------------------
@@ -784,27 +913,29 @@ public:
       base_class = NULL;
     }
 
-    // Ensure arginfo_1 and arginfo_2 exist.
-    if (!GetFlag(arginfo_used, "1")) {
-      SetFlag(arginfo_used, "1");
+    static bool generated_magic_arginfo = false;
+    if (!generated_magic_arginfo) {
+      // Create arginfo entries for __get, __set and __isset.
       Append(s_arginfo,
-	     "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_1, 0, 0, 1)\n"
-	     " ZEND_ARG_INFO(0,arg1)\n"
+	     "ZEND_BEGIN_ARG_INFO_EX(swig_magic_arginfo_get, 0, 0, 1)\n"
+	     " ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_STRING,NULL)\n"
 	     "ZEND_END_ARG_INFO()\n");
-    }
-    if (!GetFlag(arginfo_used, "2")) {
-      SetFlag(arginfo_used, "2");
       Append(s_arginfo,
-	     "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_2, 0, 0, 2)\n"
-	     " ZEND_ARG_INFO(0,arg1)\n"
+	     "ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_magic_arginfo_set, 0, 1, MAY_BE_VOID)\n"
+	     " ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_STRING,NULL)\n"
 	     " ZEND_ARG_INFO(0,arg2)\n"
 	     "ZEND_END_ARG_INFO()\n");
+      Append(s_arginfo,
+	     "ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(swig_magic_arginfo_isset, 0, 1, MAY_BE_BOOL)\n"
+	     " ZEND_ARG_TYPE_MASK(0,arg1,MAY_BE_STRING,NULL)\n"
+	     "ZEND_END_ARG_INFO()\n");
+      generated_magic_arginfo = true;
     }
 
     Wrapper *f = NewWrapper();
 
     Printf(f_h, "PHP_METHOD(%s%s,__set);\n", prefix, class_name);
-    Printf(all_cs_entry, " PHP_ME(%s%s,__set,swig_arginfo_2,ZEND_ACC_PUBLIC)\n", prefix, class_name);
+    Printf(all_cs_entry, " PHP_ME(%s%s,__set,swig_magic_arginfo_set,ZEND_ACC_PUBLIC)\n", prefix, class_name);
     Printf(f->code, "PHP_METHOD(%s%s,__set) {\n", prefix, class_name);
 
     Printf(f->code, "  swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS);\n");
@@ -842,7 +973,7 @@ public:
 
 
     Printf(f_h, "PHP_METHOD(%s%s,__get);\n", prefix, class_name);
-    Printf(all_cs_entry, " PHP_ME(%s%s,__get,swig_arginfo_1,ZEND_ACC_PUBLIC)\n", prefix, class_name);
+    Printf(all_cs_entry, " PHP_ME(%s%s,__get,swig_magic_arginfo_get,ZEND_ACC_PUBLIC)\n", prefix, class_name);
     Printf(f->code, "PHP_METHOD(%s%s,__get) {\n",prefix, class_name);
 
     Printf(f->code, "  swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS);\n");
@@ -875,7 +1006,7 @@ public:
 
 
     Printf(f_h, "PHP_METHOD(%s%s,__isset);\n", prefix, class_name);
-    Printf(all_cs_entry, " PHP_ME(%s%s,__isset,swig_arginfo_1,ZEND_ACC_PUBLIC)\n", prefix, class_name);
+    Printf(all_cs_entry, " PHP_ME(%s%s,__isset,swig_magic_arginfo_isset,ZEND_ACC_PUBLIC)\n", prefix, class_name);
     Printf(f->code, "PHP_METHOD(%s%s,__isset) {\n",prefix, class_name);
 
     Printf(f->code, "  swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS);\n");
@@ -994,6 +1125,12 @@ public:
 	return SWIG_ERROR;
     }
 
+    if (!Getattr(n, "sym:previousSibling")) {
+      // First function of an overloaded group or a function which isn't part
+      // of a group so reset the phptype information.
+      phptypes.reset();
+    }
+
     if (constructor) {
       wname = NewString("__construct");
     } else if (wrapperType == membervar) {
@@ -1077,10 +1214,6 @@ public:
     /* Attach standard typemaps */
 
     emit_attach_parmmaps(l, f);
-    // Not issued for overloaded functions.
-    if (!overloaded && !static_getter) {
-      create_command(class_name, wname, n, false, modes);
-    }
 
     if (wrapperType == memberfn || wrapperType == membervar) {
       // Assign "this" to arg1 and remove first entry from ParmList l.
@@ -1164,6 +1297,8 @@ public:
 	continue;
       }
 
+      phptypes.process_phptype(p, i + 1, "tmap:in:phptype");
+
       String *source = NewStringf("args[%d]", i);
       Replaceall(tm, "$input", source);
       Setattr(p, "emit:input", source);
@@ -1247,6 +1382,8 @@ public:
     }
     emit_return_variable(n, d, f);
 
+    phptypes.process_phptype(n, 0, "tmap:out:phptype");
+
     if (outarg) {
       Printv(f->code, outarg, NIL);
     }
@@ -1290,10 +1427,15 @@ public:
     Wrapper_print(f, s_wrappers);
     DelWrapper(f);
     f = NULL;
-    wname = NULL;
 
-    if (overloaded && !Getattr(n, "sym:nextSibling")) {
-      dispatchFunction(n, constructor);
+    if (overloaded) {
+      if (!Getattr(n, "sym:nextSibling")) {
+	dispatchFunction(n, constructor);
+      }
+    } else {
+      if (!static_getter) {
+	create_command(class_name, wname, n, false, modes);
+      }
     }
 
     return SWIG_OK;
@@ -2154,6 +2296,82 @@ public:
 
 static PHP *maininstance = 0;
 
+void PHPTypes::process_phptype(Node *n, int key, const String_or_char *attribute_name) {
+
+  while (Len(merged_types) <= key) {
+    Append(merged_types, NewList());
+  }
+
+  String *phptype = Getattr(n, attribute_name);
+  if (!phptype || Len(phptype) == 0) {
+    // There's no type declaration, so any merged version has no type declaration.
+    //
+    // Use a DOH None object as a marker to indicate there's no type
+    // declaration for this parameter/return value (you can't store NULL as a
+    // value in a DOH List).
+    Setitem(merged_types, key, None);
+    return;
+  }
+
+  DOH *merge_list = Getitem(merged_types, key);
+  if (merge_list == None) return;
+
+  List *types = Split(phptype, '|', -1);
+  String *first_type = Getitem(types, 0);
+  if (Char(first_type)[0] == '?') {
+    if (Len(types) > 1) {
+      Printf(stderr, "warning: Invalid phptype: '%s' (can't use ? and | together)\n", phptype);
+    }
+    // Treat `?foo` just like `foo|null`.
+    Append(types, "null");
+    Setitem(types, 0, NewString(Char(first_type) + 1));
+  }
+
+  SortList(types, NULL);
+  String *prev = NULL;
+  for (Iterator i = First(types); i.item; i = Next(i)) {
+    if (prev && Equal(prev, i.item)) {
+      Printf(stderr, "warning: Invalid phptype: '%s' (duplicate entry for '%s')\n", phptype, i.item);
+      continue;
+    }
+
+    if (key > 0 && Equal(i.item, "void")) {
+      // Reject void for parameter type.
+      Printf(stderr, "warning: Invalid phptype: '%s' ('%s' can't be used as a parameter phptype)\n", phptype, i.item);
+      continue;
+    }
+
+    if (Equal(i.item, "SWIGTYPE")) {
+      String *type = Getattr(n, "type");
+      Node *class_node = maininstance->classLookup(type);
+      if (class_node) {
+	// FIXME: Prefix classname with a backslash to prevent collisions
+	// with built-in types?  Or are non of those valid anyway and so will
+	// have been renamed at this point?
+	Append(merge_list, Getattr(class_node, "sym:name"));
+      } else {
+	// SWIG wraps a pointer to a non-object type as an object in a PHP
+	// class named based on the SWIG-mangled C/C++ type.
+	//
+	// FIXME: We should check this is actually a known pointer to
+	// non-object type so we complain about `phptype="SWIGTYPE"` being
+	// used for PHP types like `int` or `string` (currently this only
+	// fails at runtime and the error isn't very helpful).  We could
+	// check the condition
+	//
+	//   zend_types && Getattr(zend_types, SwigType_manglestr(type))
+	//
+	// except that zend_types may not have been fully filled in when
+	// we are called.
+	Append(merge_list, NewStringf("SWIG\\%s", SwigType_manglestr(type)));
+      }
+    } else {
+      Append(merge_list, i.item);
+    }
+    prev = i.item;
+  }
+}
+
 // Collect non-class pointer types from the type table so we can set up PHP
 // classes for them later.
 //