File Coverage

blib/lib/Keyword/Declare.pm

Criterion	Covered	Total	%
statement	366	446	82.0
branch	130	174	74.7
condition	39	69	56.5
subroutine	33	35	94.2
pod			n/a
total	568	724	78.4

package Keyword::Declare;
our $VERSION = '0.001017';

use 5.012;     # required for pluggable keywords plus /.../r
use warnings;
use Carp;
use List::Util 1.45 'max', 'uniqstr';

use Keyword::Simple;
use PPR;

my $NESTING_THRESHOLD = 100;   # How many nested keyword expansions is probably too many?

my $TYPE_JUNCTION = qr{ [^\W\d] \w*+ (?: [|] [^\W\d] \w*+ )*+ }x;   # How to match a TypeA|TypeB type

my @keyword_impls;  # Tracks all keyword information in every scope

sub import {
    my (undef, $opt_ref) = @_;
    $opt_ref //= {};

    # Don't allow bad arguments to be passed when the module is loaded...
    my $arg_type = ref($opt_ref);
    if (@_ > 2 || $arg_type ne 'HASH') {
        $arg_type ||= $opt_ref;
        croak "Invalid option for: use Keyword::Declare.\n",
              "Expected single hash reference, but found $arg_type instead.\n",
              "Error detected";
    }

    # If debugging requested, set in on for the caller's lexical scope...
    if ($opt_ref->{debug}) {
        ${^H}{'Keyword::Declare debug'} = !!$opt_ref->{debug};
    }

    # Install replacement __DATA__ handler...
    # [REMOVE IF UPSTREAM MODULE (Keyword::Simple) FIXED]
    _install_data_handler();

    # Install the 'keytype' (meta-)keyword...
    Keyword::Simple::define 'keytype', sub {
        # Unpack trailing code...
        my ($src_ref) = @_;

        # Where was this keyword declared???
        my ($file, $line) = (caller)[1,2];

        # These track error messages and help decompose the parameter list...
        # (they have to be package vars, so they're visible to in-regex code blocks in older Perls)
        our ($expected, $failed_at, $block_start, @params) = ('new type name', 0, 0);

        # Match and extract the keyword definition...
        use re 'eval';
        $$src_ref =~ s{
            \A
            (?
                            (?&PerlNWS)
                (?{ $expected = "new type name"; $failed_at = pos() })
                (? \$?+ )
                (?   (?&PerlIdentifier) )
                              (?&PerlOWS)
                (?{ $expected = "'is '"; $failed_at = pos() })
                              is
                              (?&PerlOWS)
                (?{ $expected = "existing typename or literal string or regex after 'is'"; $failed_at = pos() })
                (?
                    (?  (?&PerlMatch)  )
                |
                    (? (?&PerlString) )
                |
                    (?   $TYPE_JUNCTION )
                )
            )

            $PPR::GRAMMAR
        }{}xms
            or croak "Invalid keytype definition. Expected $expected\nbut found: ",
                     substr($$src_ref, $failed_at) =~ /(\S+)/;

        # Save the information from the keyword definition...
        my %keytype_info = ( %+, location => "$file line $line", hashline => "$line $file" );

        # Set up the sigil...
        my $sigil_decl = q{};
        if ($keytype_info{typesigil}) {
            my $var = qq{$keytype_info{typesigil}$keytype_info{newtype}};
            if ($keytype_info{oldtyperegex}) {
                $keytype_info{oldtyperegex} =~ s{^m}{};
                if ($keytype_info{oldtyperegex} =~ /\(\?\&Perl[A-Z]/) {
                    $keytype_info{oldtyperegex} =~ s{^\s*(\S)}{$1\$PPR::GRAMMAR};
                }
                $sigil_decl = qq{my $var; BEGIN { $var = qr$keytype_info{oldtyperegex} }}
            }
            elsif ($keytype_info{oldtypestring}) {
                $sigil_decl = qq{my $var; BEGIN { $var = $keytype_info{oldtypestring} }}
            }
            else {
                croak "Invalid keytype definition. Can only specify a sigil on new typename ($keytype_info{typesigil}$keytype_info{newtype}) if type is specified as a string or regex";
            }
        }

        # Debug, if requested...
        if (${^H}{"Keyword::Declare debug"}) {
            my $msg = ("#" x 50) . "\n"
                    . " Installed keytype at $keytype_info{location}:\n\n$keytype_info{syntax}\n\n"
                    . ("#" x 50) . "\n";
            $msg =~ s{^}{###}gm;
            warn $msg;
        }

        # Install the lexical type definition...
        $$src_ref
            = qq{BEGIN{\$^H{q{Keyword::Declare keytype:$keytype_info{newtype}=$keytype_info{oldtype}}} = 1;}}
            . $sigil_decl
            . $$src_ref;
    };

    # Install the 'keyword' (meta-)keyword...
    Keyword::Simple::define 'keyword', sub {
        # Unpack trailing code...
        my ($src_ref) = @_;

        # Where was this keyword declared???
        my ($file, $line) = (caller)[1,2];

        # Which keywords are allowed in nested code at this point...
        my @active_IDs = @^H{ grep { m{^ Keyword::Declare \s+ active:}xms } keys %^H };
        my $lexical_keywords
            = @active_IDs ? join '|', reverse sort map { $keyword_impls[$_]{skip_matcher} } @active_IDs
            :               '(?!)';

        # These track error messages and help decompose the parameter list...
        # (they have to be package vars, so they're visible to in-regex code blocks in older Perls)
        our ($expected, $failed_at, $block_start, @params) = ('keyword name', 0, 0);

        # Match and extract the keyword definition...
        use re 'eval';
        $$src_ref =~ s{
            \A
            (?<____K_D___KeywordDeclaration>
                            (?&PerlNWS)
                (?<____K_D___keyword> (?&PerlIdentifier)                  )
                            (?&PerlOWS)
                (?{ $expected = "keyword parameters or block, or 'from' specifier"; $failed_at = pos() })
                (?<____K_D___params>  (?&____K_D___ParamList)                       )
                            (?&PerlOWS)
                (?{ $expected = 'keyword block or attribute'; $failed_at = pos() })
                (?<____K_D___attrs>   (?&PerlAttributes)?+                )
                            (?&PerlOWS)
                (?{ $expected = 'keyword block'; $failed_at = $block_start = pos() })
                (?<____K_D___block>   \{\{\{ .*? \}\}\} | (?&PerlBlock)   )
            )

            (?(DEFINE)
                (?<____K_D___ParamList>
                    \(
                        (?&____K_D___ParamSet)?+
                        (?:
                            (?&PerlOWS) \) (?&PerlOWS) :then\(
                            (?{ push @Keyword::Declare::params, undef; })
                            (?&____K_D___ParamSet)
                        )?+
                    \)
                |
                    # Nothing
                )

                (?<____K_D___ParamSet>
                                        (?&PerlOWS) (?&____K_D___Param)
                    (?: (?&PerlOWS) ,   (?&PerlOWS) (?&____K_D___Param) )*+
                                    ,?+ (?&PerlOWS)
                )

                (?<____K_D___Param>
                    (?{ $expected = 'keyword parameter type'; $failed_at = pos() })
                        (?<____K_D___type> (?&PerlMatch) | (?&PerlString) | $TYPE_JUNCTION )

                    (?{ $expected = 'keyword parameter quantifier or variable'; $failed_at = pos() })
                        (?: (?&PerlOWS)  (?<____K_D___quantifier> [?*+][?+]?+      )  )?+

                    (?{ $expected = 'keyword parameter variable'; $failed_at = pos() })
                        (?: (?&PerlOWS)  (?<____K_D___sigil>    [\$\@]             )
                                         (?<____K_D___name>     (?&PerlIdentifier) )  )?+

                    (?: (?&PerlOWS)  :sep \(
                    (?{ $expected = 'keyword parameter separator :sep'; $failed_at = pos() })
                        (?&PerlOWS)  (?<____K_D___sep>  (?&PerlMatch) | (?&PerlString) | $TYPE_JUNCTION )
                        (?&PerlOWS) \)
                    )?+

                    (?: (?&PerlOWS)  =
                    (?{ $expected = 'keyword parameter default string after ='; $failed_at = pos() })
                        (?&PerlOWS)  (?<____K_D___default>  (?&PerlQuotelikeQ) )  )?+

                    (?{ push @Keyword::Declare::params, { %+ } })
                )


                (?
                    keyword (?&____K_D___KeywordDeclaration)
                |
                    $lexical_keywords
                )
            )

            $PPR::GRAMMAR
        }{}xms
            or croak "Invalid keyword definition. Expected $expected\nbut found: ",
                      substr($$src_ref, $failed_at) =~ /(\S+)/;

        # Save the information from the keyword definition..
        @Keyword::Declare::params = map { _deprefix($_) } @Keyword::Declare::params;
        my %keyword_info = %+;
           %keyword_info = ( %{ _deprefix(\%keyword_info) },
                             desc            => $keyword_info{____K_D___keyword},
                             param_list      => [ @Keyword::Declare::params],
                             location        => "$file line $line",
                             hashline        => "$line $file",
                           );

        # Check for excessive meta-ness...
        if ($keyword_info{keyword} =~ /^(?:keyword|keytype)$/) {
            croak "Can't redefine '$keyword_info{keyword}' keyword";
        }

        # Remember where the block started...
        my $block_location
            = ($line + substr($keyword_info{KeywordDeclaration}, 0, $block_start) =~ tr/\n//) . " $file";

        # Convert any {{{...}}} block...
        if ($keyword_info{block} =~ m{ \A \{\{\{ }xms) {
            $keyword_info{block} = _convert_triple_block(\%keyword_info);
        }

        # Extract and verify any attributes...
        _unpack_attrs(\%keyword_info);

        # Extract various useful components from the parameter list...
        _unpack_signature(\%keyword_info);

        # Prepare for a trailing #line directive to keep trailing line numbers straight...
        $line += $keyword_info{KeywordDeclaration} =~ tr/\n//;

        # Record the keyword definition...
        my $keyword_ID = $keyword_info{ID} = @keyword_impls;
        push @keyword_impls, \%keyword_info;

        # Create the keyword dispatching function...
        my $keyword_defn = _build_keyword_code(\%keyword_info);

        # Report installation of keyword if requested...
        if (${^H}{"Keyword::Declare debug"}) {
            my $msg = ("#" x 50) . "\n"
                      . " Installed keyword macro at $keyword_info{location}:\n\n$keyword_info{syntax}\n\n"
                      . ("#" x 50) . "\n";
            $msg =~ s{^}{###}gm;
            warn $msg;
        }

        # Install the keyword, exporting it as well if it's in an import() or unimport() sub...
        $$src_ref = qq{ if (((caller 0)[3]//q{}) =~ /\\b(?:un)?import\\Z/) { $keyword_defn } }
                  .  q{ Keyword::Declare::_install_data_handler(); }
                  . qq{ BEGIN{ $keyword_defn } }
                  . "\n#line $line $file\n"
                  . $$src_ref;

        # Pre-empt addition of extraneous trailing newline by Keyword::Simple...
        # [REMOVE IF UPSTREAM MODULE (Keyword::Simple) IS FIXED]
        $$src_ref =~ s{\n\z}{};
    };

    # Install the 'unkeyword' (anti-meta-)keyword...
    Keyword::Simple::define 'unkeyword', sub {
        # Unpack trailing code...
        my ($src_ref) = @_;

        # Where was this keyword declared???
        my ($file, $line) = (caller)[1,2];

        # Match and extract the keyword definition...
        use re 'eval';
        $$src_ref =~ s{
            \A
            (? (?&PerlNWS) )
            (?:
                (? (?&PerlIdentifier) )
            |
                (? \S+ )
            )

            $PPR::GRAMMAR
        }{}xms;

        my %keyword_info = %+;

        croak "Invalid unkeyword definition. Expected keyword name (identifier)\n"
            . " but found: $keyword_info{unexpected}"
                if defined $keyword_info{unexpected};

        # Check for excessive meta-ness...
        if ($keyword_info{keyword} =~ /^(?:keyword|keytype)$/) {
            croak "Can't undefine '$keyword_info{keyword}' keyword";
        }

        # Report installation of keyword if requested...
        if (${^H}{"Keyword::Declare debug"}) {
            my $msg = ("#" x 50) . "\n"
                      . " Uninstalled keyword macro: $keyword_info{keyword}(...)\n"
                      . " at $file line $line\n"
                      . ("#" x 50) . "\n";
            $msg =~ s{^}{###}gm;
            warn $msg;
        }

        # How to remove the Keyword::Simple keyword (with workaround for earlier versions)...
        my $keyword_defn = q{Keyword::Simple::undefine( 'KEYWORD' );};
        if ($Keyword::Simple::VERSION < 0.04) {
            $keyword_defn .= "\$^H{'Keyword::Simple/keywords'} =~ s{ KEYWORD:-?\\d*}{}g;" ;
        }

        # How to remove the Keyword::Declare keywords...
        $keyword_defn .= q{
            delete @^H{ grep m{^ Keyword::Declare \s+ active:KEYWORD:}xms, keys %^H };
        };
        $keyword_defn =~ s{KEYWORD}{$keyword_info{keyword}}g;

        # Uninstall the keyword, exporting it as well if it's in an import() or unimport() sub...
        $$src_ref = qq{ if (((caller 0)[3]//q{}) =~ /\\b(?:un)?import\\Z/) { $keyword_defn } }
                  . qq{ BEGIN{ $keyword_defn } }
                  . "\n#line $line $file\n"
                  . $$src_ref;
    };
}

# Keyword::Simple::define() has a bug: it can't define keywords starting with _
# [REMOVE WHEN UPSTREAM MODULE (Keyword::Simple) IS FIXED]
sub _replacement_define {
    package Keyword::Simple;

    my ($kw, $sub) = @_;
    $kw =~ /^[^\W\d]\w*\z/ or croak "'$kw' doesn't look like an identifier";
    ref($sub) eq 'CODE' or croak "'$sub' doesn't look like a coderef";

    if ($Keyword::Simple::VERSION < 0.04) {
        our @meta;
        my $n = @meta;
        push @meta, $sub;

        $^H{+HINTK_KEYWORDS} .= " $kw:$n";
        use B::Hooks::EndOfScope;
        on_scope_end {
            delete $meta[$n];
        };
    }
    else {
        my %keywords = %{$^H{+HINTK_KEYWORDS} // {}};
        $keywords{$kw} = $sub;
        $^H{+HINTK_KEYWORDS} = \%keywords;
    }
}

# Install a __DATA__ keyword to overcome bug in Keyword::Simple...
# [REMOVE WHEN UPSTREAM MODULE (Keyword::Simple) IS FIXED]
sub _install_data_handler {
    my $DATA_HANDLER = sub {
        # Unpack trailing code...
        my ($src_ref) = @_;

        # Convert to data handle...
        my $data = $$src_ref;
        $data =~ s{ \A [^\n]* \n }{}xms;
        $data .= "\n" unless substr($data,-1) eq "\n";

        # Create end-of-__DATA__ marker unlikely to be in the data...
        my $END_DATA = "\3" x 253;  # \3 is ASCII END-OF-TEXT, 253 is max ident length

        # Replace trailing code with code that opens a local *DATA handle...
        $$src_ref = qq{BEGIN {open *DATA, '<', \\<<'$END_DATA'\n$data$END_DATA\n} 1; };
    };
    _replacement_define('__DATA__', $DATA_HANDLER);
}


# Remove special prefix on names of internal named captures...
sub _deprefix {
    my ($hash_ref) = @_;

    return undef if !defined $hash_ref;
    return { map { my $key = $_; $key =~ s{^____K_D___}{}; $key => $hash_ref->{$_} }
                 keys %{$hash_ref} };
}


# Generate the source code that actually installs a keyword...
sub _build_keyword_code {
    my ($keyword_name, $keyword_sig, $keyword_ID, $keyword_block, $block_location, $block_hashline,  $prefix_var)
        = @{shift()}{qw< keyword sig_desc ID block location hashline prefix >};

    # Generate the keyword definition and set up its unique lexical ID...
    return qq{
        \$^H{"Keyword::Declare active:$keyword_name:\Q$keyword_sig\E"} = $keyword_ID;
        Keyword::Declare::_replacement_define('$keyword_name', Keyword::Declare::_get_dispatcher_for('$keyword_name',
            $keyword_ID, sub
#line $block_hashline
            { $keyword_impls[$keyword_ID]{sig_vars_unpack}  do $keyword_block }));
    };
}

# Locate prefix code for keyword...
sub _get_prefix {
    state $source_cache = {};

    my ($trail_ref, $keyword) = @_;

    my $filename = (caller 2)[1];
    my $source = $source_cache->{$filename} //= do { local (*ARGV, $/); @ARGV=$filename; <> };

    my $trailing = $$trail_ref;
    $trailing =~ s/\s+\z//;
    $source =~ s{\b$keyword\s*\Q$trailing\E\s*\z}{};

    return 'qq{' . quotemeta($source) . '}';
}


# Install keyword's source-code generator, and return a dispatcher sub for that keyword
# (building a closure for it, if necessary)...
sub _get_dispatcher_for {
    my ($keyword_name, $keyword_ID, $keyword_generator) = @_;

    # Install the keyword generator sub...
    $keyword_impls[$keyword_ID]{generator} = $keyword_generator;

    # This will dispatch any keyword of the specified name...
    state %dispatcher_for;
    return $dispatcher_for{$keyword_name} //= sub {
        my ($src_ref) = @_;
        my ($package, $file, $line) = caller;
        local $PPR::ERROR;

        # Which variants of this keyword are currently in scope???
        my @candidate_IDs = @^H{ grep { m{^ Keyword::Declare \s+ active:$keyword_name:}xms } keys %^H };

        # Which keywords are allowed in nested code at this point...
        my @active_IDs = @^H{ grep { m{^ Keyword::Declare \s+ active:}xms } keys %^H };
        my $lexical_keywords
            = @active_IDs ? join '|', reverse sort map { $keyword_impls[$_]{skip_matcher} } @active_IDs
            :               '(?!)';
        $lexical_keywords = "(?(DEFINE) (? $lexical_keywords ) )";

        # Which of them match the keyword's actual arguments???
        my @viable_IDs
            = grep { $$src_ref =~ m{ \A $keyword_impls[$_]{sig_matcher} $lexical_keywords $PPR::GRAMMAR }xms }
                   @candidate_IDs;


        # If none of them match...game over!!!
        if (!@viable_IDs) {
            my $error = eval "no strict;sub{\n" . ($PPR::ERROR//q{}) . '}'
                            ? "    $keyword_name  "
                                 . do{ my $src = $$src_ref;
                                       $src =~ s{ \A \s*+ (\S++ [^\n]*+) \n .* }{$1}xs;
                                       $src;
                                   }
                            : do{ my $err = $@;
                                  $err =~ s{^}{    }gm;
                                  $err =~ s{\(eval \d++\) line \d++}
                                           { "$file line " . $PPR::ERROR->line($line) }eg;
                                  $err
                                };
            croak "Invalid "
                . join(" or ", uniqstr map { $keyword_impls[$_]{desc} } @candidate_IDs)
                . " at $file line $line.\nExpected:"
                . join("\n    ", q{}, uniqstr map { $keyword_impls[$_]{syntax} } @candidate_IDs)
                . "\nbut found:\n$error"
                . "\nCompilation failed";
        }

        # If too many of them match...see if we can reduce it to a single match...
        if (@viable_IDs > 1) {
            # Only keep those with the most parameters...
            my $max_sig_len = max map { $keyword_impls[$_]{sig_len} } @viable_IDs;
            @viable_IDs = grep { $keyword_impls[$_]{sig_len} == $max_sig_len } @viable_IDs;

            # Resolve ambiguous matches, if possible...
            if (@viable_IDs > 1) {
                @viable_IDs = _resolve_matches(@viable_IDs);
            }

            # If still too many, see if one is marked :prefer...
            if (@viable_IDs > 1) {
                if (my @preferred_IDs = grep { $keyword_impls[$_]{prefer} } @viable_IDs) {
                    @viable_IDs = @preferred_IDs;
                }
            }

            # If still too many, give up and report the ambiguity...
            if (@viable_IDs > 1) {
                croak "Ambiguous "
                    . join(" or ", uniqstr map { $keyword_impls[$_]{desc} } @viable_IDs)
                    . " at $file line $line:\n    $keyword_name  "
                    . do{ my $src = $$src_ref;
                          $src =~ s{ \A \s*+ ( \S++ [^\n]*+) \n .* }{$1}xs;
                          $src;
                        }
                    . "\nCould be:\n"
                    . join("\n", map { "    $keyword_impls[$_]{syntax}" } @viable_IDs)
                    . "\nCompilation failed";
            }
        }

        # If we get here, we have a unique best candidate, so install it...
        my ($ID) = @viable_IDs;

        # Add in the replacement code...
        _insert_replacement_code($src_ref, $ID, $file, $line, $lexical_keywords);
    }
}

# These help unpack /.../ type specifiers...
my $REGEX_TYPE = qr{ \A (?&PerlMatch) \z $PPR::GRAMMAR }x;

my $REGEX_PAT = qr{
        \A
        (?: (? / ) | m \s* (? \S ))
        (? .* )
        (?: \k | [])>\}] )
        (? [imnsxadlup]*+ )
        \z
    }xs;

my %ACTUAL_TYPE_OF = (
  # Specified type...                         # Translated to...


# Autogenerated type translations (from bin/gen_types.pl)...

    'ArrayIndexer'                               => '/(?&PerlArrayIndexer)/',
    'AssignmentOperator'                         => '/(?&PerlAssignmentOperator)/',
    'Attributes'                                 => '/(?&PerlAttributes)/',
    'Comma'                                      => '/(?&PerlComma)/',
    'Document'                                   => '/(?&PerlDocument)/',
    'HashIndexer'                                => '/(?&PerlHashIndexer)/',
    'InfixBinaryOperator'                        => '/(?&PerlInfixBinaryOperator)/',
    'LowPrecedenceInfixOperator'                 => '/(?&PerlLowPrecedenceInfixOperator)/',
    'OWS'                                        => '/(?&PerlOWS)/',
    'PostfixUnaryOperator'                       => '/(?&PerlPostfixUnaryOperator)/',
    'PrefixUnaryOperator'                        => '/(?&PerlPrefixUnaryOperator)/',
    'StatementModifier'                          => '/(?&PerlStatementModifier)/',
    'NWS'                                        => '/(?&PerlNWS)/',
    'Whitespace'                                 => '/(?&PerlNWS)/',
    'Statement'                                  => '/(?&PerlStatement)/',
    'Block'                                      => '/(?&PerlBlock)/',
    'Comment'                                    => '/(?&PerlComment)/',
    'ControlBlock'                               => '/(?&PerlControlBlock)/',
    'Expression'                                 => '/(?&PerlExpression)/',
    'Expr'                                       => '/(?&PerlExpression)/',
    'Format'                                     => '/(?&PerlFormat)/',
    'Keyword'                                    => '/(?&PerlKeyword)/',
    'Label'                                      => '/(?&PerlLabel)/',
    'PackageDeclaration'                         => '/(?&PerlPackageDeclaration)/',
    'Pod'                                        => '/(?&PerlPod)/',
    'SubroutineDeclaration'                      => '/(?&PerlSubroutineDeclaration)/',
    'UseStatement'                               => '/(?&PerlUseStatement)/',
    'LowPrecedenceNotExpression'                 => '/(?&PerlLowPrecedenceNotExpression)/',
    'List'                                       => '/(?&PerlList)/',
    'CommaList'                                  => '/(?&PerlCommaList)/',
    'Assignment'                                 => '/(?&PerlAssignment)/',
    'ConditionalExpression'                      => '/(?&PerlConditionalExpression)/',
    'Ternary'                                    => '/(?&PerlConditionalExpression)/',
    'ListElem'                                   => '/(?&PerlConditionalExpression)/',
    'BinaryExpression'                           => '/(?&PerlBinaryExpression)/',
    'PrefixPostfixTerm'                          => '/(?&PerlPrefixPostfixTerm)/',
    'Term'                                       => '/(?&PerlTerm)/',
    'AnonymousArray'                             => '/(?&PerlAnonymousArray)/',
    'AnonArray'                                  => '/(?&PerlAnonymousArray)/',
    'AnonymousHash'                              => '/(?&PerlAnonymousHash)/',
    'AnonHash'                                   => '/(?&PerlAnonymousHash)/',
    'AnonymousSubroutine'                        => '/(?&PerlAnonymousSubroutine)/',
    'Call'                                       => '/(?&PerlCall)/',
    'DiamondOperator'                            => '/(?&PerlDiamondOperator)/',
    'DoBlock'                                    => '/(?&PerlDoBlock)/',
    'EvalBlock'                                  => '/(?&PerlEvalBlock)/',
    'Literal'                                    => '/(?&PerlLiteral)/',
    'Lvalue'                                     => '/(?&PerlLvalue)/',
    'ParenthesesList'                            => '/(?&PerlParenthesesList)/',
    'ParensList'                                 => '/(?&PerlParenthesesList)/',
    'Quotelike'                                  => '/(?&PerlQuotelike)/',
    'ReturnStatement'                            => '/(?&PerlReturnStatement)/',
    'Typeglob'                                   => '/(?&PerlTypeglob)/',
    'VariableDeclaration'                        => '/(?&PerlVariableDeclaration)/',
    'VarDecl'                                    => '/(?&PerlVariableDeclaration)/',
    'Variable'                                   => '/(?&PerlVariable)/',
    'Var'                                        => '/(?&PerlVariable)/',
    'ArrayAccess'                                => '/(?&PerlArrayAccess)/',
    'Bareword'                                   => '/(?&PerlBareword)/',
    'BuiltinFunction'                            => '/(?&PerlBuiltinFunction)/',
    'HashAccess'                                 => '/(?&PerlHashAccess)/',
    'Number'                                     => '/(?&PerlNumber)/',
    'Num'                                        => '/(?&PerlNumber)/',
    'QuotelikeQW'                                => '/(?&PerlQuotelikeQW)/',
    'QuotelikeQX'                                => '/(?&PerlQuotelikeQX)/',
    'Regex'                                      => '/(?&PerlRegex)/',
    'Regexp'                                     => '/(?&PerlRegex)/',
    'ScalarAccess'                               => '/(?&PerlScalarAccess)/',
    'String'                                     => '/(?&PerlString)/',
    'Str'                                        => '/(?&PerlString)/',
    'Substitution'                               => '/(?&PerlSubstitution)/',
    'QuotelikeS'                                 => '/(?&PerlSubstitution)/',
    'Transliteration'                            => '/(?&PerlTransliteration)/',
    'QuotelikeTR'                                => '/(?&PerlTransliteration)/',
    'ContextualRegex'                            => '/(?&PerlContextualRegex)/',
    'Heredoc'                                    => '/(?&PerlHeredoc)/',
    'Integer'                                    => '/(?&PerlInteger)/',
    'Int'                                        => '/(?&PerlInteger)/',
    'Match'                                      => '/(?&PerlMatch)/',
    'QuotelikeM'                                 => '/(?&PerlMatch)/',
    'NullaryBuiltinFunction'                     => '/(?&PerlNullaryBuiltinFunction)/',
    'OldQualifiedIdentifier'                     => '/(?&PerlOldQualifiedIdentifier)/',
    'QuotelikeQ'                                 => '/(?&PerlQuotelikeQ)/',
    'QuotelikeQQ'                                => '/(?&PerlQuotelikeQQ)/',
    'QuotelikeQR'                                => '/(?&PerlQuotelikeQR)/',
    'VString'                                    => '/(?&PerlVString)/',
    'VariableArray'                              => '/(?&PerlVariableArray)/',
    'VarArray'                                   => '/(?&PerlVariableArray)/',
    'ArrayVar'                                   => '/(?&PerlVariableArray)/',
    'VariableHash'                               => '/(?&PerlVariableHash)/',
    'VarHash'                                    => '/(?&PerlVariableHash)/',
    'HashVar'                                    => '/(?&PerlVariableHash)/',
    'VariableScalar'                             => '/(?&PerlVariableScalar)/',
    'VarScalar'                                  => '/(?&PerlVariableScalar)/',
    'ScalarVar'                                  => '/(?&PerlVariableScalar)/',
    'VersionNumber'                              => '/(?&PerlVersionNumber)/',
    'ContextualMatch'                            => '/(?&PerlContextualMatch)/',
    'ContextualQuotelikeM'                       => '/(?&PerlContextualMatch)/',
    'PositiveInteger'                            => '/(?&PerlPositiveInteger)/',
    'PosInt'                                     => '/(?&PerlPositiveInteger)/',
    'QualifiedIdentifier'                        => '/(?&PerlQualifiedIdentifier)/',
    'QualIdent'                                  => '/(?&PerlQualifiedIdentifier)/',
    'QuotelikeQR'                                => '/(?&PerlQuotelikeQR)/',
    'VString'                                    => '/(?&PerlVString)/',
    'Identifier'                                 => '/(?&PerlIdentifier)/',
    'Ident'                                      => '/(?&PerlIdentifier)/',

# End of autogenerated type translations

    'Integer'                                => '/(?:[+-]?+(?&PPR_digit_seq)(?!\.))/',
    'Int'                                    => '/(?:[+-]?+(?&PPR_digit_seq)(?!\.))/',
    'PositiveInteger'                        => '/(?:[+]?+(?&PPR_digit_seq)(?!\.))/',
    'PosInt'                                 => '/(?:[+]?+(?&PPR_digit_seq)(?!\.))/',
    'Comment'                                => '/\#[^\n]*\n/',
);

our %isa = (

# Autogenerated type ISA hierarchy (from bin/gen_types.pl)...

"AnonArray\34Assignment"=>1,"AnonArray\34BinaryExpression"=>1,"AnonArray\34CommaList"=>1,"AnonArray\34ConditionalExpression"=>1,"AnonArray\34Document"=>1,"AnonArray\34Expr"=>1,"AnonArray\34Expression"=>1,"AnonArray\34List"=>1,"AnonArray\34ListElem"=>1,"AnonArray\34LowPrecedenceNotExpression"=>1,"AnonArray\34PrefixPostfixTerm"=>1,"AnonArray\34Statement"=>1,"AnonArray\34Term"=>1,"AnonArray\34Ternary"=>1,"AnonHash\34Assignment"=>1,"AnonHash\34BinaryExpression"=>1,"AnonHash\34CommaList"=>1,"AnonHash\34ConditionalExpression"=>1,"AnonHash\34Document"=>1,"AnonHash\34Expr"=>1,"AnonHash\34Expression"=>1,"AnonHash\34List"=>1,"AnonHash\34ListElem"=>1,"AnonHash\34LowPrecedenceNotExpression"=>1,"AnonHash\34PrefixPostfixTerm"=>1,"AnonHash\34Statement"=>1,"AnonHash\34Term"=>1,"AnonHash\34Ternary"=>1,"AnonymousArray\34Assignment"=>1,"AnonymousArray\34BinaryExpression"=>1,"AnonymousArray\34CommaList"=>1,"AnonymousArray\34ConditionalExpression"=>1,"AnonymousArray\34Document"=>1,"AnonymousArray\34Expr"=>1,"AnonymousArray\34Expression"=>1,"AnonymousArray\34List"=>1,"AnonymousArray\34ListElem"=>1,"AnonymousArray\34LowPrecedenceNotExpression"=>1,"AnonymousArray\34PrefixPostfixTerm"=>1,"AnonymousArray\34Statement"=>1,"AnonymousArray\34Term"=>1,"AnonymousArray\34Ternary"=>1,"AnonymousHash\34Assignment"=>1,"AnonymousHash\34BinaryExpression"=>1,"AnonymousHash\34CommaList"=>1,"AnonymousHash\34ConditionalExpression"=>1,"AnonymousHash\34Document"=>1,"AnonymousHash\34Expr"=>1,"AnonymousHash\34Expression"=>1,"AnonymousHash\34List"=>1,"AnonymousHash\34ListElem"=>1,"AnonymousHash\34LowPrecedenceNotExpression"=>1,"AnonymousHash\34PrefixPostfixTerm"=>1,"AnonymousHash\34Statement"=>1,"AnonymousHash\34Term"=>1,"AnonymousHash\34Ternary"=>1,"AnonymousSubroutine\34Assignment"=>1,"AnonymousSubroutine\34BinaryExpression"=>1,"AnonymousSubroutine\34CommaList"=>1,"AnonymousSubroutine\34ConditionalExpression"=>1,"AnonymousSubroutine\34Document"=>1,"AnonymousSubroutine\34Expr"=>1,"AnonymousSubroutine\34Expression"=>1,"AnonymousSubroutine\34List"=>1,"AnonymousSubroutine\34ListElem"=>1,"AnonymousSubroutine\34LowPrecedenceNotExpression"=>1,"AnonymousSubroutine\34PrefixPostfixTerm"=>1,"AnonymousSubroutine\34Statement"=>1,"AnonymousSubroutine\34Term"=>1,"AnonymousSubroutine\34Ternary"=>1,"ArrayAccess\34Assignment"=>1,"ArrayAccess\34BinaryExpression"=>1,"ArrayAccess\34CommaList"=>1,"ArrayAccess\34ConditionalExpression"=>1,"ArrayAccess\34Document"=>1,"ArrayAccess\34Expr"=>1,"ArrayAccess\34Expression"=>1,"ArrayAccess\34List"=>1,"ArrayAccess\34ListElem"=>1,"ArrayAccess\34LowPrecedenceNotExpression"=>1,"ArrayAccess\34PrefixPostfixTerm"=>1,"ArrayAccess\34Statement"=>1,"ArrayAccess\34Term"=>1,"ArrayAccess\34Ternary"=>1,"ArrayAccess\34Var"=>1,"ArrayAccess\34Variable"=>1,"ArrayVar\34ArrayAccess"=>1,"ArrayVar\34Assignment"=>1,"ArrayVar\34BinaryExpression"=>1,"ArrayVar\34CommaList"=>1,"ArrayVar\34ConditionalExpression"=>1,"ArrayVar\34Document"=>1,"ArrayVar\34Expr"=>1,"ArrayVar\34Expression"=>1,"ArrayVar\34List"=>1,"ArrayVar\34ListElem"=>1,"ArrayVar\34LowPrecedenceNotExpression"=>1,"ArrayVar\34PrefixPostfixTerm"=>1,"ArrayVar\34Statement"=>1,"ArrayVar\34Term"=>1,"ArrayVar\34Ternary"=>1,"ArrayVar\34Var"=>1,"ArrayVar\34Variable"=>1,"Assignment\34CommaList"=>1,"Assignment\34Document"=>1,"Assignment\34Expr"=>1,"Assignment\34Expression"=>1,"Assignment\34List"=>1,"Assignment\34LowPrecedenceNotExpression"=>1,"Assignment\34Statement"=>1,"Bareword\34Assignment"=>1,"Bareword\34BinaryExpression"=>1,"Bareword\34CommaList"=>1,"Bareword\34ConditionalExpression"=>1,"Bareword\34Document"=>1,"Bareword\34Expr"=>1,"Bareword\34Expression"=>1,"Bareword\34List"=>1,"Bareword\34ListElem"=>1,"Bareword\34Literal"=>1,"Bareword\34LowPrecedenceNotExpression"=>1,"Bareword\34PrefixPostfixTerm"=>1,"Bareword\34Statement"=>1,"Bareword\34Term"=>1,"Bareword\34Ternary"=>1,"BinaryExpression\34Assignment"=>1,"BinaryExpression\34CommaList"=>1,"BinaryExpression\34ConditionalExpression"=>1,"BinaryExpression\34Document"=>1,"BinaryExpression\34Expr"=>1,"BinaryExpression\34Expression"=>1,"BinaryExpression\34List"=>1,"BinaryExpression\34ListElem"=>1,"BinaryExpression\34LowPrecedenceNotExpression"=>1,"BinaryExpression\34Statement"=>1,"BinaryExpression\34Ternary"=>1,"Block\34Document"=>1,"Block\34Statement"=>1,"BuiltinFunction\34Assignment"=>1,"BuiltinFunction\34BinaryExpression"=>1,"BuiltinFunction\34Call"=>1,"BuiltinFunction\34CommaList"=>1,"BuiltinFunction\34ConditionalExpression"=>1,"BuiltinFunction\34Document"=>1,"BuiltinFunction\34Expr"=>1,"BuiltinFunction\34Expression"=>1,"BuiltinFunction\34List"=>1,"BuiltinFunction\34ListElem"=>1,"BuiltinFunction\34LowPrecedenceNotExpression"=>1,"BuiltinFunction\34PrefixPostfixTerm"=>1,"BuiltinFunction\34Statement"=>1,"BuiltinFunction\34Term"=>1,"BuiltinFunction\34Ternary"=>1,"Call\34Assignment"=>1,"Call\34BinaryExpression"=>1,"Call\34CommaList"=>1,"Call\34ConditionalExpression"=>1,"Call\34Document"=>1,"Call\34Expr"=>1,"Call\34Expression"=>1,"Call\34List"=>1,"Call\34ListElem"=>1,"Call\34LowPrecedenceNotExpression"=>1,"Call\34PrefixPostfixTerm"=>1,"Call\34Statement"=>1,"Call\34Term"=>1,"Call\34Ternary"=>1,"CommaList\34Document"=>1,"CommaList\34Expr"=>1,"CommaList\34Expression"=>1,"CommaList\34List"=>1,"CommaList\34LowPrecedenceNotExpression"=>1,"CommaList\34Statement"=>1,"Comment\34NWS"=>1,"Comment\34OWS"=>1,"Comment\34Whitespace"=>1,"ConditionalExpression\34Assignment"=>1,"ConditionalExpression\34CommaList"=>1,"ConditionalExpression\34Document"=>1,"ConditionalExpression\34Expr"=>1,"ConditionalExpression\34Expression"=>1,"ConditionalExpression\34List"=>1,"ConditionalExpression\34LowPrecedenceNotExpression"=>1,"ConditionalExpression\34Statement"=>1,"ContextualMatch\34Assignment"=>1,"ContextualMatch\34BinaryExpression"=>1,"ContextualMatch\34CommaList"=>1,"ContextualMatch\34ConditionalExpression"=>1,"ContextualMatch\34ContextualRegex"=>1,"ContextualMatch\34Document"=>1,"ContextualMatch\34Expr"=>1,"ContextualMatch\34Expression"=>1,"ContextualMatch\34List"=>1,"ContextualMatch\34ListElem"=>1,"ContextualMatch\34LowPrecedenceNotExpression"=>1,"ContextualMatch\34Match"=>1,"ContextualMatch\34PrefixPostfixTerm"=>1,"ContextualMatch\34Quotelike"=>1,"ContextualMatch\34QuotelikeM"=>1,"ContextualMatch\34Regex"=>1,"ContextualMatch\34Regexp"=>1,"ContextualMatch\34Statement"=>1,"ContextualMatch\34Term"=>1,"ContextualMatch\34Ternary"=>1,"ContextualQuotelikeM\34Assignment"=>1,"ContextualQuotelikeM\34BinaryExpression"=>1,"ContextualQuotelikeM\34CommaList"=>1,"ContextualQuotelikeM\34ConditionalExpression"=>1,"ContextualQuotelikeM\34ContextualRegex"=>1,"ContextualQuotelikeM\34Document"=>1,"ContextualQuotelikeM\34Expr"=>1,"ContextualQuotelikeM\34Expression"=>1,"ContextualQuotelikeM\34List"=>1,"ContextualQuotelikeM\34ListElem"=>1,"ContextualQuotelikeM\34LowPrecedenceNotExpression"=>1,"ContextualQuotelikeM\34Match"=>1,"ContextualQuotelikeM\34PrefixPostfixTerm"=>1,"ContextualQuotelikeM\34Quotelike"=>1,"ContextualQuotelikeM\34QuotelikeM"=>1,"ContextualQuotelikeM\34Regex"=>1,"ContextualQuotelikeM\34Regexp"=>1,"ContextualQuotelikeM\34Statement"=>1,"ContextualQuotelikeM\34Term"=>1,"ContextualQuotelikeM\34Ternary"=>1,"ContextualRegex\34Assignment"=>1,"ContextualRegex\34BinaryExpression"=>1,"ContextualRegex\34CommaList"=>1,"ContextualRegex\34ConditionalExpression"=>1,"ContextualRegex\34Document"=>1,"ContextualRegex\34Expr"=>1,"ContextualRegex\34Expression"=>1,"ContextualRegex\34List"=>1,"ContextualRegex\34ListElem"=>1,"ContextualRegex\34LowPrecedenceNotExpression"=>1,"ContextualRegex\34PrefixPostfixTerm"=>1,"ContextualRegex\34Quotelike"=>1,"ContextualRegex\34Regex"=>1,"ContextualRegex\34Regexp"=>1,"ContextualRegex\34Statement"=>1,"ContextualRegex\34Term"=>1,"ContextualRegex\34Ternary"=>1,"ControlBlock\34Document"=>1,"ControlBlock\34Statement"=>1,"DiamondOperator\34Assignment"=>1,"DiamondOperator\34BinaryExpression"=>1,"DiamondOperator\34CommaList"=>1,"DiamondOperator\34ConditionalExpression"=>1,"DiamondOperator\34Document"=>1,"DiamondOperator\34Expr"=>1,"DiamondOperator\34Expression"=>1,"DiamondOperator\34List"=>1,"DiamondOperator\34ListElem"=>1,"DiamondOperator\34LowPrecedenceNotExpression"=>1,"DiamondOperator\34PrefixPostfixTerm"=>1,"DiamondOperator\34Statement"=>1,"DiamondOperator\34Term"=>1,"DiamondOperator\34Ternary"=>1,"DoBlock\34Assignment"=>1,"DoBlock\34BinaryExpression"=>1,"DoBlock\34CommaList"=>1,"DoBlock\34ConditionalExpression"=>1,"DoBlock\34Document"=>1,"DoBlock\34Expr"=>1,"DoBlock\34Expression"=>1,"DoBlock\34List"=>1,"DoBlock\34ListElem"=>1,"DoBlock\34LowPrecedenceNotExpression"=>1,"DoBlock\34PrefixPostfixTerm"=>1,"DoBlock\34Statement"=>1,"DoBlock\34Term"=>1,"DoBlock\34Ternary"=>1,"EvalBlock\34Assignment"=>1,"EvalBlock\34BinaryExpression"=>1,"EvalBlock\34CommaList"=>1,"EvalBlock\34ConditionalExpression"=>1,"EvalBlock\34Document"=>1,"EvalBlock\34Expr"=>1,"EvalBlock\34Expression"=>1,"EvalBlock\34List"=>1,"EvalBlock\34ListElem"=>1,"EvalBlock\34LowPrecedenceNotExpression"=>1,"EvalBlock\34PrefixPostfixTerm"=>1,"EvalBlock\34Statement"=>1,"EvalBlock\34Term"=>1,"EvalBlock\34Ternary"=>1,"Expr\34Document"=>1,"Expr\34Statement"=>1,"Expression\34Document"=>1,"Expression\34Statement"=>1,"Format\34Document"=>1,"Format\34Statement"=>1,"HashAccess\34Assignment"=>1,"HashAccess\34BinaryExpression"=>1,"HashAccess\34CommaList"=>1,"HashAccess\34ConditionalExpression"=>1,"HashAccess\34Document"=>1,"HashAccess\34Expr"=>1,"HashAccess\34Expression"=>1,"HashAccess\34List"=>1,"HashAccess\34ListElem"=>1,"HashAccess\34LowPrecedenceNotExpression"=>1,"HashAccess\34PrefixPostfixTerm"=>1,"HashAccess\34Statement"=>1,"HashAccess\34Term"=>1,"HashAccess\34Ternary"=>1,"HashAccess\34Var"=>1,"HashAccess\34Variable"=>1,"HashVar\34Assignment"=>1,"HashVar\34BinaryExpression"=>1,"HashVar\34CommaList"=>1,"HashVar\34ConditionalExpression"=>1,"HashVar\34Document"=>1,"HashVar\34Expr"=>1,"HashVar\34Expression"=>1,"HashVar\34HashAccess"=>1,"HashVar\34List"=>1,"HashVar\34ListElem"=>1,"HashVar\34LowPrecedenceNotExpression"=>1,"HashVar\34PrefixPostfixTerm"=>1,"HashVar\34Statement"=>1,"HashVar\34Term"=>1,"HashVar\34Ternary"=>1,"HashVar\34Var"=>1,"HashVar\34Variable"=>1,"Heredoc\34Assignment"=>1,"Heredoc\34BinaryExpression"=>1,"Heredoc\34CommaList"=>1,"Heredoc\34ConditionalExpression"=>1,"Heredoc\34Document"=>1,"Heredoc\34Expr"=>1,"Heredoc\34Expression"=>1,"Heredoc\34List"=>1,"Heredoc\34ListElem"=>1,"Heredoc\34Literal"=>1,"Heredoc\34LowPrecedenceNotExpression"=>1,"Heredoc\34PrefixPostfixTerm"=>1,"Heredoc\34Statement"=>1,"Heredoc\34Str"=>1,"Heredoc\34String"=>1,"Heredoc\34Term"=>1,"Heredoc\34Ternary"=>1,"Ident\34Assignment"=>1,"Ident\34Bareword"=>1,"Ident\34BinaryExpression"=>1,"Ident\34CommaList"=>1,"Ident\34ConditionalExpression"=>1,"Ident\34Document"=>1,"Ident\34Expr"=>1,"Ident\34Expression"=>1,"Ident\34List"=>1,"Ident\34ListElem"=>1,"Ident\34Literal"=>1,"Ident\34LowPrecedenceNotExpression"=>1,"Ident\34OldQualifiedIdentifier"=>1,"Ident\34PrefixPostfixTerm"=>1,"Ident\34QualIdent"=>1,"Ident\34QualifiedIdentifier"=>1,"Ident\34Statement"=>1,"Ident\34Term"=>1,"Ident\34Ternary"=>1,"Identifier\34Assignment"=>1,"Identifier\34Bareword"=>1,"Identifier\34BinaryExpression"=>1,"Identifier\34CommaList"=>1,"Identifier\34ConditionalExpression"=>1,"Identifier\34Document"=>1,"Identifier\34Expr"=>1,"Identifier\34Expression"=>1,"Identifier\34List"=>1,"Identifier\34ListElem"=>1,"Identifier\34Literal"=>1,"Identifier\34LowPrecedenceNotExpression"=>1,"Identifier\34OldQualifiedIdentifier"=>1,"Identifier\34PrefixPostfixTerm"=>1,"Identifier\34QualIdent"=>1,"Identifier\34QualifiedIdentifier"=>1,"Identifier\34Statement"=>1,"Identifier\34Term"=>1,"Identifier\34Ternary"=>1,"Int\34Assignment"=>1,"Int\34BinaryExpression"=>1,"Int\34CommaList"=>1,"Int\34ConditionalExpression"=>1,"Int\34Document"=>1,"Int\34Expr"=>1,"Int\34Expression"=>1,"Int\34List"=>1,"Int\34ListElem"=>1,"Int\34Literal"=>1,"Int\34LowPrecedenceNotExpression"=>1,"Int\34Num"=>1,"Int\34Number"=>1,"Int\34PrefixPostfixTerm"=>1,"Int\34Statement"=>1,"Int\34Term"=>1,"Int\34Ternary"=>1,"Integer\34Assignment"=>1,"Integer\34BinaryExpression"=>1,"Integer\34CommaList"=>1,"Integer\34ConditionalExpression"=>1,"Integer\34Document"=>1,"Integer\34Expr"=>1,"Integer\34Expression"=>1,"Integer\34List"=>1,"Integer\34ListElem"=>1,"Integer\34Literal"=>1,"Integer\34LowPrecedenceNotExpression"=>1,"Integer\34Num"=>1,"Integer\34Number"=>1,"Integer\34PrefixPostfixTerm"=>1,"Integer\34Statement"=>1,"Integer\34Term"=>1,"Integer\34Ternary"=>1,"Keyword\34Document"=>1,"Keyword\34Statement"=>1,"Label\34Document"=>1,"Label\34Statement"=>1,"List\34Document"=>1,"List\34Expr"=>1,"List\34Expression"=>1,"List\34LowPrecedenceNotExpression"=>1,"List\34Statement"=>1,"ListElem\34Assignment"=>1,"ListElem\34CommaList"=>1,"ListElem\34Document"=>1,"ListElem\34Expr"=>1,"ListElem\34Expression"=>1,"ListElem\34List"=>1,"ListElem\34LowPrecedenceNotExpression"=>1,"ListElem\34Statement"=>1,"Literal\34Assignment"=>1,"Literal\34BinaryExpression"=>1,"Literal\34CommaList"=>1,"Literal\34ConditionalExpression"=>1,"Literal\34Document"=>1,"Literal\34Expr"=>1,"Literal\34Expression"=>1,"Literal\34List"=>1,"Literal\34ListElem"=>1,"Literal\34LowPrecedenceNotExpression"=>1,"Literal\34PrefixPostfixTerm"=>1,"Literal\34Statement"=>1,"Literal\34Term"=>1,"Literal\34Ternary"=>1,"LowPrecedenceNotExpression\34Document"=>1,"LowPrecedenceNotExpression\34Expr"=>1,"LowPrecedenceNotExpression\34Expression"=>1,"LowPrecedenceNotExpression\34Statement"=>1,"Lvalue\34Assignment"=>1,"Lvalue\34BinaryExpression"=>1,"Lvalue\34CommaList"=>1,"Lvalue\34ConditionalExpression"=>1,"Lvalue\34Document"=>1,"Lvalue\34Expr"=>1,"Lvalue\34Expression"=>1,"Lvalue\34List"=>1,"Lvalue\34ListElem"=>1,"Lvalue\34LowPrecedenceNotExpression"=>1,"Lvalue\34PrefixPostfixTerm"=>1,"Lvalue\34Statement"=>1,"Lvalue\34Term"=>1,"Lvalue\34Ternary"=>1,"Match\34Assignment"=>1,"Match\34BinaryExpression"=>1,"Match\34CommaList"=>1,"Match\34ConditionalExpression"=>1,"Match\34Document"=>1,"Match\34Expr"=>1,"Match\34Expression"=>1,"Match\34List"=>1,"Match\34ListElem"=>1,"Match\34LowPrecedenceNotExpression"=>1,"Match\34PrefixPostfixTerm"=>1,"Match\34Quotelike"=>1,"Match\34Regex"=>1,"Match\34Regexp"=>1,"Match\34Statement"=>1,"Match\34Term"=>1,"Match\34Ternary"=>1,"NullaryBuiltinFunction\34Assignment"=>1,"NullaryBuiltinFunction\34BinaryExpression"=>1,"NullaryBuiltinFunction\34BuiltinFunction"=>1,"NullaryBuiltinFunction\34Call"=>1,"NullaryBuiltinFunction\34CommaList"=>1,"NullaryBuiltinFunction\34ConditionalExpression"=>1,"NullaryBuiltinFunction\34Document"=>1,"NullaryBuiltinFunction\34Expr"=>1,"NullaryBuiltinFunction\34Expression"=>1,"NullaryBuiltinFunction\34List"=>1,"NullaryBuiltinFunction\34ListElem"=>1,"NullaryBuiltinFunction\34LowPrecedenceNotExpression"=>1,"NullaryBuiltinFunction\34PrefixPostfixTerm"=>1,"NullaryBuiltinFunction\34Statement"=>1,"NullaryBuiltinFunction\34Term"=>1,"NullaryBuiltinFunction\34Ternary"=>1,"Num\34Assignment"=>1,"Num\34BinaryExpression"=>1,"Num\34CommaList"=>1,"Num\34ConditionalExpression"=>1,"Num\34Document"=>1,"Num\34Expr"=>1,"Num\34Expression"=>1,"Num\34List"=>1,"Num\34ListElem"=>1,"Num\34Literal"=>1,"Num\34LowPrecedenceNotExpression"=>1,"Num\34PrefixPostfixTerm"=>1,"Num\34Statement"=>1,"Num\34Term"=>1,"Num\34Ternary"=>1,"Number\34Assignment"=>1,"Number\34BinaryExpression"=>1,"Number\34CommaList"=>1,"Number\34ConditionalExpression"=>1,"Number\34Document"=>1,"Number\34Expr"=>1,"Number\34Expression"=>1,"Number\34List"=>1,"Number\34ListElem"=>1,"Number\34Literal"=>1,"Number\34LowPrecedenceNotExpression"=>1,"Number\34PrefixPostfixTerm"=>1,"Number\34Statement"=>1,"Number\34Term"=>1,"Number\34Ternary"=>1,"NWS\34OWS"=>1,"OldQualifiedIdentifier\34Assignment"=>1,"OldQualifiedIdentifier\34Bareword"=>1,"OldQualifiedIdentifier\34BinaryExpression"=>1,"OldQualifiedIdentifier\34CommaList"=>1,"OldQualifiedIdentifier\34ConditionalExpression"=>1,"OldQualifiedIdentifier\34Document"=>1,"OldQualifiedIdentifier\34Expr"=>1,"OldQualifiedIdentifier\34Expression"=>1,"OldQualifiedIdentifier\34List"=>1,"OldQualifiedIdentifier\34ListElem"=>1,"OldQualifiedIdentifier\34Literal"=>1,"OldQualifiedIdentifier\34LowPrecedenceNotExpression"=>1,"OldQualifiedIdentifier\34PrefixPostfixTerm"=>1,"OldQualifiedIdentifier\34Statement"=>1,"OldQualifiedIdentifier\34Term"=>1,"OldQualifiedIdentifier\34Ternary"=>1,"PackageDeclaration\34Document"=>1,"PackageDeclaration\34Statement"=>1,"ParensList\34Assignment"=>1,"ParensList\34BinaryExpression"=>1,"ParensList\34CommaList"=>1,"ParensList\34ConditionalExpression"=>1,"ParensList\34Document"=>1,"ParensList\34Expr"=>1,"ParensList\34Expression"=>1,"ParensList\34List"=>1,"ParensList\34ListElem"=>1,"ParensList\34LowPrecedenceNotExpression"=>1,"ParensList\34PrefixPostfixTerm"=>1,"ParensList\34Statement"=>1,"ParensList\34Term"=>1,"ParensList\34Ternary"=>1,"ParenthesesList\34Assignment"=>1,"ParenthesesList\34BinaryExpression"=>1,"ParenthesesList\34CommaList"=>1,"ParenthesesList\34ConditionalExpression"=>1,"ParenthesesList\34Document"=>1,"ParenthesesList\34Expr"=>1,"ParenthesesList\34Expression"=>1,"ParenthesesList\34List"=>1,"ParenthesesList\34ListElem"=>1,"ParenthesesList\34LowPrecedenceNotExpression"=>1,"ParenthesesList\34PrefixPostfixTerm"=>1,"ParenthesesList\34Statement"=>1,"ParenthesesList\34Term"=>1,"ParenthesesList\34Ternary"=>1,"Pod\34NWS"=>1,"Pod\34OWS"=>1,"Pod\34Whitespace"=>1,"PosInt\34Assignment"=>1,"PosInt\34BinaryExpression"=>1,"PosInt\34CommaList"=>1,"PosInt\34ConditionalExpression"=>1,"PosInt\34Document"=>1,"PosInt\34Expr"=>1,"PosInt\34Expression"=>1,"PosInt\34Int"=>1,"PosInt\34Integer"=>1,"PosInt\34List"=>1,"PosInt\34ListElem"=>1,"PosInt\34Literal"=>1,"PosInt\34LowPrecedenceNotExpression"=>1,"PosInt\34Num"=>1,"PosInt\34Number"=>1,"PosInt\34PrefixPostfixTerm"=>1,"PosInt\34Statement"=>1,"PosInt\34Term"=>1,"PosInt\34Ternary"=>1,"PositiveInteger\34Assignment"=>1,"PositiveInteger\34BinaryExpression"=>1,"PositiveInteger\34CommaList"=>1,"PositiveInteger\34ConditionalExpression"=>1,"PositiveInteger\34Document"=>1,"PositiveInteger\34Expr"=>1,"PositiveInteger\34Expression"=>1,"PositiveInteger\34Int"=>1,"PositiveInteger\34Integer"=>1,"PositiveInteger\34List"=>1,"PositiveInteger\34ListElem"=>1,"PositiveInteger\34Literal"=>1,"PositiveInteger\34LowPrecedenceNotExpression"=>1,"PositiveInteger\34Num"=>1,"PositiveInteger\34Number"=>1,"PositiveInteger\34PrefixPostfixTerm"=>1,"PositiveInteger\34Statement"=>1,"PositiveInteger\34Term"=>1,"PositiveInteger\34Ternary"=>1,"PrefixPostfixTerm\34Assignment"=>1,"PrefixPostfixTerm\34BinaryExpression"=>1,"PrefixPostfixTerm\34CommaList"=>1,"PrefixPostfixTerm\34ConditionalExpression"=>1,"PrefixPostfixTerm\34Document"=>1,"PrefixPostfixTerm\34Expr"=>1,"PrefixPostfixTerm\34Expression"=>1,"PrefixPostfixTerm\34List"=>1,"PrefixPostfixTerm\34ListElem"=>1,"PrefixPostfixTerm\34LowPrecedenceNotExpression"=>1,"PrefixPostfixTerm\34Statement"=>1,"PrefixPostfixTerm\34Ternary"=>1,"QualIdent\34Assignment"=>1,"QualIdent\34Bareword"=>1,"QualIdent\34BinaryExpression"=>1,"QualIdent\34CommaList"=>1,"QualIdent\34ConditionalExpression"=>1,"QualIdent\34Document"=>1,"QualIdent\34Expr"=>1,"QualIdent\34Expression"=>1,"QualIdent\34List"=>1,"QualIdent\34ListElem"=>1,"QualIdent\34Literal"=>1,"QualIdent\34LowPrecedenceNotExpression"=>1,"QualIdent\34OldQualifiedIdentifier"=>1,"QualIdent\34PrefixPostfixTerm"=>1,"QualIdent\34Statement"=>1,"QualIdent\34Term"=>1,"QualIdent\34Ternary"=>1,"QualifiedIdentifier\34Assignment"=>1,"QualifiedIdentifier\34Bareword"=>1,"QualifiedIdentifier\34BinaryExpression"=>1,"QualifiedIdentifier\34CommaList"=>1,"QualifiedIdentifier\34ConditionalExpression"=>1,"QualifiedIdentifier\34Document"=>1,"QualifiedIdentifier\34Expr"=>1,"QualifiedIdentifier\34Expression"=>1,"QualifiedIdentifier\34List"=>1,"QualifiedIdentifier\34ListElem"=>1,"QualifiedIdentifier\34Literal"=>1,"QualifiedIdentifier\34LowPrecedenceNotExpression"=>1,"QualifiedIdentifier\34OldQualifiedIdentifier"=>1,"QualifiedIdentifier\34PrefixPostfixTerm"=>1,"QualifiedIdentifier\34Statement"=>1,"QualifiedIdentifier\34Term"=>1,"QualifiedIdentifier\34Ternary"=>1,"Quotelike\34Assignment"=>1,"Quotelike\34BinaryExpression"=>1,"Quotelike\34CommaList"=>1,"Quotelike\34ConditionalExpression"=>1,"Quotelike\34Document"=>1,"Quotelike\34Expr"=>1,"Quotelike\34Expression"=>1,"Quotelike\34List"=>1,"Quotelike\34ListElem"=>1,"Quotelike\34LowPrecedenceNotExpression"=>1,"Quotelike\34PrefixPostfixTerm"=>1,"Quotelike\34Statement"=>1,"Quotelike\34Term"=>1,"Quotelike\34Ternary"=>1,"QuotelikeM\34Assignment"=>1,"QuotelikeM\34BinaryExpression"=>1,"QuotelikeM\34CommaList"=>1,"QuotelikeM\34ConditionalExpression"=>1,"QuotelikeM\34Document"=>1,"QuotelikeM\34Expr"=>1,"QuotelikeM\34Expression"=>1,"QuotelikeM\34List"=>1,"QuotelikeM\34ListElem"=>1,"QuotelikeM\34LowPrecedenceNotExpression"=>1,"QuotelikeM\34PrefixPostfixTerm"=>1,"QuotelikeM\34Quotelike"=>1,"QuotelikeM\34Regex"=>1,"QuotelikeM\34Regexp"=>1,"QuotelikeM\34Statement"=>1,"QuotelikeM\34Term"=>1,"QuotelikeM\34Ternary"=>1,"QuotelikeQ\34Assignment"=>1,"QuotelikeQ\34BinaryExpression"=>1,"QuotelikeQ\34CommaList"=>1,"QuotelikeQ\34ConditionalExpression"=>1,"QuotelikeQ\34Document"=>1,"QuotelikeQ\34Expr"=>1,"QuotelikeQ\34Expression"=>1,"QuotelikeQ\34List"=>1,"QuotelikeQ\34ListElem"=>1,"QuotelikeQ\34Literal"=>1,"QuotelikeQ\34LowPrecedenceNotExpression"=>1,"QuotelikeQ\34PrefixPostfixTerm"=>1,"QuotelikeQ\34Quotelike"=>1,"QuotelikeQ\34Statement"=>1,"QuotelikeQ\34Str"=>1,"QuotelikeQ\34String"=>1,"QuotelikeQ\34Term"=>1,"QuotelikeQ\34Ternary"=>1,"QuotelikeQQ\34Assignment"=>1,"QuotelikeQQ\34BinaryExpression"=>1,"QuotelikeQQ\34CommaList"=>1,"QuotelikeQQ\34ConditionalExpression"=>1,"QuotelikeQQ\34Document"=>1,"QuotelikeQQ\34Expr"=>1,"QuotelikeQQ\34Expression"=>1,"QuotelikeQQ\34List"=>1,"QuotelikeQQ\34ListElem"=>1,"QuotelikeQQ\34Literal"=>1,"QuotelikeQQ\34LowPrecedenceNotExpression"=>1,"QuotelikeQQ\34PrefixPostfixTerm"=>1,"QuotelikeQQ\34Quotelike"=>1,"QuotelikeQQ\34Statement"=>1,"QuotelikeQQ\34Str"=>1,"QuotelikeQQ\34String"=>1,"QuotelikeQQ\34Term"=>1,"QuotelikeQQ\34Ternary"=>1,"QuotelikeQR\34Assignment"=>1,"QuotelikeQR\34BinaryExpression"=>1,"QuotelikeQR\34CommaList"=>1,"QuotelikeQR\34ConditionalExpression"=>1,"QuotelikeQR\34ContextualRegex"=>1,"QuotelikeQR\34Document"=>1,"QuotelikeQR\34Expr"=>1,"QuotelikeQR\34Expression"=>1,"QuotelikeQR\34List"=>1,"QuotelikeQR\34ListElem"=>1,"QuotelikeQR\34LowPrecedenceNotExpression"=>1,"QuotelikeQR\34PrefixPostfixTerm"=>1,"QuotelikeQR\34Quotelike"=>1,"QuotelikeQR\34Regex"=>1,"QuotelikeQR\34Regexp"=>1,"QuotelikeQR\34Statement"=>1,"QuotelikeQR\34Term"=>1,"QuotelikeQR\34Ternary"=>1,"QuotelikeQW\34Assignment"=>1,"QuotelikeQW\34BinaryExpression"=>1,"QuotelikeQW\34CommaList"=>1,"QuotelikeQW\34ConditionalExpression"=>1,"QuotelikeQW\34Document"=>1,"QuotelikeQW\34Expr"=>1,"QuotelikeQW\34Expression"=>1,"QuotelikeQW\34List"=>1,"QuotelikeQW\34ListElem"=>1,"QuotelikeQW\34LowPrecedenceNotExpression"=>1,"QuotelikeQW\34PrefixPostfixTerm"=>1,"QuotelikeQW\34Quotelike"=>1,"QuotelikeQW\34Statement"=>1,"QuotelikeQW\34Term"=>1,"QuotelikeQW\34Ternary"=>1,"QuotelikeQX\34Assignment"=>1,"QuotelikeQX\34BinaryExpression"=>1,"QuotelikeQX\34CommaList"=>1,"QuotelikeQX\34ConditionalExpression"=>1,"QuotelikeQX\34Document"=>1,"QuotelikeQX\34Expr"=>1,"QuotelikeQX\34Expression"=>1,"QuotelikeQX\34List"=>1,"QuotelikeQX\34ListElem"=>1,"QuotelikeQX\34LowPrecedenceNotExpression"=>1,"QuotelikeQX\34PrefixPostfixTerm"=>1,"QuotelikeQX\34Quotelike"=>1,"QuotelikeQX\34Statement"=>1,"QuotelikeQX\34Term"=>1,"QuotelikeQX\34Ternary"=>1,"QuotelikeS\34Assignment"=>1,"QuotelikeS\34BinaryExpression"=>1,"QuotelikeS\34CommaList"=>1,"QuotelikeS\34ConditionalExpression"=>1,"QuotelikeS\34Document"=>1,"QuotelikeS\34Expr"=>1,"QuotelikeS\34Expression"=>1,"QuotelikeS\34List"=>1,"QuotelikeS\34ListElem"=>1,"QuotelikeS\34LowPrecedenceNotExpression"=>1,"QuotelikeS\34PrefixPostfixTerm"=>1,"QuotelikeS\34Quotelike"=>1,"QuotelikeS\34Statement"=>1,"QuotelikeS\34Term"=>1,"QuotelikeS\34Ternary"=>1,"QuotelikeTR\34Assignment"=>1,"QuotelikeTR\34BinaryExpression"=>1,"QuotelikeTR\34CommaList"=>1,"QuotelikeTR\34ConditionalExpression"=>1,"QuotelikeTR\34Document"=>1,"QuotelikeTR\34Expr"=>1,"QuotelikeTR\34Expression"=>1,"QuotelikeTR\34List"=>1,"QuotelikeTR\34ListElem"=>1,"QuotelikeTR\34LowPrecedenceNotExpression"=>1,"QuotelikeTR\34PrefixPostfixTerm"=>1,"QuotelikeTR\34Quotelike"=>1,"QuotelikeTR\34Statement"=>1,"QuotelikeTR\34Term"=>1,"QuotelikeTR\34Ternary"=>1,"Regex\34Assignment"=>1,"Regex\34BinaryExpression"=>1,"Regex\34CommaList"=>1,"Regex\34ConditionalExpression"=>1,"Regex\34Document"=>1,"Regex\34Expr"=>1,"Regex\34Expression"=>1,"Regex\34List"=>1,"Regex\34ListElem"=>1,"Regex\34LowPrecedenceNotExpression"=>1,"Regex\34PrefixPostfixTerm"=>1,"Regex\34Quotelike"=>1,"Regex\34Statement"=>1,"Regex\34Term"=>1,"Regex\34Ternary"=>1,"Regexp\34Assignment"=>1,"Regexp\34BinaryExpression"=>1,"Regexp\34CommaList"=>1,"Regexp\34ConditionalExpression"=>1,"Regexp\34Document"=>1,"Regexp\34Expr"=>1,"Regexp\34Expression"=>1,"Regexp\34List"=>1,"Regexp\34ListElem"=>1,"Regexp\34LowPrecedenceNotExpression"=>1,"Regexp\34PrefixPostfixTerm"=>1,"Regexp\34Quotelike"=>1,"Regexp\34Statement"=>1,"Regexp\34Term"=>1,"Regexp\34Ternary"=>1,"ReturnStatement\34Assignment"=>1,"ReturnStatement\34BinaryExpression"=>1,"ReturnStatement\34CommaList"=>1,"ReturnStatement\34ConditionalExpression"=>1,"ReturnStatement\34Document"=>1,"ReturnStatement\34Expr"=>1,"ReturnStatement\34Expression"=>1,"ReturnStatement\34List"=>1,"ReturnStatement\34ListElem"=>1,"ReturnStatement\34LowPrecedenceNotExpression"=>1,"ReturnStatement\34PrefixPostfixTerm"=>1,"ReturnStatement\34Statement"=>1,"ReturnStatement\34Term"=>1,"ReturnStatement\34Ternary"=>1,"ScalarAccess\34Assignment"=>1,"ScalarAccess\34BinaryExpression"=>1,"ScalarAccess\34CommaList"=>1,"ScalarAccess\34ConditionalExpression"=>1,"ScalarAccess\34Document"=>1,"ScalarAccess\34Expr"=>1,"ScalarAccess\34Expression"=>1,"ScalarAccess\34List"=>1,"ScalarAccess\34ListElem"=>1,"ScalarAccess\34LowPrecedenceNotExpression"=>1,"ScalarAccess\34PrefixPostfixTerm"=>1,"ScalarAccess\34Statement"=>1,"ScalarAccess\34Term"=>1,"ScalarAccess\34Ternary"=>1,"ScalarAccess\34Var"=>1,"ScalarAccess\34Variable"=>1,"ScalarVar\34Assignment"=>1,"ScalarVar\34BinaryExpression"=>1,"ScalarVar\34CommaList"=>1,"ScalarVar\34ConditionalExpression"=>1,"ScalarVar\34Document"=>1,"ScalarVar\34Expr"=>1,"ScalarVar\34Expression"=>1,"ScalarVar\34List"=>1,"ScalarVar\34ListElem"=>1,"ScalarVar\34LowPrecedenceNotExpression"=>1,"ScalarVar\34PrefixPostfixTerm"=>1,"ScalarVar\34ScalarAccess"=>1,"ScalarVar\34Statement"=>1,"ScalarVar\34Term"=>1,"ScalarVar\34Ternary"=>1,"ScalarVar\34Var"=>1,"ScalarVar\34Variable"=>1,"Statement\34Document"=>1,"Str\34Assignment"=>1,"Str\34BinaryExpression"=>1,"Str\34CommaList"=>1,"Str\34ConditionalExpression"=>1,"Str\34Document"=>1,"Str\34Expr"=>1,"Str\34Expression"=>1,"Str\34List"=>1,"Str\34ListElem"=>1,"Str\34Literal"=>1,"Str\34LowPrecedenceNotExpression"=>1,"Str\34PrefixPostfixTerm"=>1,"Str\34Quotelike"=>1,"Str\34Statement"=>1,"Str\34Term"=>1,"Str\34Ternary"=>1,"String\34Assignment"=>1,"String\34BinaryExpression"=>1,"String\34CommaList"=>1,"String\34ConditionalExpression"=>1,"String\34Document"=>1,"String\34Expr"=>1,"String\34Expression"=>1,"String\34List"=>1,"String\34ListElem"=>1,"String\34Literal"=>1,"String\34LowPrecedenceNotExpression"=>1,"String\34PrefixPostfixTerm"=>1,"String\34Quotelike"=>1,"String\34Statement"=>1,"String\34Term"=>1,"String\34Ternary"=>1,"SubroutineDeclaration\34Document"=>1,"SubroutineDeclaration\34Statement"=>1,"Substitution\34Assignment"=>1,"Substitution\34BinaryExpression"=>1,"Substitution\34CommaList"=>1,"Substitution\34ConditionalExpression"=>1,"Substitution\34Document"=>1,"Substitution\34Expr"=>1,"Substitution\34Expression"=>1,"Substitution\34List"=>1,"Substitution\34ListElem"=>1,"Substitution\34LowPrecedenceNotExpression"=>1,"Substitution\34PrefixPostfixTerm"=>1,"Substitution\34Quotelike"=>1,"Substitution\34Statement"=>1,"Substitution\34Term"=>1,"Substitution\34Ternary"=>1,"Term\34Assignment"=>1,"Term\34BinaryExpression"=>1,"Term\34CommaList"=>1,"Term\34ConditionalExpression"=>1,"Term\34Document"=>1,"Term\34Expr"=>1,"Term\34Expression"=>1,"Term\34List"=>1,"Term\34ListElem"=>1,"Term\34LowPrecedenceNotExpression"=>1,"Term\34PrefixPostfixTerm"=>1,"Term\34Statement"=>1,"Term\34Ternary"=>1,"Ternary\34Assignment"=>1,"Ternary\34CommaList"=>1,"Ternary\34Document"=>1,"Ternary\34Expr"=>1,"Ternary\34Expression"=>1,"Ternary\34List"=>1,"Ternary\34LowPrecedenceNotExpression"=>1,"Ternary\34Statement"=>1,"Transliteration\34Assignment"=>1,"Transliteration\34BinaryExpression"=>1,"Transliteration\34CommaList"=>1,"Transliteration\34ConditionalExpression"=>1,"Transliteration\34Document"=>1,"Transliteration\34Expr"=>1,"Transliteration\34Expression"=>1,"Transliteration\34List"=>1,"Transliteration\34ListElem"=>1,"Transliteration\34LowPrecedenceNotExpression"=>1,"Transliteration\34PrefixPostfixTerm"=>1,"Transliteration\34Quotelike"=>1,"Transliteration\34Statement"=>1,"Transliteration\34Term"=>1,"Transliteration\34Ternary"=>1,"Typeglob\34Assignment"=>1,"Typeglob\34BinaryExpression"=>1,"Typeglob\34CommaList"=>1,"Typeglob\34ConditionalExpression"=>1,"Typeglob\34Document"=>1,"Typeglob\34Expr"=>1,"Typeglob\34Expression"=>1,"Typeglob\34List"=>1,"Typeglob\34ListElem"=>1,"Typeglob\34LowPrecedenceNotExpression"=>1,"Typeglob\34PrefixPostfixTerm"=>1,"Typeglob\34Statement"=>1,"Typeglob\34Term"=>1,"Typeglob\34Ternary"=>1,"UseStatement\34Document"=>1,"UseStatement\34Statement"=>1,"Var\34Assignment"=>1,"Var\34BinaryExpression"=>1,"Var\34CommaList"=>1,"Var\34ConditionalExpression"=>1,"Var\34Document"=>1,"Var\34Expr"=>1,"Var\34Expression"=>1,"Var\34List"=>1,"Var\34ListElem"=>1,"Var\34LowPrecedenceNotExpression"=>1,"Var\34PrefixPostfixTerm"=>1,"Var\34Statement"=>1,"Var\34Term"=>1,"Var\34Ternary"=>1,"VarArray\34ArrayAccess"=>1,"VarArray\34Assignment"=>1,"VarArray\34BinaryExpression"=>1,"VarArray\34CommaList"=>1,"VarArray\34ConditionalExpression"=>1,"VarArray\34Document"=>1,"VarArray\34Expr"=>1,"VarArray\34Expression"=>1,"VarArray\34List"=>1,"VarArray\34ListElem"=>1,"VarArray\34LowPrecedenceNotExpression"=>1,"VarArray\34PrefixPostfixTerm"=>1,"VarArray\34Statement"=>1,"VarArray\34Term"=>1,"VarArray\34Ternary"=>1,"VarArray\34Var"=>1,"VarArray\34Variable"=>1,"VarDecl\34Assignment"=>1,"VarDecl\34BinaryExpression"=>1,"VarDecl\34CommaList"=>1,"VarDecl\34ConditionalExpression"=>1,"VarDecl\34Document"=>1,"VarDecl\34Expr"=>1,"VarDecl\34Expression"=>1,"VarDecl\34List"=>1,"VarDecl\34ListElem"=>1,"VarDecl\34LowPrecedenceNotExpression"=>1,"VarDecl\34PrefixPostfixTerm"=>1,"VarDecl\34Statement"=>1,"VarDecl\34Term"=>1,"VarDecl\34Ternary"=>1,"VarHash\34Assignment"=>1,"VarHash\34BinaryExpression"=>1,"VarHash\34CommaList"=>1,"VarHash\34ConditionalExpression"=>1,"VarHash\34Document"=>1,"VarHash\34Expr"=>1,"VarHash\34Expression"=>1,"VarHash\34HashAccess"=>1,"VarHash\34List"=>1,"VarHash\34ListElem"=>1,"VarHash\34LowPrecedenceNotExpression"=>1,"VarHash\34PrefixPostfixTerm"=>1,"VarHash\34Statement"=>1,"VarHash\34Term"=>1,"VarHash\34Ternary"=>1,"VarHash\34Var"=>1,"VarHash\34Variable"=>1,"Variable\34Assignment"=>1,"Variable\34BinaryExpression"=>1,"Variable\34CommaList"=>1,"Variable\34ConditionalExpression"=>1,"Variable\34Document"=>1,"Variable\34Expr"=>1,"Variable\34Expression"=>1,"Variable\34List"=>1,"Variable\34ListElem"=>1,"Variable\34LowPrecedenceNotExpression"=>1,"Variable\34PrefixPostfixTerm"=>1,"Variable\34Statement"=>1,"Variable\34Term"=>1,"Variable\34Ternary"=>1,"VariableArray\34ArrayAccess"=>1,"VariableArray\34Assignment"=>1,"VariableArray\34BinaryExpression"=>1,"VariableArray\34CommaList"=>1,"VariableArray\34ConditionalExpression"=>1,"VariableArray\34Document"=>1,"VariableArray\34Expr"=>1,"VariableArray\34Expression"=>1,"VariableArray\34List"=>1,"VariableArray\34ListElem"=>1,"VariableArray\34LowPrecedenceNotExpression"=>1,"VariableArray\34PrefixPostfixTerm"=>1,"VariableArray\34Statement"=>1,"VariableArray\34Term"=>1,"VariableArray\34Ternary"=>1,"VariableArray\34Var"=>1,"VariableArray\34Variable"=>1,"VariableDeclaration\34Assignment"=>1,"VariableDeclaration\34BinaryExpression"=>1,"VariableDeclaration\34CommaList"=>1,"VariableDeclaration\34ConditionalExpression"=>1,"VariableDeclaration\34Document"=>1,"VariableDeclaration\34Expr"=>1,"VariableDeclaration\34Expression"=>1,"VariableDeclaration\34List"=>1,"VariableDeclaration\34ListElem"=>1,"VariableDeclaration\34LowPrecedenceNotExpression"=>1,"VariableDeclaration\34PrefixPostfixTerm"=>1,"VariableDeclaration\34Statement"=>1,"VariableDeclaration\34Term"=>1,"VariableDeclaration\34Ternary"=>1,"VariableHash\34Assignment"=>1,"VariableHash\34BinaryExpression"=>1,"VariableHash\34CommaList"=>1,"VariableHash\34ConditionalExpression"=>1,"VariableHash\34Document"=>1,"VariableHash\34Expr"=>1,"VariableHash\34Expression"=>1,"VariableHash\34HashAccess"=>1,"VariableHash\34List"=>1,"VariableHash\34ListElem"=>1,"VariableHash\34LowPrecedenceNotExpression"=>1,"VariableHash\34PrefixPostfixTerm"=>1,"VariableHash\34Statement"=>1,"VariableHash\34Term"=>1,"VariableHash\34Ternary"=>1,"VariableHash\34Var"=>1,"VariableHash\34Variable"=>1,"VariableScalar\34Assignment"=>1,"VariableScalar\34BinaryExpression"=>1,"VariableScalar\34CommaList"=>1,"VariableScalar\34ConditionalExpression"=>1,"VariableScalar\34Document"=>1,"VariableScalar\34Expr"=>1,"VariableScalar\34Expression"=>1,"VariableScalar\34List"=>1,"VariableScalar\34ListElem"=>1,"VariableScalar\34LowPrecedenceNotExpression"=>1,"VariableScalar\34PrefixPostfixTerm"=>1,"VariableScalar\34ScalarAccess"=>1,"VariableScalar\34Statement"=>1,"VariableScalar\34Term"=>1,"VariableScalar\34Ternary"=>1,"VariableScalar\34Var"=>1,"VariableScalar\34Variable"=>1,"VarScalar\34Assignment"=>1,"VarScalar\34BinaryExpression"=>1,"VarScalar\34CommaList"=>1,"VarScalar\34ConditionalExpression"=>1,"VarScalar\34Document"=>1,"VarScalar\34Expr"=>1,"VarScalar\34Expression"=>1,"VarScalar\34List"=>1,"VarScalar\34ListElem"=>1,"VarScalar\34LowPrecedenceNotExpression"=>1,"VarScalar\34PrefixPostfixTerm"=>1,"VarScalar\34ScalarAccess"=>1,"VarScalar\34Statement"=>1,"VarScalar\34Term"=>1,"VarScalar\34Ternary"=>1,"VarScalar\34Var"=>1,"VarScalar\34Variable"=>1,"VersionNumber\34Assignment"=>1,"VersionNumber\34BinaryExpression"=>1,"VersionNumber\34CommaList"=>1,"VersionNumber\34ConditionalExpression"=>1,"VersionNumber\34Document"=>1,"VersionNumber\34Expr"=>1,"VersionNumber\34Expression"=>1,"VersionNumber\34List"=>1,"VersionNumber\34ListElem"=>1,"VersionNumber\34Literal"=>1,"VersionNumber\34LowPrecedenceNotExpression"=>1,"VersionNumber\34Num"=>1,"VersionNumber\34Number"=>1,"VersionNumber\34PrefixPostfixTerm"=>1,"VersionNumber\34Statement"=>1,"VersionNumber\34Term"=>1,"VersionNumber\34Ternary"=>1,"VString\34Assignment"=>1,"VString\34BinaryExpression"=>1,"VString\34CommaList"=>1,"VString\34ConditionalExpression"=>1,"VString\34Document"=>1,"VString\34Expr"=>1,"VString\34Expression"=>1,"VString\34List"=>1,"VString\34ListElem"=>1,"VString\34Literal"=>1,"VString\34LowPrecedenceNotExpression"=>1,"VString\34Num"=>1,"VString\34Number"=>1,"VString\34PrefixPostfixTerm"=>1,"VString\34Statement"=>1,"VString\34Str"=>1,"VString\34String"=>1,"VString\34Term"=>1,"VString\34Ternary"=>1,"VString\34VersionNumber"=>1,"Whitespace\34OWS"=>1,

# End of autogenerated type ISA hierarchy

);

# Convert type aliases into standard PPR types...
sub _resolve_type {
    my ($type, $user_defined_type_for) = @_;

    # Identify valid user-defined types in the current calling scope...
    $user_defined_type_for //= { map { m{ \A Keyword::Declare \s* keytype: (\w+) = (.*) }xms } keys %^H };

    while ($type =~ /\A \w++ \Z/x) {
        $type = $user_defined_type_for->{$type}
             // $ACTUAL_TYPE_OF{$type}
             // croak "Unknown type ($type) for keyword parameter.\nDid you mean: ",
                     join(' or ', grep { lc substr($_,0,1) eq lc substr($type,0,1) } keys %ACTUAL_TYPE_OF);
    }

    if ($type =~ m{\A (?: q\s*\S | ' ) (.*) \S \z }x) {
        return quotemeta $1
    }
    elsif ($type =~ $REGEX_TYPE ) {
        $type =~ $REGEX_PAT or die "Keyword::Declare internal error: weird regex";
        my $pat  = $+{pattern};
        my $mods = $+{modifiers};
        $pat =~ s{(?
        return "(?$mods:$pat)";
    }
    elsif ($type =~ $TYPE_JUNCTION) {
        return join '|', map { _resolve_type($_, $user_defined_type_for) } split /[|]/, $type;
    }
    else {
        die 'Keyword::Declare internal error: incomprehensible type: [$type]';
    }

}

# Convert named types and explicit regexes or strings to matcher regex...
sub _convert_type_to_matcher {
    my ($param) = @_;

    my $matcher;

    # Convert type specification to PPR subrule invocations and build a description...
    # ...for named types...
    my $type = $param->{type};
    if ($type =~ m{\A \w++ (?: [|] \w++ )* \Z}x) {
        # Extract component types...
        my @types = split /[|]/, $type;

        # First set up pseudo-inheritance...
        for my $component_type (@types) {
            $isa{$component_type, $type} = 1;
        }

        # Convert component types to regexes...
        $param->{desc} //= do {
            my $desc = $param->{name} ? "<$param->{name}>" : '<'.join(' or ', @types).'>';
            $desc =~ tr/_/ /;
            $desc;
        };
        $type = '/' . join('|', map { _resolve_type( $_ ) } @types) . '/';

    }

    # ...for literal string types...
    if ($type =~ m{\A (?: q\s*\S | ' ) (.*) \S \z }x) {
        $param->{desc}
            //= ($param->{name}
                    ? do{ my $name = "<$param->{name}>"; $name =~ tr/_/ /; $name }
                    : $1
                );
        $matcher = '(?:' . quotemeta($1) . ')';
    }

    # ...for regex types...
    elsif ($type =~ $REGEX_TYPE ) {
        $type =~ $REGEX_PAT or die "Keyword::Declare internal error: weird regex";
        my %match = %+;
        $match{pattern} =~ s{(?
        $param->{desc}
            //= ($param->{name}
                    ? do{ my $name = "<$param->{name}>"; $name =~ tr/_/ /; $name }
                    : "/$match{pattern}/$match{modifiers}"
                );
        $matcher = "(?$match{modifiers}:$match{pattern})";
    }

    # Incomprehensible types...
    else {
        die "Keyword::Declare internal error: incomprehensible type: [$type]"
    }

    return $matcher;
}

# This class allows captures from type-regexes to be preserved and accessed...
{
    package Keyword::Declare::Arg;
    use overload
        '""'     => sub { $_[0]{""} },
        fallback => 1
}

# Extract a string or a Keyword::Declare::Arg object from the most recent match...
sub _objectify {
    my ($match_str, $captures_ref) = @_;

    # Trim any leading Perlish whitespace from the match...
    $match_str =~ s{^(?: \s*+ (?: [#].*\n \s*+)*+)}{}x;

    # Just return the match if there were no captures...
    return $match_str if !keys %{$captures_ref};

    my $obj = { q{}=>$match_str, %{$captures_ref} };
    $obj->{':sep'} = delete( $obj->{____KD___sep} ) // q{};
    return bless $obj, 'Keyword::Declare::Arg';
}

# Convert the keyword's parameter list to various useful representations...
sub _unpack_signature {
    my ($keyword_info_ref) = @_;

    # We're setting up all these entries...
    my $sig_vars                          = "";  # List of variables into which keyword args are unpacked
    $keyword_info_ref->{sig_vars_unpack}  = "";  # Statements that unpack keyword args
    $keyword_info_ref->{sig_matcher}      = "";  # Pattern that matches entire arg list
    $keyword_info_ref->{sig_skip_matcher} = "";  # Pattern that matches entire arg list without captures
    $keyword_info_ref->{sig}              = [];  # Array of parameter types
    $keyword_info_ref->{sig_quantified}   = [];  # Array of quantified parameter types
    $keyword_info_ref->{sig_names}        = [];  # Names of each parameter ("" if no unnamed)
    $keyword_info_ref->{sig_defaults}     = {};  # Defaults for any parameter that has them

    # Walk through the parameters...
    my $not_post = 1;
    for my $param (@{$keyword_info_ref->{param_list}}) {
        if (!defined($param)) {
            $not_post = 0;
            next;
        }

        # Generate a regex to match this parameter (note: modifies $param!)...
        my $matcher = _convert_type_to_matcher($param);

        # Generate a regex to match the separator (if any)...
        my $sep;
        if ($param->{sep}) {
            $sep = _convert_type_to_matcher({name=>':sep', type=>$param->{sep}});
        }

        # Resolve implicit quantification (and any default value)...
        if (exists $param->{default}) {
            my $def = $param->{default};
            $def =~ s{\A (?: qq? \s* \S | ["']) (.*) \S \Z }{$1}gx;
            $keyword_info_ref->{sig_defaults}{$param->{name}} = $def;
            $param->{quantifier} //= $param->{sigil} && $param->{sigil} eq '@' ? '*' : '?';
        }
        else {
            $param->{quantifier} //= $param->{sigil} && $param->{sigil} eq '@' ? '+' : '';
        }

        # Matchers handle leading whitespace (unless they ARE whitespace)...
        $matcher = "(?:(?&PerlOWS)$matcher)"
            if $param->{type} !~ m{^/\(\?\&Perl[ON]WS\)/$};

        # Quantified parameters are repeatable...
        my $single_matcher = $matcher;
        if ($param->{quantifier}) {
            # Unseparated parameters are easy...
            if (!$sep) {
                $matcher = "(?:$matcher$param->{quantifier})";
            }
            # Separated parameters are more complex...
            else {
                $matcher = "(?:$matcher(?:(?&PerlOWS)$sep(?&PerlOWS)$matcher)*)";
                $matcher .= '?' if $param->{quantifier} eq '*';
                $single_matcher .= "(?=(?<____KD___sep>$sep))?";
            }
        }


        # Named parameters have to be named captured...
        my $skip_matcher = $matcher;
        if ($param->{name}) {
            $matcher = "(?<$param->{name}>$matcher)";
        }

        # Accumulate the signature matching pattern...
        $keyword_info_ref->{sig_matcher} .= $matcher;
        $keyword_info_ref->{sig_skip_matcher} .= $skip_matcher
            if $not_post;

        # Accumulate signature types and names (if any)...
        push @{ $keyword_info_ref->{sig} },            $param->{type};
        push @{ $keyword_info_ref->{sig_quantified} }, $param->{type}.$param->{quantifier};
        push @{ $keyword_info_ref->{sig_names} },      $param->{name} // q{};

        # Accumulate variable list into which parameters will be unpacked...
        if ($param->{name}) {
            my $match_once = $param->{sigil} ne '$' || $single_matcher =~ /\(\?
                                ? "m{$single_matcher\$PPR::GRAMMAR}"
                                : "m{}";

            $sig_vars                            .= "$param->{sigil}$param->{name},";
            $keyword_info_ref->{sig_vars_unpack} .= "$param->{sigil}$param->{name} = "
                                                  . ( $param->{sigil} eq '$'
                                                        ? qq{do { my \$arg = shift();
                                                                  \$arg =~ $match_once;
                                                                  Keyword::Declare::_objectify(\$arg,{%+});
                                                                };
                                                            }
                                                        : qq{do { my \@data;
                                                                  my \$arg = shift();
                                                                  while (\$arg =~ /\\S/ && \$arg =~ ${match_once}g) {
                                                                      push \@data,
                                                                           Keyword::Declare::_objectify(\$&,{%+});
                                                                  }
                                                                  \@data;
                                                                };
                                                            }
                                                    )
        }
        else {
            $keyword_info_ref->{sig_vars_unpack} .= 'shift();';
        }
    }

#    use Data::Show; show $keyword_info_ref->{sig_vars_unpack};

    # Build a human readable version of the signature...
    $keyword_info_ref->{sig_desc} = '(' . join(',', @{$keyword_info_ref->{sig_quantified}}) . ')';

    # Build a pretty description for debugging and error messages...
    $keyword_info_ref->{syntax} = "$keyword_info_ref->{keyword}  "
                                . join("  ", map { $_->{desc} } grep {defined} @Keyword::Declare::params);

    # Build a regex that matches the keyword plus its arguments...
    $keyword_info_ref->{matcher} = "$keyword_info_ref->{keyword}$keyword_info_ref->{sig_matcher}";
    $keyword_info_ref->{skip_matcher} = "$keyword_info_ref->{keyword}$keyword_info_ref->{sig_skip_matcher}";

    # Precompute the length of the signature (for multiple-dispatch tie-breaking)...
    $keyword_info_ref->{sig_len} = scalar @{ $keyword_info_ref->{sig} };

    # Consolidate the signature-unpacking code...
    $keyword_info_ref->{sig_vars_unpack} =
        $sig_vars ? "my ($sig_vars); $keyword_info_ref->{sig_vars_unpack}" : q{};
}


# Extract and verify any attrs specified on the keyword...
sub _unpack_attrs {
    my ($keyword_info_ref) = @_;

    # Are there any keyword attrs to unpack???
    if ($keyword_info_ref->{attrs}) {
        # Extract any :prefer or :keepspace attr...
        $keyword_info_ref->{prefer}
            = $keyword_info_ref->{attrs} =~ s{\bprefer\b}{}xms;
        $keyword_info_ref->{keepspace}
            = $keyword_info_ref->{attrs} =~ s{\bkeepspace\b}{}xms;

        # Extract any :desc(...) attr...
        if ($keyword_info_ref->{attrs} =~ s{\bdesc\( (.*?) \)}{}xms) {
            $keyword_info_ref->{desc} = $1;
        }
        else {
            $keyword_info_ref->{desc} = $keyword_info_ref->{keyword};
        }

        # Extract any :prefix(...) attr...
        if ($keyword_info_ref->{attrs} =~ s{\bprefix\( \s* (\$[^\W\d]\w*) \s* \)}{}xms) {
            $keyword_info_ref->{prefix} = $1;
        }

        # Complain about anything else...
        croak ":then attribute specified too late (must come immediately after parameter list)"
            if $keyword_info_ref->{attrs} =~ s{\bthen\b}{}xms;
        croak "Invalid attribute: $keyword_info_ref->{attrs}"
            if $keyword_info_ref->{attrs} =~ /[^\s:]/;
    }
}


# Convert a {{{...}}} interpolated keyword body to a normal body...
sub _convert_triple_block {
    my ($block, $keyword) = @{shift()}{qw< block keyword >};

    # Peel off extra curlies...
    $block = substr($block, 3, -3);

    # Report unclosed «...}> interpolations...
    if ($block =~ m{ <\{ (? (? \s* \S*) .*? ) (?: <\{ | « | \Z ) }xms) {
        my %match = %+;
        croak qq[Missing }> on interpolation <{$match{leader}...\n]
            . qq[in string-style block of keyword $keyword\ndefined]
                if $match{interpolation} !~ m{ \}> }xms;
    }
    if ($block =~ m{ « (? (? \s* \S*) .*? ) (?: <\{ | « | \Z ) }xms) {
        my %match = %+;
        croak qq[Missing » on interpolation «$match{leader}...\n]
            . qq[in string-style block of keyword $keyword\ndefined]
                if $match{interpolation} !~ m{ » }xms;
    }

    # Convert the inter polated text to code that does the interpolations...
    $block =~ s{
            « (? .*? ) »
        |
            <\{ (? .*? ) \}>
        |
            (? .+? ) (?= <\{ | « | \z )
    }{
           if (exists $+{literal_code} ) { 'qq{' . quotemeta($+{literal_code}) . '},'; }
        elsif (exists $+{interpolation}) { qq{ do{$+{interpolation}}, };               }
        else { say {*STDERR} 'Keyword::Declare internal error in {{{...}}} block'; exit; }
    }gexms;

    # Build and return the block's new source code...
    return "{ return join '', $block; }";
}


# Transform a keyword invocation into the code generated by the keyword's body...
sub _insert_replacement_code {
    my ($src_ref, $ID, $file, $line, $active_keywords) = @_;

    # Unpack keyword information...
    my $keyword = $keyword_impls[$ID];

    # Remove the arguments from the source code...
    $$src_ref =~ s{ \A ($keyword->{sig_matcher}) $active_keywords $PPR::GRAMMAR }{}xms;
    my %args     = %+;
    for my $argname (keys %args) {
        $args{$argname} = $keyword->{sig_defaults}{$argname} // q{}
            if $args{$argname} eq q{};
    }
    my $arg_list = $1;
    my @args     = @args{ @{$keyword_impls[$ID]{sig_names}} };

    # Tidy them, if requested...
    @args = map {
          !defined($_) ? undef
        : m{\S}        ? do { my $arg = $_;
                              $arg =~ s{\A\s*+(?:\#.*\n\s*+)*+}{};
                              $arg =~ s{\s*+(?:\#.*\n\s*+)*+\z}{};
                              $arg;
                            }
        :                $_
    } @args
        if !$keyword->{keepspace};

    # Adjust the line number so trailing code stays correct...
    $line += $arg_list =~ tr/\n//;

    # Generate replacement code...
    my $replacement_code = $keyword->{generator}->(@args) // q{};

    # If debugging requested, provide a summary of the substitution...
    if (${^H}{"Keyword::Declare debug"}) {
        my $keyword = "    $keyword_impls[$ID]{syntax}";
        my $from    = "    $keyword_impls[$ID]{keyword} $arg_list";
        my $to      = $replacement_code;
           $to =~ s{\A\s*\n|\n\s*\Z}{}gm;
           $to =~ s{\h+}{ }g;
           $to =~ s{^}{    }gm;

        my $msg
            =   ("#" x 50) . "\n"
              . " Keyword macro defined at $keyword_impls[$ID]{location}:\n\n$keyword\n\n"
              . " Converted code at $file line $line:"                . "\n\n$from\n\n"
              . " Into:"                                              . "\n\n$to\n\n"
              . ("#" x 50) . "\n";
        $msg =~ s{^}{###}gm;
        warn $msg;
    }

    # Track possible cycles...
    $$src_ref =~ s{^(\#KDCT:_:_:)(\d+)([^\n]*)}
                  { my ($comment, $count, $trace) = ($1, $2, $3);
                    croak "Likely keyword substitution cycle:\n    $trace\nCompilation abandoned",
                        if $count > $NESTING_THRESHOLD && $trace =~ m{(\w++) --> .+ --> \1};
                    $comment.($count+1).$trace." --> $keyword->{keyword}";
                  }gexms;

    # Install the replacement code...
    $$src_ref = "$replacement_code\n#KDCT:_:_:1 $keyword->{keyword}\n#line $line $file\n" . $$src_ref;

    # Pre-empt addition of extraneous trailing newline by Keyword::Simple...
    # [REMOVE WHEN UPSTREAM MODULE (Keyword::Simple) IS FIXED]
    $$src_ref =~ s{\n\z}{};
}

# Compare two types...
sub _is_narrower {
    my ($type_a, $type_b) = @_;

    # Short-circuit on identity...
    return 0  if $type_a eq $type_b;

    # Otherwise, work out the metatypes of the types...
    my $kind_a = $type_a =~ /\A'|\Aq\W/ ? 'literal'  :  $type_a =~ m{\A/|\Am\W}xms ? 'pattern'  :  'typename';
    my $kind_b = $type_b =~ /\A'|\Aq\W/ ? 'literal'  :  $type_b =~ m{\A/|\Am\W}xms ? 'pattern'  :  'typename';

    # If both are named types, try the standard inheritance hierarchy rules...
    if ($kind_a eq 'typename' && $kind_b eq 'typename') {
        return +1 if $isa{$type_a,$type_b};
        return -1 if $isa{$type_b,$type_a};
    }

    # Otherwise, the metatype names "just happen" to be in narrowness order ;-)...
    return $kind_a cmp $kind_b;
}

# Compare two type signatures (of equal length)...
sub _cmp_signatures {
    my ($sig_a, $sig_b) = @_;

    # Track relative ordering parameter-by-parameter...
    my $partial_ordering = 0;
    for my $n (0 .. $#$sig_a) {
        # Find the ordering of the next pair from the two lists...
        my $is_narrower = _is_narrower($sig_a->[$n], $sig_b->[$n]);

        # If this pair's ordering contradicts the ordering so far, there is no ordering...
        return 0 if $is_narrower && $is_narrower == -$partial_ordering;

        # Otherwise if there's an ordering, it becomes the "ordering so far"...
        $partial_ordering ||= $is_narrower;
    }

    # If we make it through the entire list, return the resulting ordering...
    return $partial_ordering;
}

# Resolve ambiguous argument lists using Perl6-ish multiple dispatch rules...
sub _resolve_matches {
    my @IDs = @_;

    # Extend type hierarchy...
    my @keytype_isa = map { my ($derived, $base) = m{ \A Keyword::Declare \s+ keytype:(\w+)=(\w+) \z}xms;
                            if ($derived) {
                                my @ancestors = map  { my $anc = $_;
                                                       $anc =~ s{ \A $base $; }
                                                                {$derived$;}xms;
                                                       $anc => 1
                                                     }
                                                grep { m{ \A $base $; }xms }
                                                keys %isa;
                                $derived.$;.$base => 1, @ancestors;
                            }
                            else {
                                ();
                            }
                          } keys %^H;
    local %isa = ( %isa, @keytype_isa );

    # Track narrownesses...
    my %narrower = map { $_ => [] } 0..$#IDs;

    # Compare all signatures, recording definitive differences in narrowness...
    for my $index_1 (0 .. $#IDs) {
        for my $index_2 ($index_1+1 .. $#IDs) {
            my $narrowness = _cmp_signatures($keyword_impls[$IDs[$index_1]]{sig},
                                             $keyword_impls[$IDs[$index_2]]{sig});

            if    ($narrowness > 0) { push @{$narrower{$index_1}}, $index_2; }
            elsif ($narrowness < 0) { push @{$narrower{$index_2}}, $index_1; }
        }
    }

    # Was there a signature narrower than all the others???
    my $max_narrower = max map { scalar @{$_} } values %narrower;
    my $unique_narrowest = $max_narrower == $#IDs;

    # If not, return the entire set...
    return @IDs if !$unique_narrowest;

    # Otherwise, return the narrowest...
    return @IDs[ grep { @{$narrower{$_}} >= $max_narrower } keys %narrower ];
}

1; # Magic true value required at end of module
__END__