ParseXS: refactor: unify sig and INPUT params

The series of approx 45 refactoring commits in this branch have added
E::P::Node::Param and E::P::Node:Sig objects, to allow an XSUB's
signature to be stored as a list of Param objects in a Sig object. So in
a straightforward XSUB like:

    int
    foo(a, b = 999)
        int a
        int b

a pair of Param objects is created and stored in a Sig object to
represent the two items in the signature, e.g.

    { var => 'a', arg_num => 1 },
    { var => 'b', arg_num => 2, default => 999 },

But up until now, when the lines in the implicit INPUT section were
subsequently parsed, a *second* pair of temporary Param objects were
created using both data obtained from the Sig objects and from the INPUT
line. The as_code() method was then called on each temp Param object,
and the temp object was then thrown away.

This commit changes it so that instead, any extra info obtained from an
INPUT line is added to the original Param object in the Sig object,
(e.g. the 'type' value) and the as_code() method is called on the
*original* object. No temporary Param objects are created.

This commit is effectively what the previous chain of commits have been
preparing for. Before that, all info obtained from the signature was
stored in a series of hash refs stored in the ExtUtils::ParseXS object,
such as

    $self->{sub_map_argname_to_default}{b} = 999;

The new way is cleaner, conceptually simpler, gathers related code and
data into one location, and has fewer special cases that need handling.

The main thing it doesn't do yet is defer code generation. It still
emits a C var declaration directly after each INPUT line is read and
parsed. Eventually I would like for the whole signature/INPUT sequence
to be read in and parsed and *then* emit all the code one go (and in the
long term, to read in the *whole* XS file before emitting any code).

One intended side effect of this commit is that it now detects duplicate
'alien' parameters again - this was broken during the earlier
refactoring. An alien param is one declared in INPUT but not in the
signature:

    int
    foo(a)
        int a   # normal parameter
        int b   # alien parameter
        int b   # duplicate alien parameter

A test has been added for this.

A test has also been added for looking up the prototype char associated
with a type when the type can change, as with a synthetic parameter like
THIS.

Author: iabyn

dist/ExtUtils-ParseXS/lib/ExtUtils/ParseXS.pm

@@ -2363,9 +2363,11 @@ sub INPUT_handler {
     $self->{xsub_seen_RETVAL_in_INPUT} |= $var_name eq "RETVAL";
 
     my ($var_num, $is_alien);
-    my $sig_param = $self->{xsub_sig}{names}{$var_name};
 
-    if (defined $sig_param) {
+    my ExtUtils::ParseXS::Node::Param $param
+          = $self->{xsub_sig}{names}{$var_name};
+
+    if (defined $param) {
       # The var appeared in the signature too.
 
       # Check for duplicate definitions of a particular parameter name.
@@ -2374,21 +2376,28 @@ sub INPUT_handler {
       # and thus shouldn't be defined again. The exception to this are
       # synthetic params like THIS, which are assigned a provisional type
       # which can be overridden.
-      if (   $sig_param->{in_input}
-          or (!$sig_param->{is_synthetic} and exists $sig_param->{type})
+      if (   $param->{in_input}
+          or (!$param->{is_synthetic} and exists $param->{type})
       ) {
           $self->blurt(
             "Error: duplicate definition of argument '$var_name' ignored");
           next;
       }
-      $sig_param->{in_input} = 1;
-      $var_num = $sig_param->{arg_num};
+      $param->{in_input} = 1;
+      $var_num = $param->{arg_num};
     }
     else {
       # The var is in an INPUT line, but not in signature. Treat it as a
       # general var declaration (which really should have been in a
       # PREINIT section). Legal but nasty: flag is as 'alien'
       $is_alien = 1;
+      $param = ExtUtils::ParseXS::Node::Param->new({
+                  var      => $var_name,
+                  is_alien => 1,
+               });
+
+      push @{$self->{xsub_sig}{params}}, $param;
+      $self->{xsub_sig}{names}{$var_name} = $param;
     }
 
     # Parse the initialisation part of the INPUT line (if any)
@@ -2442,8 +2451,16 @@ sub INPUT_handler {
       $no_init = 1;
     }
 
-  my ExtUtils::ParseXS::Node::Param $param =
-     ExtUtils::ParseXS::Node::Param->new({
+    if (    defined $param->{in_out}
+        and  $param->{in_out} =~ /^OUT/
+        and !defined $init_op
+    ) {
+        # OUT* class: skip initialisation
+        $no_init = 1;
+    }
+
+    %$param = (
+      %$param,
       type    => $var_type,
       arg_num => $var_num,
       var     => $var_name,
@@ -2452,8 +2469,7 @@ sub INPUT_handler {
       init_op => $init_op,
       no_init => $no_init,
       is_addr => !!$var_addr,
-      is_alien=> $is_alien,
-    });
+    );
 
     $param->check($self)
       or next;
@@ -2464,7 +2480,7 @@ sub INPUT_handler {
     # Synthetic params like THIS will be emitted later - they
     # are treated like ANSI params, except the type can overridden
     # within an INPUT statement
-    next if $sig_param->{is_synthetic};
+    next if $param->{is_synthetic};
 
     $param->as_code($self);
 

dist/ExtUtils-ParseXS/lib/ExtUtils/ParseXS/Node.pm

@@ -115,8 +115,7 @@ BEGIN {
 
 
 # check(): for a parsed INPUT line and/or typed parameter in a signature,
-# update some global state and do some checks (e.g. "duplicate argument"
-# error).
+# update some global state and do some checks
 #
 # Return true if checks pass.
 
@@ -128,35 +127,16 @@ sub check {
 
     # Get the overridden prototype character, if any, associated with the
     # typemap entry for this var's type.
+    # Note that something with a provisional type such as THIS can get
+    # the type changed later. It is important to update each time.
+    # It also can't be looked up only at BOOT code emitting time, because
+    # potentiall, the typmap may been bee updated last in the XS file
+    # after the XSUB was parsed.
     if ($self->{arg_num}) {
         my $typemap = $pxs->{typemaps_object}->get_typemap(ctype => $type);
         my $p = $typemap && $typemap->proto;
         $self->{proto} = $p if defined $p && length $p;
     }
-
-    # XXX tmp workaround during code refactoring
-    # Copy any relevant fields from the param object (if any) for the
-    # param of the same name declared in the signature, to the INPUT param
-    # object.
-    my ExtUtils::ParseXS::Node::Param $sigp =
-        $pxs->{xsub_sig}{names}{$self->{var}};
-
-    if ($sigp) {
-        for (qw(default)) {
-            $self->{$_} = $sigp->{$_} if exists $sigp->{$_};
-        }
-        if (    defined $sigp->{in_out}
-            and  $sigp->{in_out} =~ /^OUT/
-            and !defined($self->{init_op})
-        ) {
-            # OUT* class: skip initialisation
-            $self->{no_init} = 1;
-        }
-        # XXX also tmp copy some stuff back to the sig param
-        for(qw(is_addr in_out proto type)) {
-            $sigp->{$_} = $self->{$_} if exists $self->{$_};
-        }
-    }
 
     return 1;
 }

dist/ExtUtils-ParseXS/t/001-basic.t

@@ -1,7 +1,7 @@
 #!/usr/bin/perl
 
 use strict;
-use Test::More tests => 179;
+use Test::More tests => 182;
 use Config;
 use DynaLoader;
 use ExtUtils::CBuilder;
@@ -883,14 +883,16 @@ EOF
         |    int b;
         |    int b;
         |    int c;
+        |    int alien;
+        |    int alien;
 EOF
 
     tie *FH, 'Capture';
     my $stderr = PrimitiveCapture::capture_stderr(sub {
         $pxs->process_file( filename => \$text, output => \*FH);
     });
 
-    for my $var (qw(a b c)) {
+    for my $var (qw(a b c alien)) {
         my $count = () =
             $stderr =~ /duplicate definition of argument '$var'/g;
         is($count, 1, "One dup error for \"$var\"");
@@ -1481,6 +1483,9 @@ EOF
         |X::Y *        T_OBJECT
         |const X::Y *  T_OBJECT \&
         |
+        |P::Q *        T_OBJECT @
+        |const P::Q *  T_OBJECT %
+        |
         |INPUT
         |T_OBJECT
         |    $var = my_in($arg);
@@ -1555,6 +1560,16 @@ EOF
             [ 0, 0, qr/"\$\$\$\$;\$\@"/, "" ],
         ],
 
+        [
+            "auto-generated proto with overridden THIS type",
+            [
+                'void',
+                'P::Q::foo()',
+                '    const P::Q * THIS'
+            ],
+            [ 0, 0, qr/"%"/, "" ],
+        ],
+
         [
             "explicit prototype",
             [