diff --git a/src/Perl6/Actions.nqp b/src/Perl6/Actions.nqp
index faf5140c90a..27b25b7fcb0 100644
--- a/src/Perl6/Actions.nqp
+++ b/src/Perl6/Actions.nqp
@@ -1073,6 +1073,10 @@ role STDActions {
 }
 
 class Perl6::Actions is HLL::Actions does STDActions {
+    #================================================================
+    # AMBIENT AND POD-COMMON CODE HANDLERS
+    #================================================================
+
     our @MAX_PERL_VERSION;
 
     # Could add to this based on signatures.
@@ -1441,443 +1445,180 @@ class Perl6::Actions is HLL::Actions does STDActions {
         }
     }
 
-    method pod_content_toplevel($/) {
-        my $child := $<pod_block>.ast;
-        # make sure we don't push the same thing twice
-        if $child {
-            my $id := $/.from ~ "," ~ ~$/.to;
-            if !$*POD_BLOCKS_SEEN{$id} {
-                $*POD_BLOCKS.push($child);
-                $*POD_BLOCKS_SEEN{$id} := 1;
-            }
-        }
-        make $child;
-    }
-
-    method pod_content:sym<block>($/) {
-        make $<pod_block>.ast;
-    }
-
-    # TODO The spaces arg from Grammar.nqp seems
-    #      NOT to be handled. That shows up
-    #      in testing for config continuation lines.
-    method pod_configuration($/) {
-        make Perl6::Pod::make_config($/);
+    method unitstart($/) {
+        # Use SET_BLOCK_OUTER_CTX (inherited from HLL::Actions)
+        # to set dynamic outer lexical context and namespace details
+        # for the compilation unit.
+        self.SET_BLOCK_OUTER_CTX($*UNIT_OUTER);
     }
 
-    method pod_block:sym<delimited>($/) {
-        if $<type>.Str ~~ /^defn/ {
-            make Perl6::Pod::defn($/, $delim-block);
+    method statementlist($/) {
+        my $past := QAST::Stmts.new( :node($/) );
+        if $<statement> {
+            my int $i := 0;
+            my int $e := nqp::elems($<statement>) - 1;
+            while $i <= $e {
+                my $ast := $<statement>[$i].ast;
+                if $ast {
+                    if $ast.ann('statement_level') && $*statement_level {
+                        $ast.ann('statement_level')();
+                    }
+                    if $ast.ann('sink_ast') {
+                        $ast := QAST::Want.new($ast, 'v', $ast.ann('sink_ast'));
+                        $ast := UNWANTED($ast, 'statementlist/sink_ast') if $i < $e;
+                    }
+                    elsif $ast.ann('bare_block') {
+                        if $i < $e {
+                            $ast := UNWANTED(autosink($ast.ann('bare_block')), "statementlist/bare_block");
+                        }
+                        elsif $*ESCAPEBLOCK {
+                            $ast := WANTED($ast.ann('bare_block'),'statementlist/escape');
+                        }
+                        else {
+                            $ast := autosink($ast.ann('bare_block'));
+                        }
+                    }
+                    else {
+                        if nqp::istype($ast,QAST::Op) && ($ast.op eq 'while' || $ast.op eq 'until' || $ast.op eq 'repeat_while' || $ast.op eq 'repeat_until') {
+                            $ast := UNWANTED($ast,'statementlist/loop');   # statement level loops never want return value
+                        }
+                        elsif $i == $e && $*ESCAPEBLOCK {
+                            $ast := QAST::Stmt.new(autosink(WANTED($ast,'statementlist/else')), :returns($ast.returns));
+                        }
+                        else {
+                            $ast := QAST::Stmt.new(autosink($ast), :returns($ast.returns));
+                        }
+                    }
+                    $ast.node($<statement>[$i]);
+                    $past.push( $ast );
+                }
+                ++$i;
+            }
         }
-        else {
-            make Perl6::Pod::any_block($/, $delim-block);
+        if +$past.list < 1 {
+            $past.push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
         }
-    }
-
-    method pod_block:sym<delimited_comment>($/) {
-        make Perl6::Pod::raw_block($/);
-    }
-
-    method pod_block:sym<delimited_table>($/) {
-        make Perl6::Pod::table($/, $delim-block);
-    }
-
-    method pod_block:sym<delimited_code>($/) {
-        # TODO add numbered-alias handling
-        my $config   := $<pod_configuration>.ast;
-        my @contents := $<delimited_code_content>.ast;
-        @contents    := Perl6::Pod::serialize_array(@contents).compile_time_value;
-        make Perl6::Pod::serialize_object('Pod::Block::Code',
-                                          :@contents,:$config).compile_time_value
-    }
-
-    method delimited_code_content($/) {
-        my @contents := [];
-        for $/[0] {
-            if $_<pod_string> {
-                nqp::splice(@contents,
-                            Perl6::Pod::pod_strings_from_matches($_<pod_string>),
-                            +@contents, 0);
-                nqp::push(@contents, $*W.add_constant(
-                    'Str', 'str', ~$_<pod_newline>
-                ).compile_time_value);
-            } else {
-                @contents.push($*W.add_constant('Str', 'str', "\n").compile_time_value);
+        else {
+            my $pl := $past[+@($past) - 1];
+            if $pl.sunk {
+                $past.push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
+            }
+            else {
+                $pl.final(1);
+                $past.returns($pl.returns);
             }
         }
-        make @contents;
+        make $past;
     }
 
-    method pod_block:sym<paragraph>($/) {
-        if $<type>.Str ~~ /^defn/ {
-            make Perl6::Pod::defn($/, $para-block);
+    # Produces a LoL from a semicolon list
+    method semilist($/) {
+        if $<statement> {
+            my $past := QAST::Stmts.new( :node($/) );
+            if $<statement> > 1 {
+                my $l := QAST::Op.new( :name('&infix:<,>'), :op('call') );
+                for $<statement> {
+                    my $sast := $_.ast || QAST::WVal.new( :value($*W.find_symbol(['Nil'])) );
+                    $l.push(wanted($sast, 'semilist'));
+                }
+                $past.push($l);
+                $past.annotate('multislice', 1);
+            }
+            else {
+                $past.push($<statement>[0].ast || QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
+            }
+            make $past;
         }
         else {
-            make Perl6::Pod::any_block($/, $para-block);
+            make QAST::Op.new( :op('call'), :name('&infix:<,>') );
         }
     }
 
-    method pod_block:sym<paragraph_comment>($/) {
-        make Perl6::Pod::raw_block($/);
-    }
-
-    method pod_block:sym<paragraph_table>($/) {
-        make Perl6::Pod::table($/, $para-block);
-    }
-
-    method pod_block:sym<paragraph_code>($/) {
-        # TODO make config via call to make_config in Pod.nqp
-        my $config := $<pod_configuration>.ast;
-        my @contents := [];
-        for $<pod_line> {
-            nqp::splice(@contents, $_.ast, +@contents, 0);
+    method sequence($/) {
+        my $past := QAST::Stmts.new( :node($/) );
+        if $<statement> {
+            for $<statement> { $past.push($_.ast) if $_.ast; }
         }
-        @contents  := Perl6::Pod::serialize_array(@contents).compile_time_value;
-        make Perl6::Pod::serialize_object('Pod::Block::Code',
-                                          :@contents,:$config).compile_time_value;
+        unless +@($past) {
+            $past.push( QAST::Op.new( :op('call'), :name('&infix:<,>') ) );
+        }
+        make $past;
     }
 
-    method pod_block:sym<abbreviated>($/) {
-        if $<type>.Str ~~ /^defn/ {
-            make Perl6::Pod::defn($/, $abbrev-block);
-        }
-        else {
-            make Perl6::Pod::any_block($/, $abbrev-block);
+    method statement($/) {
+        my $past;
+        if $<EXPR> {
+            my $mc := $<statement_mod_cond>;
+            my $ml := $<statement_mod_loop>;
+            $past := $<EXPR>.ast;
+            if $mc {
+                if ~$mc<sym> eq 'with' {
+                    make thunkity_thunk($/,'.b',QAST::Op.new( :op('call'), :name('&infix:<andthen>')),[$mc,$<EXPR>]);
+                    return;
+                }
+                elsif ~$mc<sym> eq 'without' {
+                    make thunkity_thunk($/,'.b',QAST::Op.new( :op('call'), :name('&infix:<notandthen>')),[$mc,$<EXPR>]);
+                    return;
+                }
+                my $mc_ast := $mc.ast;
+                if $past.ann('bare_block') {
+                    my $cond_block := $past.ann('past_block');
+                    remove_block($*W.cur_lexpad(), $cond_block);
+                    $cond_block.blocktype('immediate');
+                    $past := $cond_block;
+                }
+                $mc_ast.push($past);
+                $mc_ast.push(QAST::WVal.new( :value($*W.find_symbol(['Empty'])) ));
+                $past := $mc_ast;
+            }
+            if $ml {
+                $past.okifnil(1);
+                $past[0].okifnil(1) if +@($past);
+                my $cond := $ml<smexpr>.ast;
+                if ~$ml<sym> eq 'given' {
+                    unless $past.ann('bare_block') {
+                        $past := make_topic_block_ref($/, $past, migrate_stmt_id => $*STATEMENT_ID);
+                    }
+                    $past := QAST::Op.new( :op('call'), block_closure($past), $cond );
+                }
+                elsif ~$ml<sym> eq 'for' {
+                    unless $past.ann('past_block') {
+                        $past := make_topic_block_ref($/, $past, migrate_stmt_id => $*STATEMENT_ID);
+                    }
+                    my $fornode := QAST::Op.new(
+                            :op<p6for>, :node($/),
+                            $cond,
+                            block_closure($past),
+                        );
+                    $past := QAST::Want.new(
+                        $fornode,
+                        'v', QAST::Op.new(:op<p6sink>, $fornode),
+                    );
+                    $past[2].sunk(1);
+                    my $sinkee := $past[0];
+                    $past.annotate('statement_level', -> {
+                        UNWANTED($sinkee, 'force for mod');
+                        $fornode.op('p6forstmt') if can-use-p6forstmt($fornode[1]);
+                        $fornode.annotate('IterationEnd', $*W.find_symbol(['IterationEnd']));
+                        $fornode.annotate('Nil', $*W.find_symbol(['Nil']));
+                    });
+                }
+                else {
+                    $past := QAST::Op.new($cond, $past, :op(~$ml<sym>), :node($/) );
+                }
+            }
         }
-    }
+        elsif $<statement> { $past := $<statement>.ast; }
+        elsif $<statement_control> { $past := $<statement_control>.ast; }
+        else { $past := 0; }
 
-    method pod_block:sym<abbreviated_comment>($/) {
-        make Perl6::Pod::raw_block($/);
-    }
+        if $past {
+            my $id := $*STATEMENT_ID;
+            $past.annotate('statement_id', $id);
 
-    method pod_block:sym<abbreviated_table>($/) {
-        make Perl6::Pod::table($/, $abbrev-block);
-    }
-
-    method pod_block:sym<abbreviated_code>($/) {
-        my @contents := [];
-        for $<pod_line> {
-            nqp::splice(@contents, $_.ast, +@contents, 0);
-        }
-        @contents := Perl6::Pod::serialize_array(@contents).compile_time_value;
-        make Perl6::Pod::serialize_object(
-            'Pod::Block::Code', :@contents
-        ).compile_time_value
-    }
-
-    method pod_line ($/) {
-        my @contents := Perl6::Pod::pod_strings_from_matches($<pod_string>);
-        @contents.push($*W.add_constant(
-            'Str', 'str', ~$<pod_newline>
-        ).compile_time_value);
-        make @contents;
-    }
-
-    method pod_block:sym<finish>($/) {
-        $*W.install_lexical_symbol(
-          $*UNIT,'$=finish', nqp::hllizefor(~$<finish>, 'perl6'));
-    }
-
-    method pod_content:sym<config>($/) {
-        make Perl6::Pod::config($/);
-    }
-
-    method pod_content:sym<text>($/) {
-        my @ret := [];
-        for $<pod_textcontent> {
-            @ret.push($_.ast);
-        }
-        my $past := Perl6::Pod::serialize_array(@ret);
-        make $past.compile_time_value;
-    }
-
-    method pod_textcontent:sym<regular>($/) {
-        my @contents := Perl6::Pod::pod_strings_from_matches($<pod_string>);
-        @contents    := Perl6::Pod::serialize_array(@contents).compile_time_value;
-        make Perl6::Pod::serialize_object('Pod::Block::Para', :@contents).compile_time_value
-    }
-
-    method pod_textcontent:sym<code>($/) {
-        my $s := $<spaces>.Str;
-        my $t := subst($<text>.Str, /\n$s/, "\n", :global);
-        $t    := subst($t, /\n$/, ''); # chomp!
-        my $past := Perl6::Pod::serialize_object(
-            'Pod::Block::Code',
-            :contents(Perl6::Pod::serialize_aos([$t]).compile_time_value),
-        );
-        make $past.compile_time_value;
-    }
-
-    method pod_formatting_code($/) {
-        if $<code> eq 'V' {
-            make ~$<contents>;
-        } elsif $<code> eq 'E' {
-            my @contents := [];
-            my @meta    := [];
-            for $/[0] {
-                if $_<html_ref> {
-                    @contents.push(~$_);
-                    @meta.push($*W.add_string_constant(~$_).compile_time_value);
-                    #my $s := Perl6::Pod::str_from_entity(~$_);
-                    #$s ?? @contents.push($s) && @meta.push(~$_)
-                    #   !! $/.worry("\"$_\" is not a valid HTML5 entity.");
-                } else {
-                    my $n := $_<integer>
-                          ?? $_<integer>.made
-                          !! nqp::codepointfromname(~$_);
-                    if $n >= 0 {
-                        @contents.push(nqp::chr($n));
-                        @meta.push($n);
-                    } else {
-                        $/.worry("\"$_\" is not a valid Unicode character name or code point.");
-                    }
-                }
-            }
-            @contents := Perl6::Pod::serialize_aos(@contents).compile_time_value;
-            @meta    := Perl6::Pod::serialize_array(@meta).compile_time_value;
-            make Perl6::Pod::serialize_object(
-                'Pod::FormattingCode',
-                :type($*W.add_string_constant(~$<code>).compile_time_value),
-                :@contents,
-                :@meta,
-            ).compile_time_value;
-        } else {
-            my @chars := Perl6::Pod::build_pod_chars($<pod_string_character>);
-            my @meta := [];
-            if $<code> eq 'X' {
-                for $/[0] {
-                    my @tmp := [];
-                    for $_<meta> {
-                        @tmp.push(~$_);
-                    }
-                    @meta.push(@tmp);
-                }
-                @meta := Perl6::Pod::serialize_aoaos(@meta).compile_time_value;
-            } else {
-                for $<meta> {
-                    @meta.push(~$_)
-                }
-                @meta := Perl6::Pod::serialize_aos(@meta).compile_time_value;
-            }
-            my @contents  := Perl6::Pod::build_pod_strings([@chars]);
-            @contents := Perl6::Pod::serialize_array(@contents).compile_time_value;
-            my $past := Perl6::Pod::serialize_object(
-                'Pod::FormattingCode',
-                :type($*W.add_string_constant(~$<code>).compile_time_value),
-                :@contents,
-                :meta(@meta),
-            );
-            make $past.compile_time_value;
-        }
-    }
-
-    method pod_string($/) {
-        make Perl6::Pod::build_pod_chars($<pod_string_character>);
-    }
-
-    method pod_balanced_braces($/) {
-        if $<endtag> {
-            my @chars := Perl6::Pod::build_pod_chars($<pod_string_character>);
-            @chars.unshift(~$<start>);
-            @chars.push(~$<endtag>);
-            make @chars;
-        } else {
-            make ~$<braces>
-        }
-    }
-
-    method pod_string_character($/) {
-        if $<pod_formatting_code> {
-            make $<pod_formatting_code>.ast
-        } elsif $<pod_balanced_braces> {
-            make $<pod_balanced_braces>.ast
-        } else {
-            make ~$<char>;
-        }
-    }
-
-    method table_row($/) {
-        make ~$/
-    }
-
-    method table_row_or_blank($/) {
-        make ~$/
-    }
-
-    method unitstart($/) {
-        # Use SET_BLOCK_OUTER_CTX (inherited from HLL::Actions)
-        # to set dynamic outer lexical context and namespace details
-        # for the compilation unit.
-        self.SET_BLOCK_OUTER_CTX($*UNIT_OUTER);
-    }
-
-    method statementlist($/) {
-        my $past := QAST::Stmts.new( :node($/) );
-        if $<statement> {
-            my int $i := 0;
-            my int $e := nqp::elems($<statement>) - 1;
-            while $i <= $e {
-                my $ast := $<statement>[$i].ast;
-                if $ast {
-                    if $ast.ann('statement_level') && $*statement_level {
-                        $ast.ann('statement_level')();
-                    }
-                    if $ast.ann('sink_ast') {
-                        $ast := QAST::Want.new($ast, 'v', $ast.ann('sink_ast'));
-                        $ast := UNWANTED($ast, 'statementlist/sink_ast') if $i < $e;
-                    }
-                    elsif $ast.ann('bare_block') {
-                        if $i < $e {
-                            $ast := UNWANTED(autosink($ast.ann('bare_block')), "statementlist/bare_block");
-                        }
-                        elsif $*ESCAPEBLOCK {
-                            $ast := WANTED($ast.ann('bare_block'),'statementlist/escape');
-                        }
-                        else {
-                            $ast := autosink($ast.ann('bare_block'));
-                        }
-                    }
-                    else {
-                        if nqp::istype($ast,QAST::Op) && ($ast.op eq 'while' || $ast.op eq 'until' || $ast.op eq 'repeat_while' || $ast.op eq 'repeat_until') {
-                            $ast := UNWANTED($ast,'statementlist/loop');   # statement level loops never want return value
-                        }
-                        elsif $i == $e && $*ESCAPEBLOCK {
-                            $ast := QAST::Stmt.new(autosink(WANTED($ast,'statementlist/else')), :returns($ast.returns));
-                        }
-                        else {
-                            $ast := QAST::Stmt.new(autosink($ast), :returns($ast.returns));
-                        }
-                    }
-                    $ast.node($<statement>[$i]);
-                    $past.push( $ast );
-                }
-                ++$i;
-            }
-        }
-        if +$past.list < 1 {
-            $past.push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
-        }
-        else {
-            my $pl := $past[+@($past) - 1];
-            if $pl.sunk {
-                $past.push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
-            }
-            else {
-                $pl.final(1);
-                $past.returns($pl.returns);
-            }
-        }
-        make $past;
-    }
-
-    # Produces a LoL from a semicolon list
-    method semilist($/) {
-        if $<statement> {
-            my $past := QAST::Stmts.new( :node($/) );
-            if $<statement> > 1 {
-                my $l := QAST::Op.new( :name('&infix:<,>'), :op('call') );
-                for $<statement> {
-                    my $sast := $_.ast || QAST::WVal.new( :value($*W.find_symbol(['Nil'])) );
-                    $l.push(wanted($sast, 'semilist'));
-                }
-                $past.push($l);
-                $past.annotate('multislice', 1);
-            }
-            else {
-                $past.push($<statement>[0].ast || QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
-            }
-            make $past;
-        }
-        else {
-            make QAST::Op.new( :op('call'), :name('&infix:<,>') );
-        }
-    }
-
-    method sequence($/) {
-        my $past := QAST::Stmts.new( :node($/) );
-        if $<statement> {
-            for $<statement> { $past.push($_.ast) if $_.ast; }
-        }
-        unless +@($past) {
-            $past.push( QAST::Op.new( :op('call'), :name('&infix:<,>') ) );
-        }
-        make $past;
-    }
-
-    method statement($/) {
-        my $past;
-        if $<EXPR> {
-            my $mc := $<statement_mod_cond>;
-            my $ml := $<statement_mod_loop>;
-            $past := $<EXPR>.ast;
-            if $mc {
-                if ~$mc<sym> eq 'with' {
-                    make thunkity_thunk($/,'.b',QAST::Op.new( :op('call'), :name('&infix:<andthen>')),[$mc,$<EXPR>]);
-                    return;
-                }
-                elsif ~$mc<sym> eq 'without' {
-                    make thunkity_thunk($/,'.b',QAST::Op.new( :op('call'), :name('&infix:<notandthen>')),[$mc,$<EXPR>]);
-                    return;
-                }
-                my $mc_ast := $mc.ast;
-                if $past.ann('bare_block') {
-                    my $cond_block := $past.ann('past_block');
-                    remove_block($*W.cur_lexpad(), $cond_block);
-                    $cond_block.blocktype('immediate');
-                    $past := $cond_block;
-                }
-                $mc_ast.push($past);
-                $mc_ast.push(QAST::WVal.new( :value($*W.find_symbol(['Empty'])) ));
-                $past := $mc_ast;
-            }
-            if $ml {
-                $past.okifnil(1);
-                $past[0].okifnil(1) if +@($past);
-                my $cond := $ml<smexpr>.ast;
-                if ~$ml<sym> eq 'given' {
-                    unless $past.ann('bare_block') {
-                        $past := make_topic_block_ref($/, $past, migrate_stmt_id => $*STATEMENT_ID);
-                    }
-                    $past := QAST::Op.new( :op('call'), block_closure($past), $cond );
-                }
-                elsif ~$ml<sym> eq 'for' {
-                    unless $past.ann('past_block') {
-                        $past := make_topic_block_ref($/, $past, migrate_stmt_id => $*STATEMENT_ID);
-                    }
-                    my $fornode := QAST::Op.new(
-                            :op<p6for>, :node($/),
-                            $cond,
-                            block_closure($past),
-                        );
-                    $past := QAST::Want.new(
-                        $fornode,
-                        'v', QAST::Op.new(:op<p6sink>, $fornode),
-                    );
-                    $past[2].sunk(1);
-                    my $sinkee := $past[0];
-                    $past.annotate('statement_level', -> {
-                        UNWANTED($sinkee, 'force for mod');
-                        $fornode.op('p6forstmt') if can-use-p6forstmt($fornode[1]);
-                        $fornode.annotate('IterationEnd', $*W.find_symbol(['IterationEnd']));
-                        $fornode.annotate('Nil', $*W.find_symbol(['Nil']));
-                    });
-                }
-                else {
-                    $past := QAST::Op.new($cond, $past, :op(~$ml<sym>), :node($/) );
-                }
-            }
-        }
-        elsif $<statement> { $past := $<statement>.ast; }
-        elsif $<statement_control> { $past := $<statement_control>.ast; }
-        else { $past := 0; }
-
-        if $past {
-            my $id := $*STATEMENT_ID;
-            $past.annotate('statement_id', $id);
-
-            # only trace when running in source
-            if $/.pragma('trace') && !$*W.is_precompilation_mode {
-                my $code := ~$/;
+            # only trace when running in source
+            if $/.pragma('trace') && !$*W.is_precompilation_mode {
+                my $code := ~$/;
 
                 # don't bother putting ops for activating it
                 if $code eq 'use trace' {
@@ -10244,130 +9985,404 @@ class Perl6::Actions is HLL::Actions does STDActions {
             $i++;
         }
 
-        # go through any remaining children and just migrate QAST::Blocks
-        my $qels := nqp::elems($qast);
-        while $i < $qels {
-            find_block_calls_and_migrate($cur_lexpad, $curry, $qast[$i]);
-            $i++;
+        # go through any remaining children and just migrate QAST::Blocks
+        my $qels := nqp::elems($qast);
+        while $i < $qels {
+            find_block_calls_and_migrate($cur_lexpad, $curry, $qast[$i]);
+            $i++;
+        }
+
+        # Bake the signature for our curry
+        my %sig_info := hash(parameters => @params);
+        my $signature := $*W.create_signature_and_params:
+            $/, %sig_info, $curry, 'Mu';
+        add_signature_binding_code($curry, $signature, @params);
+
+        fatalize($curry[1]) if $*FATAL;
+
+        # Create a code object for our curry
+        my $code := $*W.create_code_object: $curry, 'WhateverCode', $signature;
+        $qast := block_closure(reference_to_code_object($code, $curry));
+        $qast.returns: $WhateverCode;
+        $qast.arity: nqp::elems(@params);
+
+        # Hyperspace!
+        $qast := QAST::Op.new: :op<call>, :name<&HYPERWHATEVER>, $qast
+            if $hyperwhatever;
+        $qast;
+    }
+
+    sub find_block_calls_and_migrate($from, $to, $qast) {
+        if nqp::can($qast, 'ann') && $qast.ann('past_block') -> $block {
+            $to[0].push: $block;
+            remove_block($from, $block, :ignore-not-found);
+        }
+        elsif nqp::istype($qast, QAST::Node) {
+            for @($qast) {
+                find_block_calls_and_migrate($from, $to, $_);
+            }
+        }
+    }
+
+    sub remove_block($from, $block, :$ignore-not-found) {
+        # Remove the QAST::Block $block from $from[0]; die if not found.
+        my @decls := $from[0].list;
+        my int $i := 0;
+        my int $n := nqp::elems(@decls);
+        while $i < $n {
+            my $consider := @decls[$i];
+            if $consider =:= $block {
+                @decls[$i] := QAST::Op.new( :op('null') );
+                return 1;
+            }
+            elsif nqp::istype($consider, QAST::Stmt) || nqp::istype($consider, QAST::Stmts) {
+                if $consider[0] =:= $block {
+                    $consider[0] := QAST::Op.new( :op('null') );
+                    return 1;
+                }
+            }
+            $i++;
+        }
+        nqp::die('Internal error: failed to remove block')
+            unless $ignore-not-found;
+    }
+
+    sub wrap_return_type_check($wrappee, $code_obj) {
+        my $ret := %*SIG_INFO<returns>;
+        return $wrappee if nqp::isconcrete($ret) || $ret.HOW.name($ret) eq 'Nil';
+        QAST::Op.new(
+            :op('p6typecheckrv'),
+            $wrappee,
+            QAST::WVal.new( :value($code_obj) ),
+            QAST::WVal.new( :value($*W.find_symbol(['Nil'])) )
+        );
+    }
+
+    sub wrap_return_handler($past) {
+        wrap_return_type_check(
+            QAST::Op.new(
+                :op<handlepayload>,
+                # If we fall off the bottom, decontainerize if
+                # rw not set.
+                QAST::Op.new( :op('p6decontrv'), QAST::WVal.new( :value($*DECLARAND) ), $past ),
+                'RETURN',
+                QAST::Op.new( :op<lastexpayload> )
+            ),
+            $*DECLARAND
+        )
+    }
+
+    # Works out how to look up a type. If it's not generic and is in an SC, we
+    # statically resolve it. Otherwise, we punt to a runtime lexical lookup.
+    sub instantiated_type(@name, $/) {
+        CATCH {
+            $*W.throw($/, ['X', 'NoSuchSymbol'], symbol => join('::', @name));
+        }
+        my $type := $*W.find_symbol(@name);
+        my $is_generic := 0;
+        try { $is_generic := $type.HOW.archetypes.generic }
+        my $past;
+        if $is_generic || nqp::isnull(nqp::getobjsc($type)) || istype($type.HOW,$/.how('package')) {
+            $past := $*W.symbol_lookup(@name, $/);
+            $past.set_compile_time_value($type);
+        }
+        else {
+            $past := QAST::WVal.new( :value($type) );
+        }
+        $past.returns($type.WHAT);
+        $past
+    }
+
+    # Ensures that the given PAST node has a value known at compile
+    # time and if so obtains it. Otherwise reports an error, involving
+    # the $usage parameter to make it more helpful.
+    sub compile_time_value_str($past, $usage, $/) {
+        if $past.has_compile_time_value {
+            nqp::unbox_s($past.compile_time_value);
+        }
+        else {
+            $*W.throw($/, ['X', 'Value', 'Dynamic'], what => $usage);
+        }
+    }
+
+    sub istype($val, $type) {
+        try { return nqp::istype($val, $type) }
+        0
+    }
+
+    #================================================================
+    # POD-ONLY CODE HANDLERS
+    #================================================================
+    # move ALL Pod-only action objects here
+
+    method pod_content_toplevel($/) {
+        my $child := $<pod_block>.ast;
+        # make sure we don't push the same thing twice
+        if $child {
+            my $id := $/.from ~ "," ~ ~$/.to;
+            if !$*POD_BLOCKS_SEEN{$id} {
+                $*POD_BLOCKS.push($child);
+                $*POD_BLOCKS_SEEN{$id} := 1;
+            }
+        }
+        make $child;
+    }
+
+    method pod_content:sym<block>($/) {
+        make $<pod_block>.ast;
+    }
+
+    # TODO The spaces arg from Grammar.nqp seems
+    #      NOT to be handled. That shows up
+    #      in testing for config continuation lines.
+    method pod_configuration($/) {
+        make Perl6::Pod::make_config($/);
+    }
+
+    method pod_block:sym<delimited>($/) {
+        if $<type>.Str ~~ /^defn/ {
+            make Perl6::Pod::defn($/, $delim-block);
+        }
+        else {
+            make Perl6::Pod::any_block($/, $delim-block);
+        }
+    }
+
+    method pod_block:sym<delimited_comment>($/) {
+        make Perl6::Pod::raw_block($/);
+    }
+
+    method pod_block:sym<delimited_table>($/) {
+        make Perl6::Pod::table($/, $delim-block);
+    }
+
+    method pod_block:sym<delimited_code>($/) {
+        # TODO add numbered-alias handling
+        my $config   := $<pod_configuration>.ast;
+        my @contents := $<delimited_code_content>.ast;
+        @contents    := Perl6::Pod::serialize_array(@contents).compile_time_value;
+        make Perl6::Pod::serialize_object('Pod::Block::Code',
+                                          :@contents,:$config).compile_time_value
+    }
+
+    method delimited_code_content($/) {
+        my @contents := [];
+        for $/[0] {
+            if $_<pod_string> {
+                nqp::splice(@contents,
+                            Perl6::Pod::pod_strings_from_matches($_<pod_string>),
+                            +@contents, 0);
+                nqp::push(@contents, $*W.add_constant(
+                    'Str', 'str', ~$_<pod_newline>
+                ).compile_time_value);
+            } else {
+                @contents.push($*W.add_constant('Str', 'str', "\n").compile_time_value);
+            }
+        }
+        make @contents;
+    }
+
+    method pod_block:sym<paragraph>($/) {
+        if $<type>.Str ~~ /^defn/ {
+            make Perl6::Pod::defn($/, $para-block);
+        }
+        else {
+            make Perl6::Pod::any_block($/, $para-block);
+        }
+    }
+
+    method pod_block:sym<paragraph_comment>($/) {
+        make Perl6::Pod::raw_block($/);
+    }
+
+    method pod_block:sym<paragraph_table>($/) {
+        make Perl6::Pod::table($/, $para-block);
+    }
+
+    method pod_block:sym<paragraph_code>($/) {
+        # TODO make config via call to make_config in Pod.nqp
+        my $config := $<pod_configuration>.ast;
+        my @contents := [];
+        for $<pod_line> {
+            nqp::splice(@contents, $_.ast, +@contents, 0);
+        }
+        @contents  := Perl6::Pod::serialize_array(@contents).compile_time_value;
+        make Perl6::Pod::serialize_object('Pod::Block::Code',
+                                          :@contents,:$config).compile_time_value;
+    }
+
+    method pod_block:sym<abbreviated>($/) {
+        if $<type>.Str ~~ /^defn/ {
+            make Perl6::Pod::defn($/, $abbrev-block);
+        }
+        else {
+            make Perl6::Pod::any_block($/, $abbrev-block);
         }
+    }
 
-        # Bake the signature for our curry
-        my %sig_info := hash(parameters => @params);
-        my $signature := $*W.create_signature_and_params:
-            $/, %sig_info, $curry, 'Mu';
-        add_signature_binding_code($curry, $signature, @params);
+    method pod_block:sym<abbreviated_comment>($/) {
+        make Perl6::Pod::raw_block($/);
+    }
 
-        fatalize($curry[1]) if $*FATAL;
+    method pod_block:sym<abbreviated_table>($/) {
+        make Perl6::Pod::table($/, $abbrev-block);
+    }
 
-        # Create a code object for our curry
-        my $code := $*W.create_code_object: $curry, 'WhateverCode', $signature;
-        $qast := block_closure(reference_to_code_object($code, $curry));
-        $qast.returns: $WhateverCode;
-        $qast.arity: nqp::elems(@params);
+    method pod_block:sym<abbreviated_code>($/) {
+        my @contents := [];
+        for $<pod_line> {
+            nqp::splice(@contents, $_.ast, +@contents, 0);
+        }
+        @contents := Perl6::Pod::serialize_array(@contents).compile_time_value;
+        make Perl6::Pod::serialize_object(
+            'Pod::Block::Code', :@contents
+        ).compile_time_value
+    }
 
-        # Hyperspace!
-        $qast := QAST::Op.new: :op<call>, :name<&HYPERWHATEVER>, $qast
-            if $hyperwhatever;
-        $qast;
+    method pod_line ($/) {
+        my @contents := Perl6::Pod::pod_strings_from_matches($<pod_string>);
+        @contents.push($*W.add_constant(
+            'Str', 'str', ~$<pod_newline>
+        ).compile_time_value);
+        make @contents;
     }
 
-    sub find_block_calls_and_migrate($from, $to, $qast) {
-        if nqp::can($qast, 'ann') && $qast.ann('past_block') -> $block {
-            $to[0].push: $block;
-            remove_block($from, $block, :ignore-not-found);
-        }
-        elsif nqp::istype($qast, QAST::Node) {
-            for @($qast) {
-                find_block_calls_and_migrate($from, $to, $_);
-            }
+    method pod_block:sym<finish>($/) {
+        $*W.install_lexical_symbol(
+          $*UNIT,'$=finish', nqp::hllizefor(~$<finish>, 'perl6'));
+    }
+
+    method pod_content:sym<config>($/) {
+        make Perl6::Pod::config($/);
+    }
+
+    method pod_content:sym<text>($/) {
+        my @ret := [];
+        for $<pod_textcontent> {
+            @ret.push($_.ast);
         }
+        my $past := Perl6::Pod::serialize_array(@ret);
+        make $past.compile_time_value;
     }
 
-    sub remove_block($from, $block, :$ignore-not-found) {
-        # Remove the QAST::Block $block from $from[0]; die if not found.
-        my @decls := $from[0].list;
-        my int $i := 0;
-        my int $n := nqp::elems(@decls);
-        while $i < $n {
-            my $consider := @decls[$i];
-            if $consider =:= $block {
-                @decls[$i] := QAST::Op.new( :op('null') );
-                return 1;
+    method pod_textcontent:sym<regular>($/) {
+        my @contents := Perl6::Pod::pod_strings_from_matches($<pod_string>);
+        @contents    := Perl6::Pod::serialize_array(@contents).compile_time_value;
+        make Perl6::Pod::serialize_object('Pod::Block::Para', :@contents).compile_time_value
+    }
+
+    method pod_textcontent:sym<code>($/) {
+        my $s := $<spaces>.Str;
+        my $t := subst($<text>.Str, /\n$s/, "\n", :global);
+        $t    := subst($t, /\n$/, ''); # chomp!
+        my $past := Perl6::Pod::serialize_object(
+            'Pod::Block::Code',
+            :contents(Perl6::Pod::serialize_aos([$t]).compile_time_value),
+        );
+        make $past.compile_time_value;
+    }
+
+    method pod_formatting_code($/) {
+        if $<code> eq 'V' {
+            make ~$<contents>;
+        } elsif $<code> eq 'E' {
+            my @contents := [];
+            my @meta    := [];
+            for $/[0] {
+                if $_<html_ref> {
+                    @contents.push(~$_);
+                    @meta.push($*W.add_string_constant(~$_).compile_time_value);
+                    #my $s := Perl6::Pod::str_from_entity(~$_);
+                    #$s ?? @contents.push($s) && @meta.push(~$_)
+                    #   !! $/.worry("\"$_\" is not a valid HTML5 entity.");
+                } else {
+                    my $n := $_<integer>
+                          ?? $_<integer>.made
+                          !! nqp::codepointfromname(~$_);
+                    if $n >= 0 {
+                        @contents.push(nqp::chr($n));
+                        @meta.push($n);
+                    } else {
+                        $/.worry("\"$_\" is not a valid Unicode character name or code point.");
+                    }
+                }
             }
-            elsif nqp::istype($consider, QAST::Stmt) || nqp::istype($consider, QAST::Stmts) {
-                if $consider[0] =:= $block {
-                    $consider[0] := QAST::Op.new( :op('null') );
-                    return 1;
+            @contents := Perl6::Pod::serialize_aos(@contents).compile_time_value;
+            @meta    := Perl6::Pod::serialize_array(@meta).compile_time_value;
+            make Perl6::Pod::serialize_object(
+                'Pod::FormattingCode',
+                :type($*W.add_string_constant(~$<code>).compile_time_value),
+                :@contents,
+                :@meta,
+            ).compile_time_value;
+        } else {
+            my @chars := Perl6::Pod::build_pod_chars($<pod_string_character>);
+            my @meta := [];
+            if $<code> eq 'X' {
+                for $/[0] {
+                    my @tmp := [];
+                    for $_<meta> {
+                        @tmp.push(~$_);
+                    }
+                    @meta.push(@tmp);
+                }
+                @meta := Perl6::Pod::serialize_aoaos(@meta).compile_time_value;
+            } else {
+                for $<meta> {
+                    @meta.push(~$_)
                 }
+                @meta := Perl6::Pod::serialize_aos(@meta).compile_time_value;
             }
-            $i++;
+            my @contents  := Perl6::Pod::build_pod_strings([@chars]);
+            @contents := Perl6::Pod::serialize_array(@contents).compile_time_value;
+            my $past := Perl6::Pod::serialize_object(
+                'Pod::FormattingCode',
+                :type($*W.add_string_constant(~$<code>).compile_time_value),
+                :@contents,
+                :meta(@meta),
+            );
+            make $past.compile_time_value;
         }
-        nqp::die('Internal error: failed to remove block')
-            unless $ignore-not-found;
     }
 
-    sub wrap_return_type_check($wrappee, $code_obj) {
-        my $ret := %*SIG_INFO<returns>;
-        return $wrappee if nqp::isconcrete($ret) || $ret.HOW.name($ret) eq 'Nil';
-        QAST::Op.new(
-            :op('p6typecheckrv'),
-            $wrappee,
-            QAST::WVal.new( :value($code_obj) ),
-            QAST::WVal.new( :value($*W.find_symbol(['Nil'])) )
-        );
+    method pod_string($/) {
+        make Perl6::Pod::build_pod_chars($<pod_string_character>);
     }
 
-    sub wrap_return_handler($past) {
-        wrap_return_type_check(
-            QAST::Op.new(
-                :op<handlepayload>,
-                # If we fall off the bottom, decontainerize if
-                # rw not set.
-                QAST::Op.new( :op('p6decontrv'), QAST::WVal.new( :value($*DECLARAND) ), $past ),
-                'RETURN',
-                QAST::Op.new( :op<lastexpayload> )
-            ),
-            $*DECLARAND
-        )
+    method pod_balanced_braces($/) {
+        if $<endtag> {
+            my @chars := Perl6::Pod::build_pod_chars($<pod_string_character>);
+            @chars.unshift(~$<start>);
+            @chars.push(~$<endtag>);
+            make @chars;
+        } else {
+            make ~$<braces>
+        }
     }
 
-    # Works out how to look up a type. If it's not generic and is in an SC, we
-    # statically resolve it. Otherwise, we punt to a runtime lexical lookup.
-    sub instantiated_type(@name, $/) {
-        CATCH {
-            $*W.throw($/, ['X', 'NoSuchSymbol'], symbol => join('::', @name));
-        }
-        my $type := $*W.find_symbol(@name);
-        my $is_generic := 0;
-        try { $is_generic := $type.HOW.archetypes.generic }
-        my $past;
-        if $is_generic || nqp::isnull(nqp::getobjsc($type)) || istype($type.HOW,$/.how('package')) {
-            $past := $*W.symbol_lookup(@name, $/);
-            $past.set_compile_time_value($type);
-        }
-        else {
-            $past := QAST::WVal.new( :value($type) );
+    method pod_string_character($/) {
+        if $<pod_formatting_code> {
+            make $<pod_formatting_code>.ast
+        } elsif $<pod_balanced_braces> {
+            make $<pod_balanced_braces>.ast
+        } else {
+            make ~$<char>;
         }
-        $past.returns($type.WHAT);
-        $past
     }
 
-    # Ensures that the given PAST node has a value known at compile
-    # time and if so obtains it. Otherwise reports an error, involving
-    # the $usage parameter to make it more helpful.
-    sub compile_time_value_str($past, $usage, $/) {
-        if $past.has_compile_time_value {
-            nqp::unbox_s($past.compile_time_value);
-        }
-        else {
-            $*W.throw($/, ['X', 'Value', 'Dynamic'], what => $usage);
-        }
+    method table_row($/) {
+        make ~$/
     }
 
-    sub istype($val, $type) {
-        try { return nqp::istype($val, $type) }
-        0
+    method table_row_or_blank($/) {
+        make ~$/
     }
+
+
+
+    #================================================================
+    # end of class Perl6::Actions block
+    #================================================================
 }
 
 class Perl6::QActions is HLL::Actions does STDActions {
diff --git a/src/Perl6/Grammar.nqp b/src/Perl6/Grammar.nqp
index cdd04750c3f..f7225757e89 100644
--- a/src/Perl6/Grammar.nqp
+++ b/src/Perl6/Grammar.nqp
@@ -473,6 +473,9 @@ role STD {
 }
 
 grammar Perl6::Grammar is HLL::Grammar does STD {
+    #================================================================
+    # AMBIENT AND POD-COMMON CODE HANDLERS
+    #================================================================
     my class SerializationContextId {
         my $count := 0;
         my $lock  := NQPLock.new;
@@ -714,1628 +717,1102 @@ grammar Perl6::Grammar is HLL::Grammar does STD {
         ]
     }
 
-    proto token comment { <...> }
-
-    token comment:sym<#> {
-       '#' {} \N*
-    }
+    token install_doc_phaser { <?> }
 
-    token comment:sym<#`(...)> {
-        '#`' <?opener> {}
-        [ <.quibble(self.slang_grammar('Quote'))> || <.typed_panic: 'X::Syntax::Comment::Embedded'> ]
+    token vnum {
+        \w+ | '*'
     }
 
-    token comment:sym<#|(...)> {
-        '#|' <?opener> <attachment=.quibble(self.slang_grammar('Quote'))>
-        {
-            unless $*POD_BLOCKS_SEEN{ self.from() } {
-                $*POD_BLOCKS_SEEN{ self.from() } := 1;
-                if $*DECLARATOR_DOCS eq '' {
-                    $*DECLARATOR_DOCS := $<attachment><nibble>;
-                } else {
-                    $*DECLARATOR_DOCS := nqp::concat($*DECLARATOR_DOCS, nqp::concat("\n", $<attachment><nibble>));
-                }
-            }
-        }
+    token version {
+        <?before v\d+\w*> 'v' $<vstr>=[<vnum>+ % '.' '+'?]
+        <!before '-'|\'> # cheat because of LTM fail
     }
 
-    token comment:sym<#|> {
-        '#|' \h+ $<attachment>=[\N*]
-        {
-            unless $*POD_BLOCKS_SEEN{ self.from() } {
-                $*POD_BLOCKS_SEEN{ self.from() } := 1;
-                if $*DECLARATOR_DOCS eq '' {
-                    $*DECLARATOR_DOCS := $<attachment>;
-                } else {
-                    $*DECLARATOR_DOCS := nqp::concat($*DECLARATOR_DOCS, nqp::concat("\n", $<attachment>));
-                }
-            }
-        }
-    }
+    ## Top-level rules
 
-    token comment:sym<#=(...)> {
-        '#=' <?opener> <attachment=.quibble(self.slang_grammar('Quote'))>
-        {
-            self.attach_trailing_docs(~$<attachment><nibble>);
-        }
-    }
+    token comp_unit {
+        # From STD.pm.
+        :my $*LEFTSIGIL;                           # sigil of LHS for item vs list assignment
+        :my $*SCOPE := '';                         # which scope declarator we're under
+        :my $*MULTINESS := '';                     # which multi declarator we're under
+        :my $*QSIGIL := '';                        # sigil of current interpolation
+        :my $*IN_META := '';                       # parsing a metaoperator like [..]
+        :my $*IN_REDUCE := 0;                      # attempting to parse an [op] construct
+        :my $*IN_DECL;                             # what declaration we're in
+        :my $*IN_RETURN := 0;                      # are we in a return?
+        :my $*HAS_SELF := '';                      # is 'self' available? (for $.foo style calls)
+        :my $*begin_compunit := 1;                 # whether we're at start of a compilation unit
+        :my $*DECLARAND;                           # the current thingy we're declaring, and subject of traits
+        :my $*CODE_OBJECT;                         # the code object we're currently inside
+        :my $*METHODTYPE;                          # the current type of method we're in, if any
+        :my $*PKGDECL;                             # what type of package we're in, if any
+        :my %*MYSTERY;                             # names we assume may be post-declared functions
+        :my $*BORG := {};                          # who gets blamed for a missing block
+        :my $*CCSTATE := '';
+        :my $*STRICT;
+        :my $*INVOCANT_OK := 0;
+        :my $*INVOCANT;
+        :my $*ARG_FLAT_OK := 0;
+        :my $*WHENEVER_COUNT := -1;                # -1 indicates whenever not valid here
 
-    token comment:sym<#=> {
-        '#=' \h+ $<attachment>=[\N*]
-        {
-            self.attach_trailing_docs(~$<attachment>);
-        }
-    }
+        # Error related. There are three levels: worry (just a warning), sorry
+        # (fatal but not immediately so) and panic (immediately deadly). There
+        # is a limit on the number of sorrows also. Unlike STD, which emits the
+        # textual messages as it goes, we keep track of the exception objects
+        # and, if needed, make a composite exception group.
+        :my @*WORRIES;                             # exception objects resulting from worry
+        :my @*SORROWS;                             # exception objects resulting from sorry
+        :my $*SORRY_LIMIT := 10;                   # when sorrow turns to panic
 
-    method attach_leading_docs() {
-        # TODO allow some limited text layout here
-        if ~$*DOC ne '' {
-            my $cont  := Perl6::Pod::serialize_aos(
-                [Perl6::Pod::normalize_text(~$*DOC)]
-            ).compile_time_value;
-            my $block := $*W.add_constant(
-                'Pod::Block::Declarator', 'type_new',
-                :nocache, :leading([$cont]),
-            );
-            $*POD_BLOCK := $block.compile_time_value;
-            $*POD_BLOCKS.push($*POD_BLOCK);
-        }
-        self
-    }
+        # Extras.
+        :my @*NQP_VIOLATIONS;                      # nqp::ops per line number
+        :my %*HANDLERS;                            # block exception handlers
+        :my $*IMPLICIT;                            # whether we allow an implicit param
+        :my $*HAS_YOU_ARE_HERE := 0;               # whether {YOU_ARE_HERE} has shown up
+        :my $*OFTYPE;
+        :my $*VMARGIN    := 0;                     # pod stuff
+        :my $*ALLOW_INLINE_CODE := 0;              # pod stuff
+        :my $*POD_IN_CODE_BLOCK := 0;              # pod stuff
+        :my $*POD_IN_FORMATTINGCODE := 0;          # pod stuff
+        :my $*POD_ALLOW_FCODES := 0b11111111111111111111111111; # allow which fcodes?
+        :my $*POD_ANGLE_COUNT := 0;                # pod stuff
+        :my $*IN_REGEX_ASSERTION := 0;
+        :my $*IN_PROTO := 0;                       # are we inside a proto?
+        :my $*NEXT_STATEMENT_ID := 1;              # to give each statement an ID
+        :my $*IN_STMT_MOD := 0;                    # are we inside a statement modifier?
+        :my $*COMPILING_CORE_SETTING := 0;         # are we compiling CORE.setting?
+        # TODO XXX: see https://github.com/rakudo/rakudo/issues/2432
+        :my $*SET_DEFAULT_LANG_VER := 1;
+        :my %*SIG_INFO;                            # information about recent signature
 
-    method attach_trailing_docs($doc) {
-        # TODO allow some limited text layout here
-        unless $*POD_BLOCKS_SEEN{ self.from() } {
-            $*POD_BLOCKS_SEEN{ self.from() } := 1;
-            my $pod_block;
-            if $doc ne '' {
-                my $cont  := Perl6::Pod::serialize_aos(
-                    [Perl6::Pod::normalize_text($doc)]
-                ).compile_time_value;
-                my $block := $*W.add_constant(
-                    'Pod::Block::Declarator', 'type_new',
-                    :nocache, :trailing([$cont]),
-                );
-                $pod_block := $block.compile_time_value;
-            }
-            unless $*PRECEDING_DECL =:= Mu {
-                Perl6::Pod::document(self.MATCH, $*PRECEDING_DECL, $pod_block, :trailing);
-            }
-        }
-    }
+        # Various interesting scopes we'd like to keep to hand.
+        :my $*GLOBALish;
+        :my $*PACKAGE;
+        :my $*UNIT;
+        :my $*UNIT_OUTER;
+        :my $*EXPORT;
+        # stack of packages, which the 'is export' needs
+        :my @*PACKAGES := [];
 
-    token pod_content_toplevel {
-        <pod_block>
-    }
+        # A place for Pod
+        :my $*POD_BLOCKS := [];
+        :my $*POD_BLOCKS_SEEN := {};
+        :my $*POD_PAST;
+        :my $*DECLARATOR_DOCS;
+        :my $*PRECEDING_DECL; # for #= comments
+        :my $*PRECEDING_DECL_LINE := -1; # XXX update this when I see another comment like it?
+        # TODO use these vars to implement S26 pod data block handling
+        :my $*DATA-BLOCKS := [];
+        :my %*DATA-BLOCKS := {};
 
-    proto token pod_content { <...> }
+        # Quasis and unquotes
+        :my $*IN_QUASI := 0;                       # whether we're currently in a quasi block
+        :my $*MAIN := 'MAIN';
 
-    token pod_content:sym<block> {
-        <pod_newline>*
-        <pod_block>
-        <pod_newline>*
-    }
+        # performance improvement stuff
+        :my $*FAKE_INFIX_FOUND := 0;
 
-    # any number of paragraphs of text
-    # the paragraphs are separated by one
-    #   or more pod_newlines
-    # each paragraph originally could have
-    #   consisted of more than one line of
-    #   text that were subsequently squeezed
-    #   into one line
-    token pod_content:sym<text> {
-        <pod_newline>*
+        # for runaway detection
+        :my $*LASTQUOTE := [0,0];
 
-        # TODO get first line if IN-DEFN-BLOCK
-        <pod_textcontent>+ % <pod_newline>+
+        {
+            nqp::getcomp('perl6').reset_language_version();
+            $*W.loading_and_symbol_setup($/)
+        }
 
-        <pod_newline>*
-    }
+        <.finishpad>
+        <.bom>?
+        <lang-version>
+        <statementlist=.FOREIGN_LANG($*MAIN, 'statementlist', 1)>
 
-    # not a block, just a directive
-    token pod_content:sym<config> {
-        <pod_newline>*
-        ^^ \h* '=config' \h+ $<type>=\S+ <pod_configuration>
-        <pod_newline>+
-    }
+        <.install_doc_phaser>
 
-    proto token pod_textcontent { <...> }
+        [ $ || <.typed_panic: 'X::Syntax::Confused'> ]
 
-    # for non-code (i.e., regular) text
-    token pod_textcontent:sym<regular> {
-        $<spaces>=[ \h* ]
-         <?{ $*POD_IN_CODE_BLOCK
-             || !$*ALLOW_INLINE_CODE
-             || ($<spaces>.to - $<spaces>.from) <= $*VMARGIN }>
+        <.explain_mystery>
+        <.cry_sorrows>
 
-        $<text> = [
-            \h* <!before '=' \w> <pod_string> [ <pod_newline> | $ ]
-        ] +
+        { $*W.mop_up_and_check($/) }
     }
 
-    token pod_textcontent:sym<code> {
-        $<spaces>=[ \h* ]
-        <?{ !$*POD_IN_CODE_BLOCK
-            && $*ALLOW_INLINE_CODE
-            && ($<spaces>.to - $<spaces>.from) > $*VMARGIN }>
+    method clonecursor() {
+        my $new := self.'!cursor_init'(
+            self.orig(),
+            :p(self.pos()),
+            :shared(self.'!shared'()),
+            :braid(self."!braid"()."!clone"()));
+        $new;
+    }
 
-        # TODO get first line if IN-DEFN-BLOCK
-        $<text> = [
-            [<!before '=' \w> \N+]+ % [<pod_newline>+ $<spaces>]
+    rule lang-version {
+        :my $comp := nqp::getcomp('perl6');
+        [
+          <.ws>? 'use' <version> {} # <-- update $/ so we can grab $<version>
+          # we parse out the numeral, since we could have "6d"
+          :my $version := nqp::radix(10,$<version><vnum>[0],0,0)[0];
+          [
+          ||  <?{ $version == 6 }> { $*W.load-lang-ver: $<version>, $comp }
+          ||  { $/.typed_panic: 'X::Language::Unsupported',
+                  version => ~$<version> }
+          ]
+        || {
+              # This is the path we take when the user did not
+              # provide any `use v6.blah` lang version statement
+              $*W.load-lang-ver: 'v6', $comp if $*SET_DEFAULT_LANG_VER;
+          }
         ]
     }
 
-    token pod_formatting_code {
-        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
-        :my $*POD_IN_FORMATTINGCODE := nqp::getlexdyn('$*POD_IN_FORMATTINGCODE');
-        :my $*POD_ANGLE_COUNT := nqp::getlexdyn('$*POD_ANGLE_COUNT');
-        <?{ $*POD_ALLOW_FCODES }>
-
-        :my $endtag;
-        <code=[A..Z]>
-        $<begin-tag>=['<'+ <![<]> | '«'] { $*POD_IN_FORMATTINGCODE := 1 }
-        <?{
-            my $codenum := nqp::ord($<code>.Str) - nqp::ord("A");
-            if !($*POD_ALLOW_FCODES +& (2 ** $codenum)) {
-                0
-            } elsif ~$<begin-tag> eq '«' {
-              $endtag := "»";
-              $*POD_ANGLE_COUNT := -1;
-              1
-            } else {
-              my int $ct := nqp::chars($<begin-tag>);
-              $endtag := nqp::x(">", $ct);
-              my $rv := $*POD_ANGLE_COUNT <= 0 || $*POD_ANGLE_COUNT >= $ct;
-              $*POD_ANGLE_COUNT := $ct;
-              $rv;
-            }
-        }>
-        {
-            if $<code>.Str eq "V" || $<code>.Str eq "C" {
-                $*POD_ALLOW_FCODES := 0;
-            }
-        }
-        [ <!{$<code> eq 'E'}>
-          $<contents>=[
-              <!before $endtag>
-              [ <?{$<code> ne 'L' && $<code> ne 'D' && $<code> ne 'X' }> || <!before \s* \| > ]
-              <pod_string_character>
-          ]*
-        ]?
-        [
-        | <?{$<code> eq 'L'}> \s* \| \s* $<meta>=[<!before $endtag>.]+
-        | <?{$<code> eq 'X'}> \s* \| \s* ( [$<meta>=[<!before $endtag | <[,;]> >.]+] +%% \, ) +%% \;
-        | <?{$<code> eq 'D'}> \s* \| \s* [$<meta>=[<!before $endtag | \; >.]+] +%% \;
-        | <?{$<code> eq 'E'}> ( <integer> | $<uni_name>=<[A..Z\s]>+ <![a..z]> || $<html_ref>=<[A..Za..z]>+ ) +%% \;
-        ]?
-        [ $endtag || <.worry: "Pod formatting code $<code> missing endtag '$endtag'."> ]
-    }
+    rule statementlist($*statement_level = 0) {
+        :my $*LANG;
+        :my $*LEAF;
+        :my %*LANG   := self.shallow_copy(self.slangs);   # XXX deprecated
+        :my $*STRICT := nqp::getlexdyn('$*STRICT');
 
-    token pod_balanced_braces {
-        <?{ $*POD_IN_FORMATTINGCODE }>
-        :my $endtag;
+        :dba('statement list')
+#        <.check_LANG_oopsies('statementlist')>
+        <.ws>
+        # Define this scope to be a new language.
+        <!!{ $*LANG := $*LEAF := $/.clone_braid_from(self); 1 }>
         [
-            $<braces>=[
-                      || '<'+ <![<]>
-                      || '>'+ <![>]>
-                      ]
-            <?{ nqp::chars($<braces>) < $*POD_ANGLE_COUNT || $*POD_ANGLE_COUNT < 0 }>
-          ||
-            <?{ $*POD_ANGLE_COUNT >= 1 }>
-            $<start>=['<'+] <![<]>
-            <?{ nqp::chars($<start>) == $*POD_ANGLE_COUNT || $*POD_ANGLE_COUNT < 0 }>
-            {
-                $endtag := nqp::x(">", nqp::chars($<start>));
-            }
-            $<contents>=[ <pod_string_character>*?]
-            <!after '>'> $<endtag>=[$endtag]
+        | $
+        | <?before <.[\)\]\}]>>
+        | [ <statement> <.eat_terminator> ]*
         ]
+        <.set_braid_from(self)>   # any language tweaks must not escape
+        <!!{ nqp::rebless($/, self.WHAT); 1 }>
     }
 
-    token pod_string {
-        <pod_string_character>+
+    method shallow_copy(%hash) {
+        my %result;
+        for %hash {
+            %result{$_.key} := $_.value;
+        }
+        %result
     }
 
-    token pod_string_character {
-        <pod_balanced_braces> || <pod_formatting_code> || $<char>=[ \N || [
-            <?{ $*POD_IN_FORMATTINGCODE }> \n [
-                <?{ $*POD_DELIMITED_CODE_BLOCK }> <!before \h* '=end' \h+ <pod-delim-code-typ> > ||
-                <!before \h* '=' \w>
-                ]
-            ]
+    rule semilist {
+        :dba('list composer')
+        ''
+        [
+        | <?before <.[)\]}]> >
+        | [<statement><.eat_terminator> ]*
         ]
     }
 
-    proto token pod_block { <...> }
-
-    token pod_configuration($spaces = '') {
-        [ [\n $spaces '=']? \h+ <colonpair> ]*
-    }
-
-    token pod_block:sym<delimited_comment> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=begin' \h+ 'comment' {}
-        <pod_configuration($<spaces>)> <pod_newline>+
+    rule sequence {
+        :dba('sequence of statements')
+        ''
         [
-         $<pod_content> = [ .*? ]
-         ^^ $<spaces> '=end' \h+
-         [
-            'comment' [ <pod_newline> | $ ]
-            || $<instead>=<identifier>? {
-                   $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
-                       type    => 'comment',
-                       spaces  => ~$<spaces>,
-                       instead => $<instead> ?? ~$<instead> !! ''
-               }
-         ]
+        | <?before <.[)\]}]> >
+        | [<statement><.eat_terminator> ]*
         ]
     }
 
-    regex pod_block:sym<delimited> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=begin'
-        [ <?pod_newline>
-          <.typed_panic('X::Syntax::Pod::BeginWithoutIdentifier')>
-        ]?
-        \h+ <!before 'finish'>
+    token label {
+        <identifier> ':' <?[\s]> <.ws>
         {
-            $*VMARGIN    := $<spaces>.to - $<spaces>.from;
-        }
-        :my $*ALLOW_INLINE_CODE := 0;
-        $<type> = [
-            <pod_code_parent> {
-                $*ALLOW_INLINE_CODE := 1;
+            $*LABEL := ~$<identifier>;
+            if $*W.already_declared('my', self.package, $*W.cur_lexpad(), [$*LABEL]) {
+                $*W.throw($/, ['X', 'Redeclaration'], symbol => $*LABEL);
             }
-            || <identifier>
-        ]
-        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
-        <pod_configuration($<spaces>)> <pod_newline>+
-        [
-         # TODO need first line to check for ws-separated '#'
-         <pod_content> *
-         ^^ $<spaces> '=end' \h+
-         [
-             $<type> [ <pod_newline> | $ ]
-             || $<instead>=<identifier>? {
-                    $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
-                        type    => ~$<type>,
-                        spaces  => ~$<spaces>,
-                        instead => $<instead> ?? ~$<instead> !! ''
-                    }
-         ]
-        ]
+            my str $orig      := self.orig();
+            my int $total     := nqp::chars($orig);
+            my int $from      := self.MATCH.from();
+            my int $to        := self.MATCH.to() + nqp::chars($*LABEL);
+            my int $line      := HLL::Compiler.lineof($orig, self.from(), :cache(1));
+            my str $prematch  := nqp::substr($orig, $from > 20 ?? $from - 20 !! 0, $from > 20 ?? 20 !! $from);
+            my str $postmatch := nqp::substr($orig, $to, 20);
+            my $label     := $*W.find_symbol(['Label']).new( :name($*LABEL), :$line, :$prematch, :$postmatch );
+            $*W.add_object_if_no_sc($label);
+            $*W.install_lexical_symbol($*W.cur_lexpad(), $*LABEL, $label);
+        }
     }
 
+    token statement($*LABEL = '') {
+        :my $*QSIGIL := '';
+        :my $*SCOPE := '';
 
-    token pod_block:sym<delimited_table> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=begin' \h+ 'table' {}
-        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
-        <pod_configuration($<spaces>)> <pod_newline>+
+        # NOTE: annotations that use STATEMENT_ID often also need IN_STMT_MOD annotation, in order
+        # to correctly migrate QAST::Blocks in constructs inside topics of statement modifiers
+        :my $*STATEMENT_ID := $*NEXT_STATEMENT_ID++;
+        :my $*IN_STMT_MOD := nqp::getlexdyn('$*IN_STMT_MOD');
+
+        :my $*ESCAPEBLOCK := 0;
+        :my $actions := self.slang_actions('MAIN');
+        <!!{ $/.set_actions($actions); 1 }>
+        <!before <.[\])}]> | $ >
+        <!stopper>
+        <!!{ nqp::rebless($/, self.slang_grammar('MAIN')); 1 }>
         [
-         [ $<table_row>=<.table_row_or_blank> ]*
-         ^^ \h* '=end' \h+
-         [
-            'table' [ <pod_newline> | $ ]
-             || $<instead>=<identifier>? {
-                    $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
-                        type    => 'table',
-                        spaces  => ~$<spaces>,
-                        instead => $<instead> ?? ~$<instead> !! ''
+        | <label> <statement($*LABEL)> { $*LABEL := '' if $*LABEL }
+        | <statement_control>
+        | <EXPR> :dba('statement end') { $*IN_STMT_MOD := 1 }
+            [
+            || <?MARKED('endstmt')>
+            || :dba('statement modifier') <.ws> <statement_mod_cond> <statement_mod_loop>?
+            || :dba('statement modifier loop') <.ws> <statement_mod_loop>
+                {
+                    my $sp := $<EXPR><statement_prefix>;
+                    if $sp && $sp<sym> eq 'do' {
+                        my $s := $<statement_mod_loop><sym>;
+                        $/.obs("do..." ~ $s, "repeat...while or repeat...until")
+                          unless $*LANG.pragma('p5isms');
                     }
-         ]
+                }
+            ]?
+        | <?[;]>
+        | <?stopper>
+        | {} <.panic: "Bogus statement">
         ]
     }
 
-    # There are several different identifiers for pod blocks
-    # that are treated essentially the same: 'code', 'input',
-    # and 'output'.
-    token pod-delim-code-typ { code | input | output }
-    token pod_block:sym<delimited_code> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=begin' \h+ $<typ>=<pod-delim-code-typ> {}
-        :my $*POD_ALLOW_FCODES  := 0;
-        :my $*POD_IN_CODE_BLOCK := 1;
-        :my $*POD_DELIMITED_CODE_BLOCK := 1;
-        <pod_configuration($<spaces>)> <pod_newline>+
-        [
-        || <delimited_code_content($<spaces>)> $<spaces> '=end' \h+
-            [ $<end>=<pod-delim-code-typ> [ <pod_newline> | $ ]
-              { if ~$<end> ne ~$<typ> {
-                         $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
-                         type    => ~$<typ>,
-                         spaces  => ~$<spaces>,
-                         instead => $<end> ?? ~$<end> !! ''
-              }}
-              || $<instead>=<identifier>? {
-                     $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
-                     type    => $<typ>,
-                     spaces  => ~$<spaces>,
-                     instead => $<instead> ?? ~$<instead> !! ''
-                 }
-            ]
-        ]
+    token eat_terminator {
+        || ';'
+        || <?MARKED('endstmt')> <.ws>
+        || <?before ')' | ']' | '}' >
+        || $
+        || <?stopper>
+        || <?before [if|while|for|loop|repeat|given|when] » > { $/.'!clear_highwater'(); self.typed_panic( 'X::Syntax::Confused', reason => "Missing semicolon" ) }
+        || { $/.typed_panic( 'X::Syntax::Confused', reason => "Confused" ) }
     }
 
-    token delimited_code_content($spaces = '') {
-        ^^
-        (
-        | $spaces
-            <!before '=end' \h+ <pod-delim-code-typ> [ <pod_newline> | $ ]>
-            <pod_string>**0..1 <pod_newline>
-        | <pod_newline>
-        )*
+    token xblock($*IMPLICIT = 0) {
+        :my $*GOAL := '{';
+        :my $*BORG := {};
+        <EXPR> <.ws> <pblock($*IMPLICIT)>
     }
 
-    token table_row {
-        \h* <!before '=' \w> \N+ [ \n | $ ]
+    token pblock($*IMPLICIT = 0) {
+        :my $*DECLARAND := $*W.stub_code_object('Block');
+        :my $*CODE_OBJECT := $*DECLARAND;
+        :my $*SIG_OBJ;
+        :my %*SIG_INFO;
+        :my $*POD_BLOCK;
+        :my $*DOC := $*DECLARATOR_DOCS;
+        :my $*LINE_NO := HLL::Compiler.lineof(self.orig(), self.from(), :cache(1));
+        :my $*FATAL := self.pragma('fatal');  # can also be set inside statementlist
+        {
+            $*DECLARATOR_DOCS := '';
+
+            if $*PRECEDING_DECL_LINE < $*LINE_NO {
+                $*PRECEDING_DECL_LINE := $*LINE_NO;
+                $*PRECEDING_DECL := $*DECLARAND;
+            }
+        }
+        <.attach_leading_docs>
+        :dba('block or pointy block')
+        :my $borg := $*BORG;
+        :my $has_mystery := $*MYSTERY ?? 1 !! 0;
+        { $*BORG := {} }
+        [
+        | <lambda>
+            <.newpad>
+            :my $*SCOPE := 'my';
+            :my $*GOAL := '{';
+            <signature> {
+                %*SIG_INFO := $<signature>.ast;
+                $*SIG_OBJ := $*W.create_signature_and_params($<signature>,
+                    %*SIG_INFO, $*W.cur_lexpad(), 'Mu', :rw($<lambda> eq '<->'));
+            }
+            <blockoid>
+        | <?[{]>
+            <.newpad>
+            <blockoid>
+        || <.missing_block($borg, $has_mystery)>
+        ]
     }
 
-    token table_row_or_blank {
-        <.table_row> | [\h* <!before '=' \w> \n ]
+    token lambda { '->' | '<->' }
+
+    token block($*IMPLICIT = 0) {
+        :my $*DECLARAND := $*W.stub_code_object('Block');
+        :my $*CODE_OBJECT := $*DECLARAND;
+        :dba('scoped block')
+        :my $borg := $*BORG;
+        :my $has_mystery := $*MYSTERY ?? 1 !! 0;
+        :my $*FATAL := self.pragma('fatal');  # can also be set inside statementlist
+        { $*BORG := {} }
+        [ <?[{]> || <.missing_block($borg, $has_mystery)>]
+        <.newpad>
+        <blockoid>
     }
 
-    token pod_block:sym<finish> {
-        ^^ \h*
+    token blockoid {
+        :my $*CURPAD;
+        :my %*HANDLERS;
+        <.finishpad>
+        :my $borg := $*BORG;
+        :my $has_mystery := $*MYSTERY ?? 1 !! 0;
+        { $*BORG := {} }
         [
-            | '=begin' \h+ 'finish' <pod_newline>
-            | '=for'   \h+ 'finish' <pod_newline>
-            | '=finish' <pod_newline>
+        | '{YOU_ARE_HERE}' <you_are_here>
+        | :dba('block')
+            '{'
+            <!!{ $*VARIABLE := '' if $*VARIABLE; 1 }>
+            <statementlist(1)>
+            [<.cheat_heredoc> || '}']
+            <?ENDSTMT>
+        || <.missing_block($borg, $has_mystery)>
         ]
-        $<finish> = .*
+        { $*CURPAD := $*W.pop_lexpad() }
     }
 
-    token pod_block:sym<paragraph> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=for' \h+ <!before 'finish'>
-        {
-            $*VMARGIN := $<spaces>.to - $<spaces>.from;
-        }
-        :my $*ALLOW_INLINE_CODE := 0;
-        [ :!ratchet
-            $<type> = [
-                <pod_code_parent> { $*ALLOW_INLINE_CODE := 1 }
-                || <identifier>
-            ]
-            :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
-            <pod_configuration($<spaces>)>
-            <pod_newline>
-        ]
-        # TODO [defn, term], [first text, line numbered-alias]
-        #   if this is a defn block
-        #     the first line of the first pod_textcontent
-        #     becomes the term
-        #     then combine the rest of the text
-        # TODO exchange **0..1 for modern syntax
-        <pod_content=.pod_textcontent>**0..1
+    token unitstart { <?> }
+    token you_are_here {
+        <?{ nqp::getlexdyn('$?FILES') ~~ /\.setting$/ }> ||
+            { self.typed_panic('X::Syntax::Reserved',
+                reserved => 'use of {YOU_ARE_HERE} outside of a setting',
+                instead => ' (use whitespace if not a setting, or rename file with .setting extension?)');
+            }
     }
+    token newpad { <?> { $*W.push_lexpad($/) } }
+    token newthunk { <?> { $*W.push_thunk($/) } }
+    token finishpad { <?> }
 
-    token pod_block:sym<paragraph_comment> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=for' \h+ 'comment' {}
-        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
-        <pod_configuration($<spaces>)> <pod_newline>
-        $<pod_content> = [ \h* <!before '=' \w> \N+ [ \n | $ ] ]*
-    }
+    token bom { \xFEFF }
 
-    token pod_block:sym<paragraph_table> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=for' \h+ 'table' {}
-        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
-        <pod_configuration($<spaces>)> <pod_newline>
+    proto token terminator { <...> }
 
-        # TODO add numbered-alias token here
-        [ <!before \h* \n> <table_row>]*
-    }
+    token terminator:sym<;> { <?[;]> }
+    token terminator:sym<)> { <?[)]> }
+    token terminator:sym<]> { <?[\]]> }
+    token terminator:sym<}> { <?[}]> }
+    token terminator:sym<ang> { <?[>]> <?{ $*IN_REGEX_ASSERTION }> }
+    token terminator:sym<if>     { 'if'     <.kok> }
+    token terminator:sym<unless> { 'unless' <.kok> }
+    token terminator:sym<while>  { 'while'  <.kok> }
+    token terminator:sym<until>  { 'until'  <.kok> }
+    token terminator:sym<for>    { 'for'    <.kok> }
+    token terminator:sym<given>  { 'given'  <.kok> }
+    token terminator:sym<when>   { 'when'   <.kok> }
+    token terminator:sym<with>   { 'with'   <.kok> }
+    token terminator:sym<without> { 'without' <.kok> }
+    token terminator:sym<arrow>  { '-->' }
 
-    token pod_block:sym<paragraph_code> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=for' \h+ <pod-delim-code-typ> {}
-        :my $*POD_ALLOW_FCODES := 0;
-        :my $*POD_IN_CODE_BLOCK := 1;
-        <pod_configuration($<spaces>)> <pod_newline>
 
-        # TODO get first line if IN-DEFN-BLOCK
-        [ <!before \h* '=' \w> <pod_line> ]*
+    token stdstopper {
+        [
+        || <?MARKED('endstmt')> <?>
+        || [
+           | <?terminator>
+           | $
+           ]
+       ]
     }
 
-    # TODO make sure this token works in all desired
-    #      places: may have to remove the before/afters
-    #      when using with non-abbreviated blocks
-    #      (particulary code blocks)
-    token numbered-alias { <after [^|\s]> '#' <before \s> }
-    token pod_block:sym<abbreviated> {
-        # Note an abbreviated block does not have
-        # %config data, but see the hash mark
-        # handling below.
-        ^^
-        $<spaces> = [ \h* ]
-        '=' <!before begin || end || for || finish || config>
-        {
-            $*VMARGIN := $<spaces>.to - $<spaces>.from;
-        }
-        :my $*ALLOW_INLINE_CODE := 0;
-        [ :!ratchet
-            $<type> = [
-                <pod_code_parent> {
-                    $*ALLOW_INLINE_CODE := 1;
-                }
-                || <identifier>
-            ]
-            :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+    ## Statement control
 
-            # An optional hash char here is special.
-            [\h+ <numbered-alias>]?
+    proto rule statement_control { <...> }
 
-            [\h*\n|\h+]
-        ]
-        # TODO [defn, term], [first text, line numbered-alias]
-        # TODO exchange **0..1 for modern syntax
-        <pod_content=.pod_textcontent>**0..1
+    rule statement_control:sym<if> {
+        $<sym>=[if|with]<.kok> {}
+        <xblock(so ~$<sym>[0] ~~ /with/)>
+        [
+            [
+            | 'else'\h*'if' <.typed_panic: 'X::Syntax::Malformed::Elsif'>
+            | 'elif' { $/.typed_panic('X::Syntax::Malformed::Elsif', what => "elif") }
+            | $<sym>='elsif' <xblock>
+            | $<sym>='orwith' <xblock(1)>
+            ]
+        ]*
+        {}
+        [ 'else' <else=.pblock(so ~$<sym>[-1] ~~ /with/)> ]?
     }
 
-    token pod_block:sym<abbreviated_comment> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=comment' {}
-        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
-        [\h*\n|\h+]
-        $<pod_content> = [ \h* <!before '=' \w> \N+ [ \n | $ ] ]*
+    rule statement_control:sym<unless> {
+        $<sym>='unless'<.kok>
+        <xblock(0)> # 0 means we're not parsing `without`
+        [ <!before [els[e|if]|orwith]» >
+            || $<wrong-keyword>=[els[e|if]|orwith]» {}
+                <.typed_panic: 'X::Syntax::UnlessElse',
+                    keyword => ~$<wrong-keyword>,
+                >
+        ]
     }
 
-    token pod_block:sym<abbreviated_table> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=table' {}
-
-        # An optional hash char here is special.
-        [\h+ <numbered-alias>]?
+    rule statement_control:sym<without> {
+        $<sym>='without'<.kok>
+        <xblock(1)> # 1 means we're not parsing `unless`
+        [ <!before [els[e|if]|orwith]» >
+            || $<wrong-keyword>=[els[e|if]|orwith]» {}
+                <.typed_panic: 'X::Syntax::WithoutElse',
+                    keyword => ~$<wrong-keyword>,
+                >
+        ]
+    }
 
-        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
-        <pod_newline>
-        [ <!before \h* \n> <table_row>]*
+    rule statement_control:sym<while> {
+        $<sym>=[while|until]<.kok> {}
+        <xblock>
     }
 
-    token pod_block:sym<abbreviated_code> {
-        ^^
-        $<spaces> = [ \h* ]
-        '=' <pod-delim-code-typ> {}
-        :my $*POD_ALLOW_FCODES  := 0;
-        :my $*POD_IN_CODE_BLOCK := 1;
-
-        # An optional hash char here is special.
-        # For the code block, we want to eat any ws
-        # between the '#' and the next char
-        #$<numbered-alias>=[\h+ '#' \s]?
-        $<numbered-alias>=[\h+ '#' \s]?
-
-        [\h*\n|\h+]
-
-        [ <!before \h* '=' \w> <pod_line> ]*
+    rule statement_control:sym<repeat> {
+        <sym><.kok> {}
+        [
+        | $<wu>=[while|until]<.kok> <xblock>
+        | <pblock>
+          [$<wu>=['while'|'until']<.kok> || <.missing('"while" or "until"')>]
+          <EXPR>
+        ]
     }
 
-    # TODO exchange **1 for modern syntax
-    token pod_line { <pod_string>**1 [ <pod_newline> | $ ] }
-
-    token pod_newline {
-        \h* \n
+    rule statement_control:sym<for> {
+        <sym><.kok> {}
+        [ <?before 'my'? '$'\w+\s+'(' >
+            <.typed_panic: 'X::Syntax::P5'> ]?
+        [ <?before '(' <.EXPR>? ';' <.EXPR>? ';' <.EXPR>? ')' >
+            <.obs('C-style "for (;;)" loop', '"loop (;;)"')> ]?
+        <xblock(1)>
     }
 
-    # These parents can contain implicit code blocks when data
-    # lines begin with whitespace indention from the virtual
-    # margin.
-    token pod_code_parent {
+    rule statement_control:sym<whenever> {
+        <sym><.kok>
         [
-        | [ 'pod' | 'item' \d* | 'nested' | 'defn' | 'finish' ]
-        | <upper>+
+        || <?{
+              nqp::getcomp('perl6').language_version eq '6.c'
+            || $*WHENEVER_COUNT >= 0
+          }>
+        || <.typed_panic('X::Comp::WheneverOutOfScope')>
         ]
-        <![\w]>
+        { $*WHENEVER_COUNT++ }
+        <xblock(1)>
     }
 
-    token install_doc_phaser { <?> }
-
-    token vnum {
-        \w+ | '*'
+    rule statement_control:sym<foreach> {
+        <sym><.end_keyword> <.obs("'foreach'", "'for'")>
     }
 
-    token version {
-        <?before v\d+\w*> 'v' $<vstr>=[<vnum>+ % '.' '+'?]
-        <!before '-'|\'> # cheat because of LTM fail
+    token statement_control:sym<loop> {
+        <sym><.kok>
+        :s''
+        [ '('
+            [
+            <e1=.EXPR>? ';' <e2=.EXPR>? ';' <e3=.EXPR>?
+            || <.malformed('loop spec')>
+            ]
+        ')' ]?
+        <block>
     }
 
-    ## Top-level rules
-
-    token comp_unit {
-        # From STD.pm.
-        :my $*LEFTSIGIL;                           # sigil of LHS for item vs list assignment
-        :my $*SCOPE := '';                         # which scope declarator we're under
-        :my $*MULTINESS := '';                     # which multi declarator we're under
-        :my $*QSIGIL := '';                        # sigil of current interpolation
-        :my $*IN_META := '';                       # parsing a metaoperator like [..]
-        :my $*IN_REDUCE := 0;                      # attempting to parse an [op] construct
-        :my $*IN_DECL;                             # what declaration we're in
-        :my $*IN_RETURN := 0;                      # are we in a return?
-        :my $*HAS_SELF := '';                      # is 'self' available? (for $.foo style calls)
-        :my $*begin_compunit := 1;                 # whether we're at start of a compilation unit
-        :my $*DECLARAND;                           # the current thingy we're declaring, and subject of traits
-        :my $*CODE_OBJECT;                         # the code object we're currently inside
-        :my $*METHODTYPE;                          # the current type of method we're in, if any
-        :my $*PKGDECL;                             # what type of package we're in, if any
-        :my %*MYSTERY;                             # names we assume may be post-declared functions
-        :my $*BORG := {};                          # who gets blamed for a missing block
-        :my $*CCSTATE := '';
-        :my $*STRICT;
-        :my $*INVOCANT_OK := 0;
-        :my $*INVOCANT;
-        :my $*ARG_FLAT_OK := 0;
-        :my $*WHENEVER_COUNT := -1;                # -1 indicates whenever not valid here
-
-        # Error related. There are three levels: worry (just a warning), sorry
-        # (fatal but not immediately so) and panic (immediately deadly). There
-        # is a limit on the number of sorrows also. Unlike STD, which emits the
-        # textual messages as it goes, we keep track of the exception objects
-        # and, if needed, make a composite exception group.
-        :my @*WORRIES;                             # exception objects resulting from worry
-        :my @*SORROWS;                             # exception objects resulting from sorry
-        :my $*SORRY_LIMIT := 10;                   # when sorrow turns to panic
-
-        # Extras.
-        :my @*NQP_VIOLATIONS;                      # nqp::ops per line number
-        :my %*HANDLERS;                            # block exception handlers
-        :my $*IMPLICIT;                            # whether we allow an implicit param
-        :my $*HAS_YOU_ARE_HERE := 0;               # whether {YOU_ARE_HERE} has shown up
-        :my $*OFTYPE;
-        :my $*VMARGIN    := 0;                     # pod stuff
-        :my $*ALLOW_INLINE_CODE := 0;              # pod stuff
-        :my $*POD_IN_CODE_BLOCK := 0;              # pod stuff
-        :my $*POD_IN_FORMATTINGCODE := 0;          # pod stuff
-        :my $*POD_ALLOW_FCODES := 0b11111111111111111111111111; # allow which fcodes?
-        :my $*POD_ANGLE_COUNT := 0;                # pod stuff
-        :my $*IN_REGEX_ASSERTION := 0;
-        :my $*IN_PROTO := 0;                       # are we inside a proto?
-        :my $*NEXT_STATEMENT_ID := 1;              # to give each statement an ID
-        :my $*IN_STMT_MOD := 0;                    # are we inside a statement modifier?
-        :my $*COMPILING_CORE_SETTING := 0;         # are we compiling CORE.setting?
-        # TODO XXX: see https://github.com/rakudo/rakudo/issues/2432
-        :my $*SET_DEFAULT_LANG_VER := 1;
-        :my %*SIG_INFO;                            # information about recent signature
-
-        # Various interesting scopes we'd like to keep to hand.
-        :my $*GLOBALish;
-        :my $*PACKAGE;
-        :my $*UNIT;
-        :my $*UNIT_OUTER;
-        :my $*EXPORT;
-        # stack of packages, which the 'is export' needs
-        :my @*PACKAGES := [];
-
-        # A place for Pod
-        :my $*POD_BLOCKS := [];
-        :my $*POD_BLOCKS_SEEN := {};
-        :my $*POD_PAST;
-        :my $*DECLARATOR_DOCS;
-        :my $*PRECEDING_DECL; # for #= comments
-        :my $*PRECEDING_DECL_LINE := -1; # XXX update this when I see another comment like it?
-        # TODO use these vars to implement S26 pod data block handling
-        :my $*DATA-BLOCKS := [];
-        :my %*DATA-BLOCKS := {};
-
-        # Quasis and unquotes
-        :my $*IN_QUASI := 0;                       # whether we're currently in a quasi block
-        :my $*MAIN := 'MAIN';
-
-        # performance improvement stuff
-        :my $*FAKE_INFIX_FOUND := 0;
-
-        # for runaway detection
-        :my $*LASTQUOTE := [0,0];
-
+    rule statement_control:sym<need> {
+        <sym>
+        [
+        | <version> <.sorry('In case of using pragma, use "use" instead (e.g., "use v6;", "use v6.c;").')>
+        | <module_name>
+        ]+ % ','
         {
-            nqp::getcomp('perl6').reset_language_version();
-            $*W.loading_and_symbol_setup($/)
+            for $<module_name> {
+                my $lnd  := $*W.dissect_longname($_<longname>);
+                my $name := $lnd.name;
+                my %cp   := $lnd.colonpairs_hash('need');
+                $*W.load_module($/, $name, %cp, $*W.cur_lexpad);
+            }
         }
-
-        <.finishpad>
-        <.bom>?
-        <lang-version>
-        <statementlist=.FOREIGN_LANG($*MAIN, 'statementlist', 1)>
-
-        <.install_doc_phaser>
-
-        [ $ || <.typed_panic: 'X::Syntax::Confused'> ]
-
-        <.explain_mystery>
-        <.cry_sorrows>
-
-        { $*W.mop_up_and_check($/) }
     }
 
-    method clonecursor() {
-        my $new := self.'!cursor_init'(
-            self.orig(),
-            :p(self.pos()),
-            :shared(self.'!shared'()),
-            :braid(self."!braid"()."!clone"()));
-        $new;
+    token statement_control:sym<import> {
+        :my $*IN_DECL := 'import';
+        <sym> <.ws>
+        <module_name> [ <.spacey> <arglist> ]? <.ws>
+        :my $*HAS_SELF := '';
+        {
+            my $longname := $*W.dissect_longname($<module_name><longname>);
+            my $module;
+            my $found := 0;
+            try {
+                $module := $*W.find_symbol($longname.components());
+                $found := 1;
+            }
+            if $found {
+                # todo: fix arglist
+                $*W.do_import($/, $*W.find_symbol(<CompUnit Handle>).from-unit($module.WHO), $longname.name, $*W.arglist($/));
+            }
+            else {
+                $/.panic("Could not find module " ~ ~$<module_name> ~
+                    " to import symbols from");
+            }
+        }
     }
 
-    rule lang-version {
-        :my $comp := nqp::getcomp('perl6');
+    token statement_control:sym<no> {
+        :my $*IN_DECL := 'no';
+        :my $longname;
+        <sym> <.ws>
         [
-          <.ws>? 'use' <version> {} # <-- update $/ so we can grab $<version>
-          # we parse out the numeral, since we could have "6d"
-          :my $version := nqp::radix(10,$<version><vnum>[0],0,0)[0];
-          [
-          ||  <?{ $version == 6 }> { $*W.load-lang-ver: $<version>, $comp }
-          ||  { $/.typed_panic: 'X::Language::Unsupported',
-                  version => ~$<version> }
-          ]
-        || {
-              # This is the path we take when the user did not
-              # provide any `use v6.blah` lang version statement
-              $*W.load-lang-ver: 'v6', $comp if $*SET_DEFAULT_LANG_VER;
-          }
+        | <module_name> [ <.spacey> <arglist> ]? <.explain_mystery> <.cry_sorrows>
+            { $*W.do_pragma_or_load_module($/,0) }
         ]
-    }
-
-    rule statementlist($*statement_level = 0) {
-        :my $*LANG;
-        :my $*LEAF;
-        :my %*LANG   := self.shallow_copy(self.slangs);   # XXX deprecated
-        :my $*STRICT := nqp::getlexdyn('$*STRICT');
-
-        :dba('statement list')
-#        <.check_LANG_oopsies('statementlist')>
         <.ws>
-        # Define this scope to be a new language.
-        <!!{ $*LANG := $*LEAF := $/.clone_braid_from(self); 1 }>
-        [
-        | $
-        | <?before <.[\)\]\}]>>
-        | [ <statement> <.eat_terminator> ]*
-        ]
-        <.set_braid_from(self)>   # any language tweaks must not escape
-        <!!{ nqp::rebless($/, self.WHAT); 1 }>
     }
 
-    method shallow_copy(%hash) {
-        my %result;
-        for %hash {
-            %result{$_.key} := $_.value;
-        }
-        %result
-    }
-
-    rule semilist {
-        :dba('list composer')
-        ''
+    token statement_control:sym<use> {
+        :my $longname;
+        :my $*IN_DECL := 'use';
+        :my $*HAS_SELF := '';
+        :my $*SCOPE   := 'use';
+        :my $OLD_MAIN := ~$*MAIN;
+        :my %*MYSTERY;
+        $<doc>=[ 'DOC' \h+ ]**0..1
+        <sym> <.ws>
         [
-        | <?before <.[)\]}]> >
-        | [<statement><.eat_terminator> ]*
+        | <version>
+            { $/.typed_panic: 'X::Language::TooLate', version => ~$<version> }
+        | <module_name>
+            [
+            || <.spacey> <arglist> <.cheat_heredoc>? <?{ $<arglist><EXPR> }> <.explain_mystery> <.cry_sorrows>
+                {
+                    my $oldmain := %*LANG<MAIN>;
+                    $*W.do_pragma_or_load_module($/,1);
+                    $¢ := $*LANG;
+                    if nqp::istype($oldmain, %*LANG<MAIN>.WHAT) {
+                        %*LANG := self.shallow_copy($*LANG.slangs);
+                    }
+                    else {
+                        $/.check_LANG_oopsies('use');
+                    }
+                }
+            || {
+                    unless ~$<doc> && !%*COMPILING<%?OPTIONS><doc> {
+                        my $oldmain := %*LANG<MAIN>;
+                        $*W.do_pragma_or_load_module($/,1);
+                        $¢ := $*LANG;
+                        if nqp::istype($oldmain, %*LANG<MAIN>.WHAT) {
+                            %*LANG := self.shallow_copy($*LANG.slangs);
+                        }
+                        else {
+                            $/.check_LANG_oopsies('use');
+                        }
+                    }
+                }
+            ]
         ]
+        [ <?{ $*MAIN ne $OLD_MAIN }>
+          <.eat_terminator>
+          <statementlist=.FOREIGN_LANG($*MAIN, 'statementlist', 1)>
+        || <?> ]
+        <.ws>
     }
 
-    rule sequence {
-        :dba('sequence of statements')
-        ''
-        [
-        | <?before <.[)\]}]> >
-        | [<statement><.eat_terminator> ]*
-        ]
-    }
+    # This is like HLL::Grammar.LANG but it allows to call a token of a Perl 6 level grammar.
+    method FOREIGN_LANG($langname, $regex, *@args) {
+        my $grammar := self.slang_grammar($langname);
+        if nqp::istype($grammar, NQPMatch) {
+            self.LANG($langname, $regex, @args);
+        }
+        else {
+            my $Str := $*W.find_symbol(['Str']);
+            my $actions := self.slang_actions($langname);
+            my $lang_cursor := $grammar.'!cursor_init'($Str.new( :value(self.orig())), :p(self.pos()));
+            $lang_cursor.clone_braid_from(self);
+            $lang_cursor.set_actions($actions);
+            if self.HOW.traced(self) {
+                $lang_cursor.HOW.trace-on($lang_cursor, self.HOW.trace_depth(self));
+            }
+            my $ret := $lang_cursor."$regex"(|@args);
 
-    token label {
-        <identifier> ':' <?[\s]> <.ws>
-        {
-            $*LABEL := ~$<identifier>;
-            if $*W.already_declared('my', self.package, $*W.cur_lexpad(), [$*LABEL]) {
-                $*W.throw($/, ['X', 'Redeclaration'], symbol => $*LABEL);
+            # Build up something NQP-levelish we can return.
+            my $new := NQPMatch.'!cursor_init'(self.orig(), :p(self.pos()), :shared(self.'!shared'()));
+            my $p6cursor := $*W.find_symbol(['Match']);
+            nqp::bindattr_i($new, NQPMatch, '$!from',  nqp::getattr_i($ret, $p6cursor, '$!from'));
+            nqp::bindattr_i($new, NQPMatch, '$!pos',   nqp::getattr_i($ret, $p6cursor, '$!pos'));
+            my str $p6c_name := nqp::getattr_s($ret, $p6cursor, '$!name');
+            if !nqp::isnull_s($p6c_name) {
+                nqp::bindattr($new,   NQPMatch, '$!name',  $p6c_name);
             }
-            my str $orig      := self.orig();
-            my int $total     := nqp::chars($orig);
-            my int $from      := self.MATCH.from();
-            my int $to        := self.MATCH.to() + nqp::chars($*LABEL);
-            my int $line      := HLL::Compiler.lineof($orig, self.from(), :cache(1));
-            my str $prematch  := nqp::substr($orig, $from > 20 ?? $from - 20 !! 0, $from > 20 ?? 20 !! $from);
-            my str $postmatch := nqp::substr($orig, $to, 20);
-            my $label     := $*W.find_symbol(['Label']).new( :name($*LABEL), :$line, :$prematch, :$postmatch );
-            $*W.add_object_if_no_sc($label);
-            $*W.install_lexical_symbol($*W.cur_lexpad(), $*LABEL, $label);
+            nqp::bindattr($new, NQPMatch, '$!made', nqp::getattr($ret, $p6cursor, '$!made'));
+            $new.MATCH;
+            $new.set_braid_from(self)
         }
     }
 
-    token statement($*LABEL = '') {
-        :my $*QSIGIL := '';
-        :my $*SCOPE := '';
-
-        # NOTE: annotations that use STATEMENT_ID often also need IN_STMT_MOD annotation, in order
-        # to correctly migrate QAST::Blocks in constructs inside topics of statement modifiers
-        :my $*STATEMENT_ID := $*NEXT_STATEMENT_ID++;
-        :my $*IN_STMT_MOD := nqp::getlexdyn('$*IN_STMT_MOD');
-
-        :my $*ESCAPEBLOCK := 0;
-        :my $actions := self.slang_actions('MAIN');
-        <!!{ $/.set_actions($actions); 1 }>
-        <!before <.[\])}]> | $ >
-        <!stopper>
-        <!!{ nqp::rebless($/, self.slang_grammar('MAIN')); 1 }>
+    rule statement_control:sym<require> {
+        <sym>
         [
-        | <label> <statement($*LABEL)> { $*LABEL := '' if $*LABEL }
-        | <statement_control>
-        | <EXPR> :dba('statement end') { $*IN_STMT_MOD := 1 }
-            [
-            || <?MARKED('endstmt')>
-            || :dba('statement modifier') <.ws> <statement_mod_cond> <statement_mod_loop>?
-            || :dba('statement modifier loop') <.ws> <statement_mod_loop>
-                {
-                    my $sp := $<EXPR><statement_prefix>;
-                    if $sp && $sp<sym> eq 'do' {
-                        my $s := $<statement_mod_loop><sym>;
-                        $/.obs("do..." ~ $s, "repeat...while or repeat...until")
-                          unless $*LANG.pragma('p5isms');
-                    }
-                }
-            ]?
-        | <?[;]>
-        | <?stopper>
-        | {} <.panic: "Bogus statement">
+        | <module_name>
+        | <file=.variable>
+        | <!sigil> <file=.term>
         ]
+        <EXPR>?
     }
 
-    token eat_terminator {
-        || ';'
-        || <?MARKED('endstmt')> <.ws>
-        || <?before ')' | ']' | '}' >
-        || $
-        || <?stopper>
-        || <?before [if|while|for|loop|repeat|given|when] » > { $/.'!clear_highwater'(); self.typed_panic( 'X::Syntax::Confused', reason => "Missing semicolon" ) }
-        || { $/.typed_panic( 'X::Syntax::Confused', reason => "Confused" ) }
+    rule statement_control:sym<given> {
+        <sym><.kok> <xblock(1)>
     }
-
-    token xblock($*IMPLICIT = 0) {
-        :my $*GOAL := '{';
-        :my $*BORG := {};
-        <EXPR> <.ws> <pblock($*IMPLICIT)>
+    rule statement_control:sym<when> {
+        <sym><.kok> <xblock>
     }
-
-    token pblock($*IMPLICIT = 0) {
-        :my $*DECLARAND := $*W.stub_code_object('Block');
-        :my $*CODE_OBJECT := $*DECLARAND;
-        :my $*SIG_OBJ;
-        :my %*SIG_INFO;
-        :my $*POD_BLOCK;
-        :my $*DOC := $*DECLARATOR_DOCS;
-        :my $*LINE_NO := HLL::Compiler.lineof(self.orig(), self.from(), :cache(1));
-        :my $*FATAL := self.pragma('fatal');  # can also be set inside statementlist
-        {
-            $*DECLARATOR_DOCS := '';
-
-            if $*PRECEDING_DECL_LINE < $*LINE_NO {
-                $*PRECEDING_DECL_LINE := $*LINE_NO;
-                $*PRECEDING_DECL := $*DECLARAND;
-            }
-        }
-        <.attach_leading_docs>
-        :dba('block or pointy block')
-        :my $borg := $*BORG;
-        :my $has_mystery := $*MYSTERY ?? 1 !! 0;
-        { $*BORG := {} }
-        [
-        | <lambda>
-            <.newpad>
-            :my $*SCOPE := 'my';
-            :my $*GOAL := '{';
-            <signature> {
-                %*SIG_INFO := $<signature>.ast;
-                $*SIG_OBJ := $*W.create_signature_and_params($<signature>,
-                    %*SIG_INFO, $*W.cur_lexpad(), 'Mu', :rw($<lambda> eq '<->'));
-            }
-            <blockoid>
-        | <?[{]>
-            <.newpad>
-            <blockoid>
-        || <.missing_block($borg, $has_mystery)>
-        ]
+    rule statement_control:sym<default> {
+        <sym><.kok> <block>
     }
 
-    token lambda { '->' | '<->' }
+    rule statement_control:sym<CATCH> {<sym> <block(1)> }
+    rule statement_control:sym<CONTROL> {<sym> <block(1)> }
+    rule statement_control:sym<QUIT> {<sym> <block(1)> }
 
-    token block($*IMPLICIT = 0) {
-        :my $*DECLARAND := $*W.stub_code_object('Block');
-        :my $*CODE_OBJECT := $*DECLARAND;
-        :dba('scoped block')
-        :my $borg := $*BORG;
-        :my $has_mystery := $*MYSTERY ?? 1 !! 0;
-        :my $*FATAL := self.pragma('fatal');  # can also be set inside statementlist
-        { $*BORG := {} }
-        [ <?[{]> || <.missing_block($borg, $has_mystery)>]
-        <.newpad>
-        <blockoid>
-    }
+    proto token statement_prefix { <...> }
+    token statement_prefix:sym<BEGIN>   { :my %*MYSTERY; <sym><.kok> <blorst> <.explain_mystery> <.cry_sorrows> }
+    token statement_prefix:sym<COMPOSE> { <sym><.kok> <blorst> }
+    token statement_prefix:sym<TEMP>    { <sym><.kok> <blorst> }
+    token statement_prefix:sym<CHECK>   { <sym><.kok> <blorst> }
+    token statement_prefix:sym<INIT>    { <sym><.kok> <blorst> }
+    token statement_prefix:sym<ENTER>   { <sym><.kok> <blorst> }
+    token statement_prefix:sym<FIRST>   { <sym><.kok> <blorst> }
 
-    token blockoid {
-        :my $*CURPAD;
-        :my %*HANDLERS;
-        <.finishpad>
-        :my $borg := $*BORG;
-        :my $has_mystery := $*MYSTERY ?? 1 !! 0;
-        { $*BORG := {} }
+    token statement_prefix:sym<END>   { <sym><.kok> <blorst> }
+    token statement_prefix:sym<LEAVE> { <sym><.kok> <blorst> }
+    token statement_prefix:sym<KEEP>  { <sym><.kok> <blorst> }
+    token statement_prefix:sym<UNDO>  { <sym><.kok> <blorst> }
+    token statement_prefix:sym<NEXT>  { <sym><.kok> <blorst> }
+    token statement_prefix:sym<LAST>  { <sym><.kok> <blorst> }
+    token statement_prefix:sym<PRE>   { <sym><.kok> <blorst> }
+    token statement_prefix:sym<POST>  { <sym><.kok> <blorst> }
+    token statement_prefix:sym<CLOSE> { <sym><.kok> <blorst> }
+
+    token statement_prefix:sym<race> {
+        <sym><.kok>
         [
-        | '{YOU_ARE_HERE}' <you_are_here>
-        | :dba('block')
-            '{'
-            <!!{ $*VARIABLE := '' if $*VARIABLE; 1 }>
-            <statementlist(1)>
-            [<.cheat_heredoc> || '}']
-            <?ENDSTMT>
-        || <.missing_block($borg, $has_mystery)>
+        | <?before 'for' <.kok>> <for=.statement_control>
+        | <blorst>
         ]
-        { $*CURPAD := $*W.pop_lexpad() }
     }
-
-    token unitstart { <?> }
-    token you_are_here {
-        <?{ nqp::getlexdyn('$?FILES') ~~ /\.setting$/ }> ||
-            { self.typed_panic('X::Syntax::Reserved',
-                reserved => 'use of {YOU_ARE_HERE} outside of a setting',
-                instead => ' (use whitespace if not a setting, or rename file with .setting extension?)');
-            }
+    token statement_prefix:sym<hyper> {
+        <sym><.kok>
+        [
+        | <?before 'for' <.kok>> <for=.statement_control>
+        | <blorst>
+        ]
     }
-    token newpad { <?> { $*W.push_lexpad($/) } }
-    token newthunk { <?> { $*W.push_thunk($/) } }
-    token finishpad { <?> }
+    token statement_prefix:sym<lazy> {
+        <sym><.kok>
+        [
+        | <?before 'for' <.kok>> <for=.statement_control>
+        | <blorst>
+        ]
+    }
+    token statement_prefix:sym<eager>   { <sym><.kok> <blorst> }
+    token statement_prefix:sym<sink>    { <sym><.kok> <blorst> }
+    token statement_prefix:sym<try>     {
+        :my $*FATAL := 1;
+        <!!{ $/.clone_braid_from(self).set_pragma('fatal',1); }>
+        <sym><.kok> <blorst>
+        <.set_braid_from(self)>
 
-    token bom { \xFEFF }
+    }
+    token statement_prefix:sym<quietly> { <sym><.kok> <blorst> }
+    token statement_prefix:sym<gather>  { <sym><.kok> <blorst> }
+    token statement_prefix:sym<once>    { <sym><.kok> <blorst> }
+    token statement_prefix:sym<start>   { <sym><.kok> <blorst> }
+    token statement_prefix:sym<supply>  {
+        :my $*WHENEVER_COUNT := 0;
+        <sym><.kok> <blorst>
+    }
+    token statement_prefix:sym<react>   {
+        :my $*WHENEVER_COUNT := 0;
+        <sym><.kok> <blorst>
+    }
+    token statement_prefix:sym<do>      { <sym><.kok> <blorst> }
+    token statement_prefix:sym<DOC>     {
+        <sym><.kok> $<phase>=['BEGIN' || 'CHECK' || 'INIT']<.end_keyword><.ws>
+        <blorst>
+    }
 
-    proto token terminator { <...> }
+    token blorst {
+        [ <?[{]> <block> | <![;]> <statement> <.cheat_heredoc>? || <.missing: 'block or statement'> ]
+    }
 
-    token terminator:sym<;> { <?[;]> }
-    token terminator:sym<)> { <?[)]> }
-    token terminator:sym<]> { <?[\]]> }
-    token terminator:sym<}> { <?[}]> }
-    token terminator:sym<ang> { <?[>]> <?{ $*IN_REGEX_ASSERTION }> }
-    token terminator:sym<if>     { 'if'     <.kok> }
-    token terminator:sym<unless> { 'unless' <.kok> }
-    token terminator:sym<while>  { 'while'  <.kok> }
-    token terminator:sym<until>  { 'until'  <.kok> }
-    token terminator:sym<for>    { 'for'    <.kok> }
-    token terminator:sym<given>  { 'given'  <.kok> }
-    token terminator:sym<when>   { 'when'   <.kok> }
-    token terminator:sym<with>   { 'with'   <.kok> }
-    token terminator:sym<without> { 'without' <.kok> }
-    token terminator:sym<arrow>  { '-->' }
+    ## Statement modifiers
 
+    proto rule statement_mod_cond { <...> }
 
-    token stdstopper {
-        [
-        || <?MARKED('endstmt')> <?>
-        || [
-           | <?terminator>
-           | $
-           ]
-       ]
+    method nomodexpr($k) {
+        self.'!clear_highwater'();
+        self.typed_panic( 'X::Syntax::Confused', reason => "Missing expression for '$k' statement modifier" );
+        self;
     }
+    token modifier_expr($k) { <EXPR> || <.nomodexpr($k)> }
+    token smexpr($k)        { <EXPR> || <.nomodexpr($k)> }
 
-    ## Statement control
+    rule statement_mod_cond:sym<if>     { <sym><.kok> <modifier_expr('if')> }
+    rule statement_mod_cond:sym<unless> { <sym><.kok> <modifier_expr('unless')> }
+    rule statement_mod_cond:sym<when>   { <sym><.kok> <modifier_expr('when')> }
+    rule statement_mod_cond:sym<with>   { <sym><.kok> <modifier_expr('with')> }
+    rule statement_mod_cond:sym<without>{ <sym><.kok> <modifier_expr('without')> }
 
-    proto rule statement_control { <...> }
+    proto rule statement_mod_loop { <...> }
 
-    rule statement_control:sym<if> {
-        $<sym>=[if|with]<.kok> {}
-        <xblock(so ~$<sym>[0] ~~ /with/)>
-        [
-            [
-            | 'else'\h*'if' <.typed_panic: 'X::Syntax::Malformed::Elsif'>
-            | 'elif' { $/.typed_panic('X::Syntax::Malformed::Elsif', what => "elif") }
-            | $<sym>='elsif' <xblock>
-            | $<sym>='orwith' <xblock(1)>
-            ]
-        ]*
-        {}
-        [ 'else' <else=.pblock(so ~$<sym>[-1] ~~ /with/)> ]?
-    }
+    rule statement_mod_loop:sym<while> { <sym><.kok> <smexpr('while')> }
+    rule statement_mod_loop:sym<until> { <sym><.kok> <smexpr('until')> }
+    rule statement_mod_loop:sym<for>   { <sym><.kok> <smexpr('for')> }
+    rule statement_mod_loop:sym<given> { <sym><.kok> <smexpr('given')> }
 
-    rule statement_control:sym<unless> {
-        $<sym>='unless'<.kok>
-        <xblock(0)> # 0 means we're not parsing `without`
-        [ <!before [els[e|if]|orwith]» >
-            || $<wrong-keyword>=[els[e|if]|orwith]» {}
-                <.typed_panic: 'X::Syntax::UnlessElse',
-                    keyword => ~$<wrong-keyword>,
-                >
-        ]
+    ## Terms
+
+    token term:sym<fatarrow>           { <fatarrow> }
+    token term:sym<colonpair>          { <colonpair> }
+    token term:sym<variable>           { <variable> { $*VAR := $<variable> unless $*VAR; } }  # maybe desigilname already set it
+    token term:sym<package_declarator> { <package_declarator> }
+    token term:sym<scope_declarator>   { <scope_declarator> }
+    token term:sym<routine_declarator> { <routine_declarator> }
+    token term:sym<multi_declarator>   { <?before 'multi'|'proto'|'only'> <multi_declarator> }
+    token term:sym<regex_declarator>   { <regex_declarator> }
+    token term:sym<circumfix>          { <circumfix> }
+    token term:sym<statement_prefix>   { <statement_prefix> }
+    token term:sym<**>                 { <sym> }
+    token term:sym<*>                  { <sym> }
+    token term:sym<lambda>             { <?lambda> <pblock> {$*BORG<block> := $<pblock> } }
+    token term:sym<type_declarator>    { <type_declarator> }
+    token term:sym<value>              { <value> }
+    token term:sym<unquote>            { '{{{' <?{ $*IN_QUASI }> <statementlist> '}}}' }
+    token term:sym<!!>                 { '!!' <?before \s> }  # actual error produced inside infix:<?? !!>
+
+    token term:sym<::?IDENT> {
+        $<sym> = [ '::?' <identifier> ] »
+    }
+    token term:sym<p5end> {
+        << __END__ >>
+        <.obs('__END__ as end of code',
+          'the =finish pod marker and $=finish to read')>
+    }
+    token term:sym<p5data> {
+        << __DATA__ >>
+        <.obs('__DATA__ as start of data',
+          'the =finish pod marker and $=finish to read')>
     }
 
-    rule statement_control:sym<without> {
-        $<sym>='without'<.kok>
-        <xblock(1)> # 1 means we're not parsing `unless`
-        [ <!before [els[e|if]|orwith]» >
-            || $<wrong-keyword>=[els[e|if]|orwith]» {}
-                <.typed_panic: 'X::Syntax::WithoutElse',
-                    keyword => ~$<wrong-keyword>,
-                >
+    token infix:sym<lambda> {
+        <?before '{' | <.lambda> > <!{ $*IN_META }> {
+            my $needparens := 0;
+            my $pos := $/.from;
+            my $line := HLL::Compiler.lineof($/.orig, $/.from, :cache(1));
+            my $lex := $*W.cur_lexpad();
+            for 'if', 'unless', 'while', 'until', 'for', 'given', 'when', 'loop', 'sub', 'method', 'with', 'without', 'supply', 'whenever', 'react' {
+                $needparens++ if $_ eq 'loop';
+                my $m := %*MYSTERY{$_ ~ '-' ~ $lex.cuid};
+                next unless $m;
+                my $m_pos  := $m<pos>[nqp::elems($m<pos>) - 1];
+                my $m_line := HLL::Compiler.lineof($/.orig, $m_pos, :cache(1));
+                if $line - $m_line < 5 {
+                    if $m<ctx> eq '(' {
+                        $/.'!clear_highwater'();
+                        $/.'!cursor_pos'($m_pos);
+                        $/.typed_sorry('X::Syntax::KeywordAsFunction',
+                                word => $_,
+                                :$needparens,
+                        );
+                        $/.'!cursor_pos'($pos);
+                        $/.panic("Unexpected block in infix position (two terms in a row)");
+                    }
+                    else {
+                        $/.'!clear_highwater'();
+                        $/.'!cursor_pos'($m_pos);
+                        $/.sorry("Word '$_' interpreted as a listop; please use 'do $_' to introduce the statement control word");
+                        $/.'!cursor_pos'($pos);
+                        $/.panic("Unexpected block in infix position (two terms in a row)");
+                    }
+                }
+            }
+        }
+        [
+        || <!{ $*IN_REDUCE }> {
+            $/.panic("Unexpected block in infix position (missing statement control word before the expression?)");
+        }
+        || <!>
         ]
     }
 
-    rule statement_control:sym<while> {
-        $<sym>=[while|until]<.kok> {}
-        <xblock>
+    token term:sym<undef> {
+        <!{ $*LANG.pragma('p5isms') }>
+        <sym> >> {}
+        [ <?before \h*'$/' >
+            <.obs('$/ variable as input record separator',
+                 "the filehandle's .slurp method")>
+        ]?
+        [ <?before [ '(' || \h*<.sigil><.twigil>?\w ] >
+            <.obs('undef as a verb', 'undefine() or assignment of Nil')>
+        ]?
+        <.obs('undef as a value', "something more specific:\n\tan undefined type object such as Any or Int,\n\t:!defined as a matcher,\n\tAny:U as a type constraint,\n\tNil as the absence of an expected value\n\tor fail() as a failure return\n\t   ")>
     }
 
-    rule statement_control:sym<repeat> {
-        <sym><.kok> {}
-        [
-        | $<wu>=[while|until]<.kok> <xblock>
-        | <pblock>
-          [$<wu>=['while'|'until']<.kok> || <.missing('"while" or "until"')>]
-          <EXPR>
-        ]
+    token term:sym<new> {
+        <!{ $*LANG.pragma('c++isms') }>
+        'new' \h+ <longname> \h* <![:]> <.obs("C++ constructor syntax", "method call syntax", :ism<c++isms>)>
     }
 
-    rule statement_control:sym<for> {
-        <sym><.kok> {}
-        [ <?before 'my'? '$'\w+\s+'(' >
-            <.typed_panic: 'X::Syntax::P5'> ]?
-        [ <?before '(' <.EXPR>? ';' <.EXPR>? ';' <.EXPR>? ')' >
-            <.obs('C-style "for (;;)" loop', '"loop (;;)"')> ]?
-        <xblock(1)>
+    token fatarrow {
+        <key=.identifier> \h* '=>' <.ws> <val=.EXPR('i<=')>
     }
 
-    rule statement_control:sym<whenever> {
-        <sym><.kok>
+    token coloncircumfix($front) {
+        # reset $*IN_DECL in case this colonpair is part of var we're
+        # declaring, since colonpair might have other vars. Don't make those
+        # think we're declaring them
+        :my $*IN_DECL := '';
         [
-        || <?{
-              nqp::getcomp('perl6').language_version eq '6.c'
-            || $*WHENEVER_COUNT >= 0
-          }>
-        || <.typed_panic('X::Comp::WheneverOutOfScope')>
+        | '<>' <.worry("Pair with <> really means an empty list, not null string; use :$front" ~ "('') to represent the null string,\n  or :$front" ~ "() to represent the empty list more accurately")>
+        | {} <circumfix>
         ]
-        { $*WHENEVER_COUNT++ }
-        <xblock(1)>
     }
 
-    rule statement_control:sym<foreach> {
-        <sym><.end_keyword> <.obs("'foreach'", "'for'")>
-    }
+    token colonpair {
+        :my $*key;
+        :my $*value;
 
-    token statement_control:sym<loop> {
-        <sym><.kok>
-        :s''
-        [ '('
+        ':'
+        :dba('colon pair')
+        [
+        | '!' [ <identifier> || <.panic: "Malformed False pair; expected identifier"> ]
+            [ <[ \[ \( \< \{ ]> {
+            $/.typed_panic('X::Syntax::NegatedPair', key => ~$<identifier>) } ]?
+            { $*key := $<identifier>.Str; $*value := 0; }
+        | $<num> = [\d+] <identifier> [ <?before <.[ \[ \( \< \{ ]>> {} <.sorry("Extra argument not allowed; pair already has argument of " ~ $<num>.Str)> <.circumfix> ]?
+            <?{
+                # Here we go over each character in the numeral and check $ch.chr eq $ch.ord.chr
+                # to fail any matches that have synthetics, such as 7\x[308]
+                my $num       := ~$<num>;
+                my $chars-num := nqp::chars($num);
+                my $pos       := -1;
+                nqp::while(
+                    nqp::islt_i( ($pos := nqp::add_i($pos, 1)), $chars-num )
+                    && nqp::eqat(
+                        $num,
+                        nqp::chr( nqp::ord($num, $pos) ),
+                        $pos,
+                    ),
+                    nqp::null,
+                );
+                nqp::iseq_i($chars-num, $pos);
+            }>
+            { $*key := $<identifier>.Str; $*value := nqp::radix_I(10, $<num>, 0, 0, $*W.find_symbol(['Int']))[0]; }
+        | <identifier>
+            { $*key := $<identifier>.Str; }
             [
-            <e1=.EXPR>? ';' <e2=.EXPR>? ';' <e3=.EXPR>?
-            || <.malformed('loop spec')>
+            || <.unsp>? :dba('pair value') <coloncircumfix($*key)> { $*value := $<coloncircumfix>; }
+            || { $*value := 1; }
             ]
-        ')' ]?
-        <block>
+        | :dba('signature') '(' ~ ')' <fakesignature>
+        | <coloncircumfix('')>
+            { $*key := ""; $*value := $<coloncircumfix>; }
+        | <var=.colonpair_variable>
+            { $*key := $<var><desigilname>.Str; $*value := $<var>; self.check_variable($*value); }
+        ]
     }
 
-    rule statement_control:sym<need> {
-        <sym>
+    token colonpair_variable {
+        <sigil> {}
         [
-        | <version> <.sorry('In case of using pragma, use "use" instead (e.g., "use v6;", "use v6.c;").')>
-        | <module_name>
-        ]+ % ','
-        {
-            for $<module_name> {
-                my $lnd  := $*W.dissect_longname($_<longname>);
-                my $name := $lnd.name;
-                my %cp   := $lnd.colonpairs_hash('need');
-                $*W.load_module($/, $name, %cp, $*W.cur_lexpad);
-            }
-        }
+        | <twigil>? <desigilname>
+        | $<capvar>='<' <desigilname> '>'
+        ]
     }
 
-    token statement_control:sym<import> {
-        :my $*IN_DECL := 'import';
-        <sym> <.ws>
-        <module_name> [ <.spacey> <arglist> ]? <.ws>
-        :my $*HAS_SELF := '';
-        {
-            my $longname := $*W.dissect_longname($<module_name><longname>);
-            my $module;
-            my $found := 0;
-            try {
-                $module := $*W.find_symbol($longname.components());
-                $found := 1;
-            }
-            if $found {
-                # todo: fix arglist
-                $*W.do_import($/, $*W.find_symbol(<CompUnit Handle>).from-unit($module.WHO), $longname.name, $*W.arglist($/));
-            }
-            else {
-                $/.panic("Could not find module " ~ ~$<module_name> ~
-                    " to import symbols from");
-            }
-        }
+    proto token special_variable { <...> }
+
+    token special_variable:sym<$!{ }> {
+        [ '$!{' .*? '}' | '%!' ]
+        <.obsvar('%!')>
     }
 
-    token statement_control:sym<no> {
-        :my $*IN_DECL := 'no';
-        :my $longname;
-        <sym> <.ws>
-        [
-        | <module_name> [ <.spacey> <arglist> ]? <.explain_mystery> <.cry_sorrows>
-            { $*W.do_pragma_or_load_module($/,0) }
-        ]
-        <.ws>
+    token special_variable:sym<$`> {
+        <sym>  <?before \s | ',' | <.terminator> >
+        <.obsvar('$`')>
     }
 
-    token statement_control:sym<use> {
-        :my $longname;
-        :my $*IN_DECL := 'use';
-        :my $*HAS_SELF := '';
-        :my $*SCOPE   := 'use';
-        :my $OLD_MAIN := ~$*MAIN;
-        :my %*MYSTERY;
-        $<doc>=[ 'DOC' \h+ ]**0..1
-        <sym> <.ws>
-        [
-        | <version>
-            { $/.typed_panic: 'X::Language::TooLate', version => ~$<version> }
-        | <module_name>
-            [
-            || <.spacey> <arglist> <.cheat_heredoc>? <?{ $<arglist><EXPR> }> <.explain_mystery> <.cry_sorrows>
-                {
-                    my $oldmain := %*LANG<MAIN>;
-                    $*W.do_pragma_or_load_module($/,1);
-                    $¢ := $*LANG;
-                    if nqp::istype($oldmain, %*LANG<MAIN>.WHAT) {
-                        %*LANG := self.shallow_copy($*LANG.slangs);
-                    }
-                    else {
-                        $/.check_LANG_oopsies('use');
-                    }
-                }
-            || {
-                    unless ~$<doc> && !%*COMPILING<%?OPTIONS><doc> {
-                        my $oldmain := %*LANG<MAIN>;
-                        $*W.do_pragma_or_load_module($/,1);
-                        $¢ := $*LANG;
-                        if nqp::istype($oldmain, %*LANG<MAIN>.WHAT) {
-                            %*LANG := self.shallow_copy($*LANG.slangs);
-                        }
-                        else {
-                            $/.check_LANG_oopsies('use');
-                        }
-                    }
-                }
-            ]
-        ]
-        [ <?{ $*MAIN ne $OLD_MAIN }>
-          <.eat_terminator>
-          <statementlist=.FOREIGN_LANG($*MAIN, 'statementlist', 1)>
-        || <?> ]
-        <.ws>
+    token special_variable:sym<$@> {
+        <sym> <[ \s ; , ) ]> .
+        <.obsvar('$@')>
     }
 
-    # This is like HLL::Grammar.LANG but it allows to call a token of a Perl 6 level grammar.
-    method FOREIGN_LANG($langname, $regex, *@args) {
-        my $grammar := self.slang_grammar($langname);
-        if nqp::istype($grammar, NQPMatch) {
-            self.LANG($langname, $regex, @args);
-        }
-        else {
-            my $Str := $*W.find_symbol(['Str']);
-            my $actions := self.slang_actions($langname);
-            my $lang_cursor := $grammar.'!cursor_init'($Str.new( :value(self.orig())), :p(self.pos()));
-            $lang_cursor.clone_braid_from(self);
-            $lang_cursor.set_actions($actions);
-            if self.HOW.traced(self) {
-                $lang_cursor.HOW.trace-on($lang_cursor, self.HOW.trace_depth(self));
-            }
-            my $ret := $lang_cursor."$regex"(|@args);
+    token special_variable:sym<$#> {
+        <sym> <identifier>
+        {}
+        <.obsvar('$#', ~$<identifier>)>
+    }
 
-            # Build up something NQP-levelish we can return.
-            my $new := NQPMatch.'!cursor_init'(self.orig(), :p(self.pos()), :shared(self.'!shared'()));
-            my $p6cursor := $*W.find_symbol(['Match']);
-            nqp::bindattr_i($new, NQPMatch, '$!from',  nqp::getattr_i($ret, $p6cursor, '$!from'));
-            nqp::bindattr_i($new, NQPMatch, '$!pos',   nqp::getattr_i($ret, $p6cursor, '$!pos'));
-            my str $p6c_name := nqp::getattr_s($ret, $p6cursor, '$!name');
-            if !nqp::isnull_s($p6c_name) {
-                nqp::bindattr($new,   NQPMatch, '$!name',  $p6c_name);
-            }
-            nqp::bindattr($new, NQPMatch, '$!made', nqp::getattr($ret, $p6cursor, '$!made'));
-            $new.MATCH;
-            $new.set_braid_from(self)
-        }
+    token special_variable:sym<$$> {
+        <sym> \W
+        <.obsvar('$$')>
     }
 
-    rule statement_control:sym<require> {
-        <sym>
-        [
-        | <module_name>
-        | <file=.variable>
-        | <!sigil> <file=.term>
-        ]
-        <EXPR>?
+    token special_variable:sym<$&> {
+        <sym> <?before \s | ',' | <.terminator> >
+        <.obsvar('$&')>
     }
 
-    rule statement_control:sym<given> {
-        <sym><.kok> <xblock(1)>
+    token special_variable:sym<@+> {
+        <sym> <?before \s | ',' | <.terminator> >
+        <.obsvar('@+')>
     }
-    rule statement_control:sym<when> {
-        <sym><.kok> <xblock>
+
+    token special_variable:sym<%+> {
+        <sym> <?before \s | ',' | <.terminator> >
+        <.obsvar('%+')>
     }
-    rule statement_control:sym<default> {
-        <sym><.kok> <block>
+
+    token special_variable:sym<$+[ ]> {
+        '$+['
+        <.obsvar('@+')>
     }
 
-    rule statement_control:sym<CATCH> {<sym> <block(1)> }
-    rule statement_control:sym<CONTROL> {<sym> <block(1)> }
-    rule statement_control:sym<QUIT> {<sym> <block(1)> }
+    token special_variable:sym<@+[ ]> {
+        '@+['
+        <.obsvar('@+')>
+    }
 
-    proto token statement_prefix { <...> }
-    token statement_prefix:sym<BEGIN>   { :my %*MYSTERY; <sym><.kok> <blorst> <.explain_mystery> <.cry_sorrows> }
-    token statement_prefix:sym<COMPOSE> { <sym><.kok> <blorst> }
-    token statement_prefix:sym<TEMP>    { <sym><.kok> <blorst> }
-    token statement_prefix:sym<CHECK>   { <sym><.kok> <blorst> }
-    token statement_prefix:sym<INIT>    { <sym><.kok> <blorst> }
-    token statement_prefix:sym<ENTER>   { <sym><.kok> <blorst> }
-    token statement_prefix:sym<FIRST>   { <sym><.kok> <blorst> }
+    token special_variable:sym<@+{ }> {
+        '@+{'
+        <.obsvar('%+')>
+    }
 
-    token statement_prefix:sym<END>   { <sym><.kok> <blorst> }
-    token statement_prefix:sym<LEAVE> { <sym><.kok> <blorst> }
-    token statement_prefix:sym<KEEP>  { <sym><.kok> <blorst> }
-    token statement_prefix:sym<UNDO>  { <sym><.kok> <blorst> }
-    token statement_prefix:sym<NEXT>  { <sym><.kok> <blorst> }
-    token statement_prefix:sym<LAST>  { <sym><.kok> <blorst> }
-    token statement_prefix:sym<PRE>   { <sym><.kok> <blorst> }
-    token statement_prefix:sym<POST>  { <sym><.kok> <blorst> }
-    token statement_prefix:sym<CLOSE> { <sym><.kok> <blorst> }
+    token special_variable:sym<@-> {
+        <sym> <?before \s | ',' | <.terminator> >
+        <.obsvar('@-')>
+    }
 
-    token statement_prefix:sym<race> {
-        <sym><.kok>
-        [
-        | <?before 'for' <.kok>> <for=.statement_control>
-        | <blorst>
-        ]
+    token special_variable:sym<%-> {
+        <sym> <?before \s | ',' | <.terminator> >
+        <.obsvar('%-')>
     }
-    token statement_prefix:sym<hyper> {
-        <sym><.kok>
-        [
-        | <?before 'for' <.kok>> <for=.statement_control>
-        | <blorst>
-        ]
-    }
-    token statement_prefix:sym<lazy> {
-        <sym><.kok>
-        [
-        | <?before 'for' <.kok>> <for=.statement_control>
-        | <blorst>
-        ]
-    }
-    token statement_prefix:sym<eager>   { <sym><.kok> <blorst> }
-    token statement_prefix:sym<sink>    { <sym><.kok> <blorst> }
-    token statement_prefix:sym<try>     {
-        :my $*FATAL := 1;
-        <!!{ $/.clone_braid_from(self).set_pragma('fatal',1); }>
-        <sym><.kok> <blorst>
-        <.set_braid_from(self)>
 
-    }
-    token statement_prefix:sym<quietly> { <sym><.kok> <blorst> }
-    token statement_prefix:sym<gather>  { <sym><.kok> <blorst> }
-    token statement_prefix:sym<once>    { <sym><.kok> <blorst> }
-    token statement_prefix:sym<start>   { <sym><.kok> <blorst> }
-    token statement_prefix:sym<supply>  {
-        :my $*WHENEVER_COUNT := 0;
-        <sym><.kok> <blorst>
-    }
-    token statement_prefix:sym<react>   {
-        :my $*WHENEVER_COUNT := 0;
-        <sym><.kok> <blorst>
-    }
-    token statement_prefix:sym<do>      { <sym><.kok> <blorst> }
-    token statement_prefix:sym<DOC>     {
-        <sym><.kok> $<phase>=['BEGIN' || 'CHECK' || 'INIT']<.end_keyword><.ws>
-        <blorst>
+    token special_variable:sym<$-[ ]> {
+        '$-['
+        <.obsvar('@-')>
     }
 
-    token blorst {
-        [ <?[{]> <block> | <![;]> <statement> <.cheat_heredoc>? || <.missing: 'block or statement'> ]
+    token special_variable:sym<@-[ ]> {
+        '@-['
+        <.obsvar('@-')>
     }
 
-    ## Statement modifiers
+    token special_variable:sym<%-{ }> {
+        '@-{'
+        <.obsvar('%-')>
+    }
 
-    proto rule statement_mod_cond { <...> }
+    token special_variable:sym<$/> {
+        <sym> <?before \h* '=' \h* <.[ ' " ]> >
+        <.obsvar('$/')>
+    }
 
-    method nomodexpr($k) {
-        self.'!clear_highwater'();
-        self.typed_panic( 'X::Syntax::Confused', reason => "Missing expression for '$k' statement modifier" );
-        self;
+    token special_variable:sym<$\\> {
+        '$\\' <?before \s | ',' | '=' | <.terminator> >
+        <.obsvar('$\\')>
     }
-    token modifier_expr($k) { <EXPR> || <.nomodexpr($k)> }
-    token smexpr($k)        { <EXPR> || <.nomodexpr($k)> }
 
-    rule statement_mod_cond:sym<if>     { <sym><.kok> <modifier_expr('if')> }
-    rule statement_mod_cond:sym<unless> { <sym><.kok> <modifier_expr('unless')> }
-    rule statement_mod_cond:sym<when>   { <sym><.kok> <modifier_expr('when')> }
-    rule statement_mod_cond:sym<with>   { <sym><.kok> <modifier_expr('with')> }
-    rule statement_mod_cond:sym<without>{ <sym><.kok> <modifier_expr('without')> }
+    token special_variable:sym<$|> {
+        <sym> <?before \h* '='>
+        <.obsvar('$|')>
+    }
 
-    proto rule statement_mod_loop { <...> }
+    token special_variable:sym<$;> {
+        <sym> <?before \h* '='>
+        <.obsvar('$;')>
+    }
 
-    rule statement_mod_loop:sym<while> { <sym><.kok> <smexpr('while')> }
-    rule statement_mod_loop:sym<until> { <sym><.kok> <smexpr('until')> }
-    rule statement_mod_loop:sym<for>   { <sym><.kok> <smexpr('for')> }
-    rule statement_mod_loop:sym<given> { <sym><.kok> <smexpr('given')> }
+    token special_variable:sym<$'> { #'
+        <sym> <?before \s | ',' | <.terminator> >
+        <.obsvar('$' ~ "'")>
+    }
 
-    ## Terms
+    token special_variable:sym<$"> {
+        <sym> <?before \h* '='>
+        <.obsvar('$"')>
+    }
 
-    token term:sym<fatarrow>           { <fatarrow> }
-    token term:sym<colonpair>          { <colonpair> }
-    token term:sym<variable>           { <variable> { $*VAR := $<variable> unless $*VAR; } }  # maybe desigilname already set it
-    token term:sym<package_declarator> { <package_declarator> }
-    token term:sym<scope_declarator>   { <scope_declarator> }
-    token term:sym<routine_declarator> { <routine_declarator> }
-    token term:sym<multi_declarator>   { <?before 'multi'|'proto'|'only'> <multi_declarator> }
-    token term:sym<regex_declarator>   { <regex_declarator> }
-    token term:sym<circumfix>          { <circumfix> }
-    token term:sym<statement_prefix>   { <statement_prefix> }
-    token term:sym<**>                 { <sym> }
-    token term:sym<*>                  { <sym> }
-    token term:sym<lambda>             { <?lambda> <pblock> {$*BORG<block> := $<pblock> } }
-    token term:sym<type_declarator>    { <type_declarator> }
-    token term:sym<value>              { <value> }
-    token term:sym<unquote>            { '{{{' <?{ $*IN_QUASI }> <statementlist> '}}}' }
-    token term:sym<!!>                 { '!!' <?before \s> }  # actual error produced inside infix:<?? !!>
+    token special_variable:sym<$,> {
+        <sym> <?before \h* '='>
+        <.obsvar('$,')>
+    }
 
-    token term:sym<::?IDENT> {
-        $<sym> = [ '::?' <identifier> ] »
+    token special_variable:sym<$.> {
+        <sym> {} <!before \w | '(' | '^' >
+        <.obsvar('$.')>
     }
-    token term:sym<p5end> {
-        << __END__ >>
-        <.obs('__END__ as end of code',
-          'the =finish pod marker and $=finish to read')>
+
+    token special_variable:sym<$?> {
+        <sym> {} <!before \w | '('>
+        <.obsvar('$?')>
     }
-    token term:sym<p5data> {
-        << __DATA__ >>
-        <.obs('__DATA__ as start of data',
-          'the =finish pod marker and $=finish to read')>
+
+    token special_variable:sym<$]> {
+        <sym> {} <!before \w | '('>
+        <.obsvar('$]')>
     }
 
-    token infix:sym<lambda> {
-        <?before '{' | <.lambda> > <!{ $*IN_META }> {
-            my $needparens := 0;
-            my $pos := $/.from;
-            my $line := HLL::Compiler.lineof($/.orig, $/.from, :cache(1));
-            my $lex := $*W.cur_lexpad();
-            for 'if', 'unless', 'while', 'until', 'for', 'given', 'when', 'loop', 'sub', 'method', 'with', 'without', 'supply', 'whenever', 'react' {
-                $needparens++ if $_ eq 'loop';
-                my $m := %*MYSTERY{$_ ~ '-' ~ $lex.cuid};
-                next unless $m;
-                my $m_pos  := $m<pos>[nqp::elems($m<pos>) - 1];
-                my $m_line := HLL::Compiler.lineof($/.orig, $m_pos, :cache(1));
-                if $line - $m_line < 5 {
-                    if $m<ctx> eq '(' {
-                        $/.'!clear_highwater'();
-                        $/.'!cursor_pos'($m_pos);
-                        $/.typed_sorry('X::Syntax::KeywordAsFunction',
-                                word => $_,
-                                :$needparens,
-                        );
-                        $/.'!cursor_pos'($pos);
-                        $/.panic("Unexpected block in infix position (two terms in a row)");
-                    }
-                    else {
-                        $/.'!clear_highwater'();
-                        $/.'!cursor_pos'($m_pos);
-                        $/.sorry("Word '$_' interpreted as a listop; please use 'do $_' to introduce the statement control word");
-                        $/.'!cursor_pos'($pos);
-                        $/.panic("Unexpected block in infix position (two terms in a row)");
-                    }
-                }
+    regex special_variable:sym<${ }> {
+        <sigil> '{' {} $<text>=[.*?] '}'
+        <!{ $*IN_DECL }>
+        <!{ $<text> ~~ / '=>' || ':'<:alpha> || '|%' / }>
+        <!{ $<text> ~~ / ^ \s* $ / }>
+        <?{
+            my $sigil := $<sigil>.Str;
+            my $text := $<text>.Str;
+            my $bad := $sigil ~ '{' ~ $text ~ '}';
+            if $text ~~ /^\d+$/ {
+                $text := nqp::radix(10, $text, 0, 0)[0];
+                $text := $text - 1 if $text > 0;
             }
-        }
-        [
-        || <!{ $*IN_REDUCE }> {
-            $/.panic("Unexpected block in infix position (missing statement control word before the expression?)");
-        }
-        || <!>
-        ]
+            if $sigil ne '$' && $sigil ne '@' {
+                False;  # not likely a P5ism
+            }
+            elsif !($text ~~ /^(\w|\:)+$/) {
+                $/.obs($bad, "$sigil\($text) for hard ref or $sigil\::($text) for symbolic ref");
+            }
+            elsif $*QSIGIL {
+                $/.obs($bad, '{' ~ $sigil ~ $text ~ '}');
+            }
+            else {
+                $/.obs($bad, $sigil ~ $text);
+            }
+        }>
     }
 
-    token term:sym<undef> {
-        <!{ $*LANG.pragma('p5isms') }>
-        <sym> >> {}
-        [ <?before \h*'$/' >
-            <.obs('$/ variable as input record separator',
-                 "the filehandle's .slurp method")>
-        ]?
-        [ <?before [ '(' || \h*<.sigil><.twigil>?\w ] >
-            <.obs('undef as a verb', 'undefine() or assignment of Nil')>
-        ]?
-        <.obs('undef as a value', "something more specific:\n\tan undefined type object such as Any or Int,\n\t:!defined as a matcher,\n\tAny:U as a type constraint,\n\tNil as the absence of an expected value\n\tor fail() as a failure return\n\t   ")>
+    token desigilname {
+        [
+        | <?before <.sigil> <.sigil> > <variable>
+        | <?sigil>
+            [ <?{ $*IN_DECL }> <.typed_panic: 'X::Syntax::Variable::IndirectDeclaration'> ]?
+            <variable> {
+                $*VAR := $<variable>;
+            }
+        | <longname>
+        ]
     }
 
-    token term:sym<new> {
-        <!{ $*LANG.pragma('c++isms') }>
-        'new' \h+ <longname> \h* <![:]> <.obs("C++ constructor syntax", "method call syntax", :ism<c++isms>)>
+    token desigilmetaname {
+        $<longname>=( $<name>=( <identifier>  ) )
     }
 
-    token fatarrow {
-        <key=.identifier> \h* '=>' <.ws> <val=.EXPR('i<=')>
+    token variable {
+        :my $*IN_META := '';
+        [
+        | :dba('infix noun') '&[' ~ ']' <infixish('[]')>
+        | <sigil> [ $<twigil>=['.^'] <desigilname=desigilmetaname> | <twigil>? <desigilname> ]
+          [ <?{ !$*IN_DECL && $*VARIABLE && $*VARIABLE eq $<sigil> ~ $<twigil> ~ $<desigilname> }>
+            { self.typed_panic: 'X::Syntax::Variable::Initializer', name => $*VARIABLE } ]?
+        | <special_variable>
+        | <sigil> $<index>=[\d+]                              [<?{ $*IN_DECL }> <.typed_panic: "X::Syntax::Variable::Numeric">]?
+        | <sigil> <?[<]> <postcircumfix>                      [<?{ $*IN_DECL }> <.typed_panic('X::Syntax::Variable::Match')>]?
+        | <?before <.sigil> <.?[ ( [ { ]>> <!RESTRICTED> <?{ !$*IN_DECL }> <contextualizer>
+        | $<sigil>=['$'] $<desigilname>=[<[/_!¢]>]
+        | {} <sigil> <!{ $*QSIGIL }> <?MARKER('baresigil')>   # try last, to allow sublanguages to redefine sigils (like & in regex)
+        ]
+        [ <?{ $<twigil> && ( $<twigil> eq '.' || $<twigil> eq '.^' ) }>
+            [ <.unsp> | '\\' | <?> ] <?[(]> <!RESTRICTED> <arglist=.postcircumfix>
+        ]?
+        { $*LEFTSIGIL := nqp::substr(self.orig(), self.from, 1) unless $*LEFTSIGIL }
     }
 
-    token coloncircumfix($front) {
-        # reset $*IN_DECL in case this colonpair is part of var we're
-        # declaring, since colonpair might have other vars. Don't make those
-        # think we're declaring them
-        :my $*IN_DECL := '';
+    token contextualizer {
+        :dba('contextualizer')
+        [ <?{ $*IN_DECL }> <.panic: "Cannot declare a contextualizer"> ]?
         [
-        | '<>' <.worry("Pair with <> really means an empty list, not null string; use :$front" ~ "('') to represent the null string,\n  or :$front" ~ "() to represent the empty list more accurately")>
-        | {} <circumfix>
+        | <sigil> '(' ~ ')'    <coercee=sequence>
+        | <sigil> <?[ \[ \{ ]> <coercee=circumfix>
         ]
     }
 
-    token colonpair {
-        :my $*key;
-        :my $*value;
-
-        ':'
-        :dba('colon pair')
-        [
-        | '!' [ <identifier> || <.panic: "Malformed False pair; expected identifier"> ]
-            [ <[ \[ \( \< \{ ]> {
-            $/.typed_panic('X::Syntax::NegatedPair', key => ~$<identifier>) } ]?
-            { $*key := $<identifier>.Str; $*value := 0; }
-        | $<num> = [\d+] <identifier> [ <?before <.[ \[ \( \< \{ ]>> {} <.sorry("Extra argument not allowed; pair already has argument of " ~ $<num>.Str)> <.circumfix> ]?
-            <?{
-                # Here we go over each character in the numeral and check $ch.chr eq $ch.ord.chr
-                # to fail any matches that have synthetics, such as 7\x[308]
-                my $num       := ~$<num>;
-                my $chars-num := nqp::chars($num);
-                my $pos       := -1;
-                nqp::while(
-                    nqp::islt_i( ($pos := nqp::add_i($pos, 1)), $chars-num )
-                    && nqp::eqat(
-                        $num,
-                        nqp::chr( nqp::ord($num, $pos) ),
-                        $pos,
-                    ),
-                    nqp::null,
-                );
-                nqp::iseq_i($chars-num, $pos);
-            }>
-            { $*key := $<identifier>.Str; $*value := nqp::radix_I(10, $<num>, 0, 0, $*W.find_symbol(['Int']))[0]; }
-        | <identifier>
-            { $*key := $<identifier>.Str; }
-            [
-            || <.unsp>? :dba('pair value') <coloncircumfix($*key)> { $*value := $<coloncircumfix>; }
-            || { $*value := 1; }
-            ]
-        | :dba('signature') '(' ~ ')' <fakesignature>
-        | <coloncircumfix('')>
-            { $*key := ""; $*value := $<coloncircumfix>; }
-        | <var=.colonpair_variable>
-            { $*key := $<var><desigilname>.Str; $*value := $<var>; self.check_variable($*value); }
-        ]
-    }
-
-    token colonpair_variable {
-        <sigil> {}
-        [
-        | <twigil>? <desigilname>
-        | $<capvar>='<' <desigilname> '>'
-        ]
-    }
-
-    proto token special_variable { <...> }
-
-    token special_variable:sym<$!{ }> {
-        [ '$!{' .*? '}' | '%!' ]
-        <.obsvar('%!')>
-    }
-
-    token special_variable:sym<$`> {
-        <sym>  <?before \s | ',' | <.terminator> >
-        <.obsvar('$`')>
-    }
-
-    token special_variable:sym<$@> {
-        <sym> <[ \s ; , ) ]> .
-        <.obsvar('$@')>
-    }
-
-    token special_variable:sym<$#> {
-        <sym> <identifier>
-        {}
-        <.obsvar('$#', ~$<identifier>)>
-    }
-
-    token special_variable:sym<$$> {
-        <sym> \W
-        <.obsvar('$$')>
-    }
-
-    token special_variable:sym<$&> {
-        <sym> <?before \s | ',' | <.terminator> >
-        <.obsvar('$&')>
-    }
-
-    token special_variable:sym<@+> {
-        <sym> <?before \s | ',' | <.terminator> >
-        <.obsvar('@+')>
-    }
-
-    token special_variable:sym<%+> {
-        <sym> <?before \s | ',' | <.terminator> >
-        <.obsvar('%+')>
-    }
-
-    token special_variable:sym<$+[ ]> {
-        '$+['
-        <.obsvar('@+')>
-    }
-
-    token special_variable:sym<@+[ ]> {
-        '@+['
-        <.obsvar('@+')>
-    }
-
-    token special_variable:sym<@+{ }> {
-        '@+{'
-        <.obsvar('%+')>
-    }
-
-    token special_variable:sym<@-> {
-        <sym> <?before \s | ',' | <.terminator> >
-        <.obsvar('@-')>
-    }
-
-    token special_variable:sym<%-> {
-        <sym> <?before \s | ',' | <.terminator> >
-        <.obsvar('%-')>
-    }
-
-    token special_variable:sym<$-[ ]> {
-        '$-['
-        <.obsvar('@-')>
-    }
-
-    token special_variable:sym<@-[ ]> {
-        '@-['
-        <.obsvar('@-')>
-    }
-
-    token special_variable:sym<%-{ }> {
-        '@-{'
-        <.obsvar('%-')>
-    }
-
-    token special_variable:sym<$/> {
-        <sym> <?before \h* '=' \h* <.[ ' " ]> >
-        <.obsvar('$/')>
-    }
-
-    token special_variable:sym<$\\> {
-        '$\\' <?before \s | ',' | '=' | <.terminator> >
-        <.obsvar('$\\')>
-    }
-
-    token special_variable:sym<$|> {
-        <sym> <?before \h* '='>
-        <.obsvar('$|')>
-    }
-
-    token special_variable:sym<$;> {
-        <sym> <?before \h* '='>
-        <.obsvar('$;')>
-    }
-
-    token special_variable:sym<$'> { #'
-        <sym> <?before \s | ',' | <.terminator> >
-        <.obsvar('$' ~ "'")>
-    }
-
-    token special_variable:sym<$"> {
-        <sym> <?before \h* '='>
-        <.obsvar('$"')>
-    }
-
-    token special_variable:sym<$,> {
-        <sym> <?before \h* '='>
-        <.obsvar('$,')>
-    }
-
-    token special_variable:sym<$.> {
-        <sym> {} <!before \w | '(' | '^' >
-        <.obsvar('$.')>
-    }
-
-    token special_variable:sym<$?> {
-        <sym> {} <!before \w | '('>
-        <.obsvar('$?')>
-    }
-
-    token special_variable:sym<$]> {
-        <sym> {} <!before \w | '('>
-        <.obsvar('$]')>
-    }
-
-    regex special_variable:sym<${ }> {
-        <sigil> '{' {} $<text>=[.*?] '}'
-        <!{ $*IN_DECL }>
-        <!{ $<text> ~~ / '=>' || ':'<:alpha> || '|%' / }>
-        <!{ $<text> ~~ / ^ \s* $ / }>
-        <?{
-            my $sigil := $<sigil>.Str;
-            my $text := $<text>.Str;
-            my $bad := $sigil ~ '{' ~ $text ~ '}';
-            if $text ~~ /^\d+$/ {
-                $text := nqp::radix(10, $text, 0, 0)[0];
-                $text := $text - 1 if $text > 0;
-            }
-            if $sigil ne '$' && $sigil ne '@' {
-                False;  # not likely a P5ism
-            }
-            elsif !($text ~~ /^(\w|\:)+$/) {
-                $/.obs($bad, "$sigil\($text) for hard ref or $sigil\::($text) for symbolic ref");
-            }
-            elsif $*QSIGIL {
-                $/.obs($bad, '{' ~ $sigil ~ $text ~ '}');
-            }
-            else {
-                $/.obs($bad, $sigil ~ $text);
-            }
-        }>
-    }
-
-    token desigilname {
-        [
-        | <?before <.sigil> <.sigil> > <variable>
-        | <?sigil>
-            [ <?{ $*IN_DECL }> <.typed_panic: 'X::Syntax::Variable::IndirectDeclaration'> ]?
-            <variable> {
-                $*VAR := $<variable>;
-            }
-        | <longname>
-        ]
-    }
-
-    token desigilmetaname {
-        $<longname>=( $<name>=( <identifier>  ) )
-    }
-
-    token variable {
-        :my $*IN_META := '';
-        [
-        | :dba('infix noun') '&[' ~ ']' <infixish('[]')>
-        | <sigil> [ $<twigil>=['.^'] <desigilname=desigilmetaname> | <twigil>? <desigilname> ]
-          [ <?{ !$*IN_DECL && $*VARIABLE && $*VARIABLE eq $<sigil> ~ $<twigil> ~ $<desigilname> }>
-            { self.typed_panic: 'X::Syntax::Variable::Initializer', name => $*VARIABLE } ]?
-        | <special_variable>
-        | <sigil> $<index>=[\d+]                              [<?{ $*IN_DECL }> <.typed_panic: "X::Syntax::Variable::Numeric">]?
-        | <sigil> <?[<]> <postcircumfix>                      [<?{ $*IN_DECL }> <.typed_panic('X::Syntax::Variable::Match')>]?
-        | <?before <.sigil> <.?[ ( [ { ]>> <!RESTRICTED> <?{ !$*IN_DECL }> <contextualizer>
-        | $<sigil>=['$'] $<desigilname>=[<[/_!¢]>]
-        | {} <sigil> <!{ $*QSIGIL }> <?MARKER('baresigil')>   # try last, to allow sublanguages to redefine sigils (like & in regex)
-        ]
-        [ <?{ $<twigil> && ( $<twigil> eq '.' || $<twigil> eq '.^' ) }>
-            [ <.unsp> | '\\' | <?> ] <?[(]> <!RESTRICTED> <arglist=.postcircumfix>
-        ]?
-        { $*LEFTSIGIL := nqp::substr(self.orig(), self.from, 1) unless $*LEFTSIGIL }
-    }
-
-    token contextualizer {
-        :dba('contextualizer')
-        [ <?{ $*IN_DECL }> <.panic: "Cannot declare a contextualizer"> ]?
-        [
-        | <sigil> '(' ~ ')'    <coercee=sequence>
-        | <sigil> <?[ \[ \{ ]> <coercee=circumfix>
-        ]
-    }
-
-    token sigil { <[$@%&]> }
+    token sigil { <[$@%&]> }
 
     proto token twigil { <...> }
     token twigil:sym<.> { <sym> <?before \w> }
@@ -5137,6 +4614,539 @@ if $*COMPILING_CORE_SETTING {
         }
         self.O(|%prec)
     }
+
+    #================================================================
+    # POD-ONLY CODE HANDLERS
+    #================================================================
+    # move ALL Pod-only grammar objects here
+
+    proto token comment { <...> }
+
+    token comment:sym<#> {
+       '#' {} \N*
+    }
+
+    token comment:sym<#`(...)> {
+        '#`' <?opener> {}
+        [ <.quibble(self.slang_grammar('Quote'))> || <.typed_panic: 'X::Syntax::Comment::Embedded'> ]
+    }
+
+    token comment:sym<#|(...)> {
+        '#|' <?opener> <attachment=.quibble(self.slang_grammar('Quote'))>
+        {
+            unless $*POD_BLOCKS_SEEN{ self.from() } {
+                $*POD_BLOCKS_SEEN{ self.from() } := 1;
+                if $*DECLARATOR_DOCS eq '' {
+                    $*DECLARATOR_DOCS := $<attachment><nibble>;
+                } else {
+                    $*DECLARATOR_DOCS := nqp::concat($*DECLARATOR_DOCS, nqp::concat("\n", $<attachment><nibble>));
+                }
+            }
+        }
+    }
+
+    token comment:sym<#|> {
+        '#|' \h+ $<attachment>=[\N*]
+        {
+            unless $*POD_BLOCKS_SEEN{ self.from() } {
+                $*POD_BLOCKS_SEEN{ self.from() } := 1;
+                if $*DECLARATOR_DOCS eq '' {
+                    $*DECLARATOR_DOCS := $<attachment>;
+                } else {
+                    $*DECLARATOR_DOCS := nqp::concat($*DECLARATOR_DOCS, nqp::concat("\n", $<attachment>));
+                }
+            }
+        }
+    }
+
+    token comment:sym<#=(...)> {
+        '#=' <?opener> <attachment=.quibble(self.slang_grammar('Quote'))>
+        {
+            self.attach_trailing_docs(~$<attachment><nibble>);
+        }
+    }
+
+    token comment:sym<#=> {
+        '#=' \h+ $<attachment>=[\N*]
+        {
+            self.attach_trailing_docs(~$<attachment>);
+        }
+    }
+
+    method attach_leading_docs() {
+        # TODO allow some limited text layout here
+        if ~$*DOC ne '' {
+            my $cont  := Perl6::Pod::serialize_aos(
+                [Perl6::Pod::normalize_text(~$*DOC)]
+            ).compile_time_value;
+            my $block := $*W.add_constant(
+                'Pod::Block::Declarator', 'type_new',
+                :nocache, :leading([$cont]),
+            );
+            $*POD_BLOCK := $block.compile_time_value;
+            $*POD_BLOCKS.push($*POD_BLOCK);
+        }
+        self
+    }
+
+    method attach_trailing_docs($doc) {
+        # TODO allow some limited text layout here
+        unless $*POD_BLOCKS_SEEN{ self.from() } {
+            $*POD_BLOCKS_SEEN{ self.from() } := 1;
+            my $pod_block;
+            if $doc ne '' {
+                my $cont  := Perl6::Pod::serialize_aos(
+                    [Perl6::Pod::normalize_text($doc)]
+                ).compile_time_value;
+                my $block := $*W.add_constant(
+                    'Pod::Block::Declarator', 'type_new',
+                    :nocache, :trailing([$cont]),
+                );
+                $pod_block := $block.compile_time_value;
+            }
+            unless $*PRECEDING_DECL =:= Mu {
+                Perl6::Pod::document(self.MATCH, $*PRECEDING_DECL, $pod_block, :trailing);
+            }
+        }
+    }
+
+    token pod_content_toplevel {
+        <pod_block>
+    }
+
+    proto token pod_content { <...> }
+
+    token pod_content:sym<block> {
+        <pod_newline>*
+        <pod_block>
+        <pod_newline>*
+    }
+
+    # any number of paragraphs of text
+    # the paragraphs are separated by one
+    #   or more pod_newlines
+    # each paragraph originally could have
+    #   consisted of more than one line of
+    #   text that were subsequently squeezed
+    #   into one line
+    token pod_content:sym<text> {
+        <pod_newline>*
+
+        # TODO get first line if IN-DEFN-BLOCK
+        <pod_textcontent>+ % <pod_newline>+
+
+        <pod_newline>*
+    }
+
+    # not a block, just a directive
+    token pod_content:sym<config> {
+        <pod_newline>*
+        ^^ \h* '=config' \h+ $<type>=\S+ <pod_configuration>
+        <pod_newline>+
+    }
+
+    proto token pod_textcontent { <...> }
+
+    # for non-code (i.e., regular) text
+    token pod_textcontent:sym<regular> {
+        $<spaces>=[ \h* ]
+         <?{ $*POD_IN_CODE_BLOCK
+             || !$*ALLOW_INLINE_CODE
+             || ($<spaces>.to - $<spaces>.from) <= $*VMARGIN }>
+
+        $<text> = [
+            \h* <!before '=' \w> <pod_string> [ <pod_newline> | $ ]
+        ] +
+    }
+
+    token pod_textcontent:sym<code> {
+        $<spaces>=[ \h* ]
+        <?{ !$*POD_IN_CODE_BLOCK
+            && $*ALLOW_INLINE_CODE
+            && ($<spaces>.to - $<spaces>.from) > $*VMARGIN }>
+
+        # TODO get first line if IN-DEFN-BLOCK
+        $<text> = [
+            [<!before '=' \w> \N+]+ % [<pod_newline>+ $<spaces>]
+        ]
+    }
+
+    token pod_formatting_code {
+        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+        :my $*POD_IN_FORMATTINGCODE := nqp::getlexdyn('$*POD_IN_FORMATTINGCODE');
+        :my $*POD_ANGLE_COUNT := nqp::getlexdyn('$*POD_ANGLE_COUNT');
+        <?{ $*POD_ALLOW_FCODES }>
+
+        :my $endtag;
+        <code=[A..Z]>
+        $<begin-tag>=['<'+ <![<]> | '«'] { $*POD_IN_FORMATTINGCODE := 1 }
+        <?{
+            my $codenum := nqp::ord($<code>.Str) - nqp::ord("A");
+            if !($*POD_ALLOW_FCODES +& (2 ** $codenum)) {
+                0
+            } elsif ~$<begin-tag> eq '«' {
+              $endtag := "»";
+              $*POD_ANGLE_COUNT := -1;
+              1
+            } else {
+              my int $ct := nqp::chars($<begin-tag>);
+              $endtag := nqp::x(">", $ct);
+              my $rv := $*POD_ANGLE_COUNT <= 0 || $*POD_ANGLE_COUNT >= $ct;
+              $*POD_ANGLE_COUNT := $ct;
+              $rv;
+            }
+        }>
+        {
+            if $<code>.Str eq "V" || $<code>.Str eq "C" {
+                $*POD_ALLOW_FCODES := 0;
+            }
+        }
+        [ <!{$<code> eq 'E'}>
+          $<contents>=[
+              <!before $endtag>
+              [ <?{$<code> ne 'L' && $<code> ne 'D' && $<code> ne 'X' }> || <!before \s* \| > ]
+              <pod_string_character>
+          ]*
+        ]?
+        [
+        | <?{$<code> eq 'L'}> \s* \| \s* $<meta>=[<!before $endtag>.]+
+        | <?{$<code> eq 'X'}> \s* \| \s* ( [$<meta>=[<!before $endtag | <[,;]> >.]+] +%% \, ) +%% \;
+        | <?{$<code> eq 'D'}> \s* \| \s* [$<meta>=[<!before $endtag | \; >.]+] +%% \;
+        | <?{$<code> eq 'E'}> ( <integer> | $<uni_name>=<[A..Z\s]>+ <![a..z]> || $<html_ref>=<[A..Za..z]>+ ) +%% \;
+        ]?
+        [ $endtag || <.worry: "Pod formatting code $<code> missing endtag '$endtag'."> ]
+    }
+
+    token pod_balanced_braces {
+        <?{ $*POD_IN_FORMATTINGCODE }>
+        :my $endtag;
+        [
+            $<braces>=[
+                      || '<'+ <![<]>
+                      || '>'+ <![>]>
+                      ]
+            <?{ nqp::chars($<braces>) < $*POD_ANGLE_COUNT || $*POD_ANGLE_COUNT < 0 }>
+          ||
+            <?{ $*POD_ANGLE_COUNT >= 1 }>
+            $<start>=['<'+] <![<]>
+            <?{ nqp::chars($<start>) == $*POD_ANGLE_COUNT || $*POD_ANGLE_COUNT < 0 }>
+            {
+                $endtag := nqp::x(">", nqp::chars($<start>));
+            }
+            $<contents>=[ <pod_string_character>*?]
+            <!after '>'> $<endtag>=[$endtag]
+        ]
+    }
+
+    token pod_string {
+        <pod_string_character>+
+    }
+
+    token pod_string_character {
+        <pod_balanced_braces> || <pod_formatting_code> || $<char>=[ \N || [
+            <?{ $*POD_IN_FORMATTINGCODE }> \n [
+                <?{ $*POD_DELIMITED_CODE_BLOCK }> <!before \h* '=end' \h+ <pod-delim-code-typ> > ||
+                <!before \h* '=' \w>
+                ]
+            ]
+        ]
+    }
+
+    proto token pod_block { <...> }
+
+    token pod_configuration($spaces = '') {
+        [ [\n $spaces '=']? \h+ <colonpair> ]*
+    }
+
+    token pod_block:sym<delimited_comment> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=begin' \h+ 'comment' {}
+        <pod_configuration($<spaces>)> <pod_newline>+
+        [
+         $<pod_content> = [ .*? ]
+         ^^ $<spaces> '=end' \h+
+         [
+            'comment' [ <pod_newline> | $ ]
+            || $<instead>=<identifier>? {
+                   $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
+                       type    => 'comment',
+                       spaces  => ~$<spaces>,
+                       instead => $<instead> ?? ~$<instead> !! ''
+               }
+         ]
+        ]
+    }
+
+    regex pod_block:sym<delimited> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=begin'
+        [ <?pod_newline>
+          <.typed_panic('X::Syntax::Pod::BeginWithoutIdentifier')>
+        ]?
+        \h+ <!before 'finish'>
+        {
+            $*VMARGIN    := $<spaces>.to - $<spaces>.from;
+        }
+        :my $*ALLOW_INLINE_CODE := 0;
+        $<type> = [
+            <pod_code_parent> {
+                $*ALLOW_INLINE_CODE := 1;
+            }
+            || <identifier>
+        ]
+        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+        <pod_configuration($<spaces>)> <pod_newline>+
+        [
+         # TODO need first line to check for ws-separated '#'
+         <pod_content> *
+         ^^ $<spaces> '=end' \h+
+         [
+             $<type> [ <pod_newline> | $ ]
+             || $<instead>=<identifier>? {
+                    $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
+                        type    => ~$<type>,
+                        spaces  => ~$<spaces>,
+                        instead => $<instead> ?? ~$<instead> !! ''
+                    }
+         ]
+        ]
+    }
+
+
+    token pod_block:sym<delimited_table> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=begin' \h+ 'table' {}
+        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+        <pod_configuration($<spaces>)> <pod_newline>+
+        [
+         [ $<table_row>=<.table_row_or_blank> ]*
+         ^^ \h* '=end' \h+
+         [
+            'table' [ <pod_newline> | $ ]
+             || $<instead>=<identifier>? {
+                    $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
+                        type    => 'table',
+                        spaces  => ~$<spaces>,
+                        instead => $<instead> ?? ~$<instead> !! ''
+                    }
+         ]
+        ]
+    }
+
+    # There are several different identifiers for pod blocks
+    # that are treated essentially the same: 'code', 'input',
+    # and 'output'.
+    token pod-delim-code-typ { code | input | output }
+    token pod_block:sym<delimited_code> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=begin' \h+ $<typ>=<pod-delim-code-typ> {}
+        :my $*POD_ALLOW_FCODES  := 0;
+        :my $*POD_IN_CODE_BLOCK := 1;
+        :my $*POD_DELIMITED_CODE_BLOCK := 1;
+        <pod_configuration($<spaces>)> <pod_newline>+
+        [
+        || <delimited_code_content($<spaces>)> $<spaces> '=end' \h+
+            [ $<end>=<pod-delim-code-typ> [ <pod_newline> | $ ]
+              { if ~$<end> ne ~$<typ> {
+                         $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
+                         type    => ~$<typ>,
+                         spaces  => ~$<spaces>,
+                         instead => $<end> ?? ~$<end> !! ''
+              }}
+              || $<instead>=<identifier>? {
+                     $/.typed_panic: 'X::Syntax::Pod::BeginWithoutEnd',
+                     type    => $<typ>,
+                     spaces  => ~$<spaces>,
+                     instead => $<instead> ?? ~$<instead> !! ''
+                 }
+            ]
+        ]
+    }
+
+    token delimited_code_content($spaces = '') {
+        ^^
+        (
+        | $spaces
+            <!before '=end' \h+ <pod-delim-code-typ> [ <pod_newline> | $ ]>
+            <pod_string>**0..1 <pod_newline>
+        | <pod_newline>
+        )*
+    }
+
+    token table_row {
+        \h* <!before '=' \w> \N+ [ \n | $ ]
+    }
+
+    token table_row_or_blank {
+        <.table_row> | [\h* <!before '=' \w> \n ]
+    }
+
+    token pod_block:sym<finish> {
+        ^^ \h*
+        [
+            | '=begin' \h+ 'finish' <pod_newline>
+            | '=for'   \h+ 'finish' <pod_newline>
+            | '=finish' <pod_newline>
+        ]
+        $<finish> = .*
+    }
+
+    token pod_block:sym<paragraph> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=for' \h+ <!before 'finish'>
+        {
+            $*VMARGIN := $<spaces>.to - $<spaces>.from;
+        }
+        :my $*ALLOW_INLINE_CODE := 0;
+        [ :!ratchet
+            $<type> = [
+                <pod_code_parent> { $*ALLOW_INLINE_CODE := 1 }
+                || <identifier>
+            ]
+            :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+            <pod_configuration($<spaces>)>
+            <pod_newline>
+        ]
+        # TODO [defn, term], [first text, line numbered-alias]
+        #   if this is a defn block
+        #     the first line of the first pod_textcontent
+        #     becomes the term
+        #     then combine the rest of the text
+        # TODO exchange **0..1 for modern syntax
+        <pod_content=.pod_textcontent>**0..1
+    }
+
+    token pod_block:sym<paragraph_comment> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=for' \h+ 'comment' {}
+        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+        <pod_configuration($<spaces>)> <pod_newline>
+        $<pod_content> = [ \h* <!before '=' \w> \N+ [ \n | $ ] ]*
+    }
+
+    token pod_block:sym<paragraph_table> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=for' \h+ 'table' {}
+        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+        <pod_configuration($<spaces>)> <pod_newline>
+
+        # TODO add numbered-alias token here
+        [ <!before \h* \n> <table_row>]*
+    }
+
+    token pod_block:sym<paragraph_code> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=for' \h+ <pod-delim-code-typ> {}
+        :my $*POD_ALLOW_FCODES := 0;
+        :my $*POD_IN_CODE_BLOCK := 1;
+        <pod_configuration($<spaces>)> <pod_newline>
+
+        # TODO get first line if IN-DEFN-BLOCK
+        [ <!before \h* '=' \w> <pod_line> ]*
+    }
+
+    # TODO make sure this token works in all desired
+    #      places: may have to remove the before/afters
+    #      when using with non-abbreviated blocks
+    #      (particulary code blocks)
+    token numbered-alias { <after [^|\s]> '#' <before \s> }
+    token pod_block:sym<abbreviated> {
+        # Note an abbreviated block does not have
+        # %config data, but see the hash mark
+        # handling below.
+        ^^
+        $<spaces> = [ \h* ]
+        '=' <!before begin || end || for || finish || config>
+        {
+            $*VMARGIN := $<spaces>.to - $<spaces>.from;
+        }
+        :my $*ALLOW_INLINE_CODE := 0;
+        [ :!ratchet
+            $<type> = [
+                <pod_code_parent> {
+                    $*ALLOW_INLINE_CODE := 1;
+                }
+                || <identifier>
+            ]
+            :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+
+            # An optional hash char here is special.
+            [\h+ <numbered-alias>]?
+
+            [\h*\n|\h+]
+        ]
+        # TODO [defn, term], [first text, line numbered-alias]
+        # TODO exchange **0..1 for modern syntax
+        <pod_content=.pod_textcontent>**0..1
+    }
+
+    token pod_block:sym<abbreviated_comment> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=comment' {}
+        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+        [\h*\n|\h+]
+        $<pod_content> = [ \h* <!before '=' \w> \N+ [ \n | $ ] ]*
+    }
+
+    token pod_block:sym<abbreviated_table> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=table' {}
+
+        # An optional hash char here is special.
+        [\h+ <numbered-alias>]?
+
+        :my $*POD_ALLOW_FCODES := nqp::getlexdyn('$*POD_ALLOW_FCODES');
+        <pod_newline>
+        [ <!before \h* \n> <table_row>]*
+    }
+
+    token pod_block:sym<abbreviated_code> {
+        ^^
+        $<spaces> = [ \h* ]
+        '=' <pod-delim-code-typ> {}
+        :my $*POD_ALLOW_FCODES  := 0;
+        :my $*POD_IN_CODE_BLOCK := 1;
+
+        # An optional hash char here is special.
+        # For the code block, we want to eat any ws
+        # between the '#' and the next char
+        #$<numbered-alias>=[\h+ '#' \s]?
+        $<numbered-alias>=[\h+ '#' \s]?
+
+        [\h*\n|\h+]
+
+        [ <!before \h* '=' \w> <pod_line> ]*
+    }
+
+    # TODO exchange **1 for modern syntax
+    token pod_line { <pod_string>**1 [ <pod_newline> | $ ] }
+
+    token pod_newline {
+        \h* \n
+    }
+
+    # These parents can contain implicit code blocks when data
+    # lines begin with whitespace indention from the virtual
+    # margin.
+    token pod_code_parent {
+        [
+        | [ 'pod' | 'item' \d* | 'nested' | 'defn' | 'finish' ]
+        | <upper>+
+        ]
+        <![\w]>
+    }
+
+
 }
 
 grammar Perl6::QGrammar is HLL::Grammar does STD {