ParseXS: make OUTPUT: SETMAGIC per-CASE

In code like:

    int
    foo(int a, int b)
        CASE: X
            OUTPUT:
                a
                SETMAGIC: DISABLE
                b
        CASE: Y
            OUTPUT:
                a
                SETMAGIC: DISABLE
                b

when the caller's two args are updated with the final values of a and b,
the first CASE calls SvSETMAGIC() after updating ST(0), but not after
updating ST(1).  This is as expected.

However in the second CASE, the current setting of SETMAGIC (i.e
disabled) from the first CASE is passed on and "inherited' by the second
CASE: so in the second branch, magic isn't called on ST(0).

This commit fixes that (i.e. calls SvSETMAGIC on ST(0) in the second
CASE) by making the current SETMAGIC state per-xbody rather than
per-xsub.

This commit achieves that by:

Remove the following field from the ExtUtils::ParseXS class:

    xsub_SETMAGIC_state

and replace it with this new field in the
ExtUtils::ParseXS::Node::xbody class:

    OUTPUT_SETMAGIC_state

and adds 4 tests (the latter two of which failed before this commit).

Author: iabyn

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

@@ -254,11 +254,6 @@ BEGIN {
                                # whether that method has been listed by
                                # OVERLOAD (for duplicate spotting).
 
-  # Per-XSUB OUTPUT section parsing state:
-
-  'xsub_SETMAGIC_state',       # Bool: most recent value of SETMAGIC in an
-                               # OUTPUT section.
-
   # Per-XSUB code-emitting state:
 
   'xsub_deferred_code_lines',  # A multi-line string containing lines of
@@ -654,11 +649,6 @@ EOM
     # Parse and code-emit an XSUB
     # ----------------------------------------------------------------
 
-    # Initialise more per-XSUB state
-
-    $self->{xsub_SETMAGIC_state} = 1;       # SETMAGIC:  ENABLE
-
-
     unshift @{$self->{line}}, $_;
     my $xsub = ExtUtils::ParseXS::Node::xsub->new();
     $self->{cur_xsub} = $xsub;

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

@@ -2238,6 +2238,9 @@ BEGIN { $build_subclass->('', # parent
 
     'seen_RETVAL_in_CODE', # Bool: have seen 'RETVAL' within a CODE block
     'seen_autocall',       # Bool: this xbody has an autocall node
+    'OUTPUT_SETMAGIC_state', # Bool: most recent value of SETMAGIC in an
+                             #       OUTPUT section.
+
 
     # State during code emitting
 
@@ -2281,6 +2284,9 @@ sub parse {
         $self->{ioparams} = $ioparams;
     }
 
+    # by default, OUTPUT entries have SETMAGIC: ENABLE
+    $self->{OUTPUT_SETMAGIC_state} = 1;
+
     for my $part (qw(input_part init_part code_part output_part cleanup_part)) {
         my $kid = "ExtUtils::ParseXS::Node::$part"->new();
         if ($kid->parse($pxs)) {
@@ -4107,12 +4113,12 @@ sub parse {
     # set some sane default values in case we do one of the early returns
     # below
 
-    $self->{do_setmagic} = $pxs->{xsub_SETMAGIC_state};
+    $self->{do_setmagic} = $pxs->{cur_xbody}{OUTPUT_SETMAGIC_state};
     $self->{is_setmagic} = 0;
 
     if ($line =~ /^\s*SETMAGIC\s*:\s*(ENABLE|DISABLE)\s*/) {
-        $pxs->{xsub_SETMAGIC_state} = ($1 eq "ENABLE" ? 1 : 0);
-        $self->{do_setmagic} = $pxs->{xsub_SETMAGIC_state};
+        $pxs->{cur_xbody}{OUTPUT_SETMAGIC_state} = ($1 eq "ENABLE" ? 1 : 0);
+        $self->{do_setmagic} = $pxs->{cur_xbody}{OUTPUT_SETMAGIC_state};
         $self->{is_setmagic} = 1;
         return;
     }
@@ -4152,7 +4158,7 @@ sub parse {
     $param->{in_output} = 1;
     $param->{do_setmagic} = $outarg eq 'RETVAL'
                                 ? 0 # RETVAL never needs magic setting
-                                : $pxs->{xsub_SETMAGIC_state};
+                                : $pxs->{cur_xbody}{OUTPUT_SETMAGIC_state};
     $self->{code} = $param->{output_code} = $outcode if length $outcode;
 
     1;

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

@@ -2560,6 +2560,44 @@ EOF
             [ 0, 0, qr/\QXSRETURN(1)/,               "has XSRETURN" ],
         ],
 
+        [
+            "OUTPUT vars with set magic mixture per-CASE",
+            [ Q(<<'EOF') ],
+                |int
+                |foo(int a, int b)
+                |   CASE: X
+                |    OUTPUT:
+                |        a
+                |        SETMAGIC: DISABLE
+                |        b
+                |   CASE: Y
+                |    OUTPUT:
+                |        a
+                |        SETMAGIC: DISABLE
+                |        b
+EOF
+            [ 0, 0, qr{\Qif (X)\E
+                       .*
+                       \QSvSETMAGIC(ST(0));\E
+                       .*
+                       \Qelse if (Y)\E
+                       }sx,                          "X: set magic ST(0)" ],
+            [ 0, 1, qr{\Qif (X)\E
+                       .*
+                       \QSvSETMAGIC(ST(1));\E
+                       .*
+                       \Qelse if (Y)\E
+                       }sx,                          "X: no magic ST(1)" ],
+            [ 0, 0, qr{\Qelse if (Y)\E
+                       .*
+                       \QSvSETMAGIC(ST(0));\E
+                       }sx,                          "Y: set magic ST(0)" ],
+            [ 0, 1, qr{\Qelse if (Y)\E
+                       .*
+                       \QSvSETMAGIC(ST(1));\E
+                       }sx,                          "Y: no magic ST(1)" ],
+        ],
+
         [
             "duplicate OUTPUT RETVAL",
             [ Q(<<'EOF') ],