Op::*, not the parser, should construct Decls

Niecza/Actions.pm

@@ -955,7 +955,6 @@ sub package_def { my ($cl, $M) = @_;
     my $outervar = $::SCOPE eq 'my' ? $name : $cl->gensym;
 
     my $optype = 'Op::' . ucfirst($::PKGDECL) . 'Def';
-    my $decltype = 'Decl::' . ucfirst($::PKGDECL);
     my $blocktype = $::PKGDECL;
     my $bodyvar = $cl->gensym;
 
@@ -967,17 +966,16 @@ sub package_def { my ($cl, $M) = @_;
 
         my $cbody = $cl->sl_to_block($blocktype, $stmts->{_ast},
             name => $name);
-        my $cdecl = $decltype->new(
+        $M->{_ast} = $optype->new(
             name    => $name,
             var     => $outervar,
             bodyvar => $bodyvar,
             body    => $cbody);
-        $M->{_ast} = $optype->new(decl => $cdecl);
     } else {
-        $M->{_ast} = $optype->new(decl => $decltype->new(
+        $M->{_ast} = $optype->new(
             name    => $name,
             var     => $outervar,
-            stub    => 1));
+            stub    => 1);
     }
 }
 
@@ -1048,7 +1046,7 @@ sub block_to_immediate { my ($cl, $type, $blk) = @_;
 sub block_to_closure { my ($cl, $blk, %args) = @_;
     my $outer_key = $args{outer_key} // $cl->gensym;
 
-    Op::SubDef->new(decl => Decl::Sub->new(var => $outer_key, code => $blk));
+    Op::SubDef->new(var => $outer_key, body => $blk);
 }
 
 # always a sub, though sometimes it's an implied sub after multi/proto/only
@@ -1160,8 +1158,8 @@ sub statement_prefix__S_PREMinusINIT { my ($cl, $M) = @_;
 
     $M->{blast}{_ast}->type('phaser');
 
-    $M->{_ast} = Op::PreInit->new(decl => Decl::PreInit->new(var => $var,
-            code => $M->{blast}{_ast}, shared => 1));
+    $M->{_ast} = Op::PreInit->new(var => $var, body => $M->{blast}{_ast},
+        shared => 1);
 }
 
 sub statement_prefix__S_START { my ($cl, $M) = @_;

Op.pm

@@ -393,22 +393,29 @@ use CgOp;
     use Moose;
     extends 'Op';
 
-    has decl => (isa => 'Decl', is => 'ro', required => 1);
+    has name => (is => 'ro', isa => 'Str', predicate => 'has_name');
+    has var  => (is => 'ro', isa => 'Str', required => 1);
+    has bodyvar => (is => 'ro', isa => 'Str');
+    has stub => (is => 'ro', isa => 'Bool', default => 0);
+    has body => (is => 'ro', isa => 'Body');
 
     sub local_decls {
         my ($self) = @_;
-        $self->decl;
+        Decl::Class->new(stub => $self->stub, var => $self->var,
+            ($self->has_name ? (name => $self->name) : ()),
+            ($self->stub ? () : (body => $self->body,
+                    bodyvar => $self->bodyvar)));
     }
 
     sub code {
         my ($self, $body) = @_;
-        if ($self->decl->stub) {
-            CgOp::scopedlex($self->decl->var);
+        if ($self->stub) {
+            CgOp::scopedlex($self->var);
         } else {
             CgOp::prog(
                 CgOp::sink(CgOp::subcall(CgOp::fetch(
-                            CgOp::scopedlex($self->decl->bodyvar)))),
-                CgOp::scopedlex($self->decl->var));
+                            CgOp::scopedlex($self->bodyvar)))),
+                CgOp::scopedlex($self->var));
         }
     }
 
@@ -421,16 +428,19 @@ use CgOp;
     use Moose;
     extends 'Op';
 
-    has decl => (isa => 'Decl', is => 'ro', required => 1);
+    has var    => (isa => 'Str', is => 'ro', predicate => 'has_var');
+    has body   => (isa => 'Body', is => 'ro', required => 1);
+    has shared => (isa => 'Bool', is => 'ro', default => 0);
 
     sub local_decls {
         my ($self) = @_;
-        $self->decl;
+        Decl::PreInit->new(var => $self->var, code => $self->body,
+            shared => $self->shared);
     }
 
     sub code {
         my ($self, $body) = @_;
-        CgOp::scopedlex($self->decl->var);
+        CgOp::scopedlex($self->var);
     }
 
     __PACKAGE__->meta->make_immutable;
@@ -442,16 +452,17 @@ use CgOp;
     use Moose;
     extends 'Op';
 
-    has decl => (isa => 'Decl', is => 'ro', required => 1);
+    has var    => (isa => 'Str', is => 'ro', required => 1);
+    has body   => (isa => 'Body', is => 'ro', required => 1);
 
     sub local_decls {
         my ($self) = @_;
-        $self->decl;
+        Decl::Sub->new(var => $self->var, code => $self->body);
     }
 
     sub code {
         my ($self, $body) = @_;
-        CgOp::scopedlex($self->decl->var);
+        CgOp::scopedlex($self->var);
     }
 
     __PACKAGE__->meta->make_immutable;