# Generated by tools/build/raku-ast-compiler.nqp

stub RakuAST metaclass Perl6::Metamodel::PackageHOW { ... };
BEGIN { Perl6::Metamodel::PackageHOW.add_stash(RakuAST); }
stub RakuAST::IMPL::QASTContext metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::IMPL::InterpContext metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Resolver metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Resolver::EVAL metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Resolver::Compile metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Resolver::Compile::Scope metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Origin metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Origin::Match metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Origin::Source metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Node metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::CompileTimeValue metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::CheckTime metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::SinkBoundary metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::SinkPropagator metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Sinkable metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::BlockStatementSensitive metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::LexicalScope metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Declaration metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ImplicitDeclarations metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Declaration::External metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Declaration::Mergeable metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Declaration::External::Constant metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Declaration::External::Setting metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Declaration::Import metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Declaration::LexicalPackage metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Declaration::ResolvedConstant metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Lookup metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::UndeclaredSymbolDescription metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::UndeclaredSymbolDescription::Routine metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ImplicitLookups metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::PackageInstaller metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Attaching metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::AttachTarget metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::BeginTime metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::TraitTarget metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait::Is metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait::Type metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait::Hides metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait::Does metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait::Of metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait::Returns metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait::Will metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Trait::Handles metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Meta metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StubbyMeta metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Doc metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Doc::Paragraph metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Doc::Block metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Doc::Markup metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Doc::Declarator metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Doc::DeclaratorTarget metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Blorst metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Contextualizable metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Label metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ImplicitBlockSemanticsProvider metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ForLoopImplementation metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementList metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::SemiList metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementSequence metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ProducesNil metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Empty metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Expression metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::IMPL::ImmediateBlockUser metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::IfWith metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::If metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::With metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Elsif metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Orwith metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Unless metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Without metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Loop metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Loop::While metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Loop::Until metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Loop::RepeatWhile metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Loop::RepeatUntil metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::For metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Given metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::When metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Whenever metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Default metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::ExceptionHandler metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Catch metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Control metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Categorical metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ModuleLoading metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Use metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Need metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Import metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Statement::Require metaclass Perl6::Metamodel::ClassHOW { ... };
stub OperatorProperties metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::CaptureSource metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Expression metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::OperatorProperties metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Infixish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Infix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Feed metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::FlipFlop metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Assignment metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::BracketedInfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::FunctionInfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaInfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaInfix::Assign metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaInfix::Negate metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaInfix::Reverse metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaInfix::Cross metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaInfix::Zip metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaInfix::Hyper metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::WhateverApplicable metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ApplyInfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ApplyListInfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::DottyInfixish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::DottyInfix::Call metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::DottyInfix::CallAssign metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ApplyDottyInfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Prefixish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Prefix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaPrefix::Hyper metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Termish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ApplyPrefix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postfixish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postfix::Literal metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postfix::Power metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postfix::Vulgar metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postcircumfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postcircumfix::ArrayIndex metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postcircumfix::HashIndex metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Postcircumfix::LiteralHashIndex metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MetaPostfix::Hyper metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ApplyPostfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Ternary metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Pragma metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::NamedArg metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::FatArrow metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ColonPairish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ColonPair metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ColonPairs metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::QuotePair metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ColonPair::True metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ColonPair::False metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ColonPair::Number metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ColonPair::Value metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ColonPair::Variable metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Circumfix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Circumfix::Parentheses metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Circumfix::ArrayComposer metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Circumfix::HashComposer metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ArgList metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::Name metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::Name::WithoutParentheses metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::Term metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::Methodish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::Method metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::QuotedMethod metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::PrivateMethod metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::MetaMethod metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::MaybeMethod metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Call::VarMethod metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Stub metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Stub::Fail metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Stub::Warn metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Stub::Die metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Nqp metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Nqp::Const metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::Name metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::True metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::False metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::Self metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::TopicCall metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::Named metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::EmptySet metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::Rand metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::Whatever metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::WhateverCode::Argument metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::HyperWhatever metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::Capture metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::Reduce metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Term::RadixNumber metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Name metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Name::Part metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Name::Part::Simple metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Name::Part::Expression metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Name::Part::Empty metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Simple metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Setting metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Derived metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Coercion metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Definedness metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Capture metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Parameterized metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Enum metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Type::Subset metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Initializer metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Initializer::Assign metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Initializer::Bind metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Initializer::CallAssign metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ContainerCreator metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::TraitTarget::Variable metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Constant metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Simple metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Auto metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Signature metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Anonymous metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Term metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Special metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::BlockTopic metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Constant metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Block metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Self metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Cursor metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Routine metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::State metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Doc metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Doc::Pod metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Doc::Data metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Doc::Finish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Implicit::Doc::Rakudoc metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Placeholder metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Placeholder::Positional metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Placeholder::Named metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Placeholder::SlurpyArray metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VarDeclaration::Placeholder::SlurpyHash metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Lexical metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Lexical::Constant metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Lexical::Setting metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Dynamic metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Attribute metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Compiler metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Compiler::File metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Compiler::Line metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Compiler::Block metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Compiler::Routine metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Compiler::Lookup metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Doc metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::PositionalCapture metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::NamedCapture metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Package metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Var::Slang metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Contextualizer metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Contextualizer::Item metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Contextualizer::List metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Contextualizer::Hash metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Blockoid metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::OnlyStar metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Code metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ExpressionThunk metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::PlaceholderParameterOwner metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ScopePhaser metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Block metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::PointyBlock metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Routine metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Sub metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Methodish metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Method metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Submethod metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::RegexDeclaration metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::TokenDeclaration metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::RuleDeclaration metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::RegexThunk metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::QuotedMatchConstruct metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::QuotedRegex metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Substitution metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::SubstitutionReplacementThunk metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::CurryThunk metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::BlockThunk metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::CompUnit metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::LiteralBuilder metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Do metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Quietly metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Race metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Hyper metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Lazy metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Eager metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Try metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Thunky metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Gather metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Blorst metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Once metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Start metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::React metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Supply metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Sinky metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Begin metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Check metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Init metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Enter metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::End metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Quit metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Block metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::First metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Next metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Last metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Leave metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Keep metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Pre metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Post metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Undo metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementPrefix::Phaser::Close metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::Condition metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::If metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::Unless metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::When metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::With metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::Without metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::Loop metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::While metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::Until metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::Given metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::For metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::For::Thunk metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StatementModifier::Condition::Thunk metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Signature metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::FakeSignature metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Parameter metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ParameterTarget metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ParameterTarget::Var metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ParameterTarget::Term metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ParameterTarget::Whatever metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Parameter::Slurpy metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Parameter::Slurpy::Flattened metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Parameter::Slurpy::Unflattened metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Parameter::Slurpy::SingleArgument metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Parameter::Slurpy::Capture metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ParameterDefaultThunk metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Package metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Role metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Class metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Grammar metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Module metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Knowhow metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Native metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Literal metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Constant metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::IntLiteral metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::NumLiteral metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::RatLiteral metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ComplexLiteral metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::VersionLiteral metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::ListLiteral metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::MapLiteral metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::StrLiteral metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::QuotedString metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Heredoc metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Heredoc::InterpolatedWhiteSpace metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::QuoteWordsAtom metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Branching metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::SequentialAlternation metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::SequentialConjunction metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Alternation metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Conjunction metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Sequence metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Term metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Atom metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Literal metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Quote metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Group metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CapturingGroup metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::NamedCapture metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Anchor metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Anchor::BeginningOfString metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Anchor::BeginningOfLine metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Anchor::EndOfString metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Anchor::EndOfLine metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Anchor::LeftWordBoundary metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Anchor::RightWordBoundary metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::MatchFrom metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::MatchTo metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Any metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Negatable metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClassEnumerationElement metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::BackSpace metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Digit metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Escape metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::FormFeed metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::HorizontalSpace metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Newline metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::CarriageReturn metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Space metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Tab metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::VerticalSpace metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Word metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Specified metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClass::Nul metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::BackReference metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::BackReference::Positional metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::BackReference::Named metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Statement metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Block metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Interpolation metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Pass metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Fail metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Named metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Named::Args metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Named::RegexArg metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Alias metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Lookahead metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::InterpolatedBlock metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::InterpolatedVar metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Callable metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::PredicateBlock metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::CharClass metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Assertion::Recurse metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClassElement metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClassElement::Rule metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClassElement::Property metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClassElement::Enumeration metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClassEnumerationElement::Character metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::CharClassEnumerationElement::Range metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::InternalModifier metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::InternalModifier::IgnoreCase metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::InternalModifier::IgnoreMark metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::InternalModifier::Ratchet metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::InternalModifier::Sigspace metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::QuantifiedAtom metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Quantifier metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Quantifier::ZeroOrOne metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Quantifier::ZeroOrMore metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Quantifier::OneOrMore metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Quantifier::Range metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Quantifier::BlockRange metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::BacktrackModifiedAtom metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Backtrack metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Backtrack::Greedy metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Backtrack::Frugal metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::Backtrack::Ratchet metaclass Perl6::Metamodel::ClassHOW { ... };
stub RakuAST::Regex::WithWhitespace metaclass Perl6::Metamodel::ClassHOW { ... };

BEGIN {
#line 1 src/Raku/ast/rakuast-prologue.nqp
    ##
    ## Various utility subs to help us produce types that look Raku-like.
    ##

    sub parent($class, $parent) {
        $class.HOW.add_parent($class, $parent);
    }

    sub add-attribute($class, $type, $name) {
        $class.HOW.add_attribute($class, Attribute.new(
            :$name, :$type, :package($class), :auto_viv_primitive($type)
        ));
    }

    sub add-method($class, $name, @parameters, $impl) {
        # Assemble a signature object for introspection purposes.
        my @params;
        my $first := 1;
        for @parameters -> $type, $name, $named, $optional {
            my $param := nqp::create(Parameter);
            nqp::bindattr($param, Parameter, '$!type', $type);
            nqp::bindattr_s($param, Parameter, '$!variable_name', $name);
            my int $flags := 128; # Multi-invocant
            $flags := $flags + 64 if $first; # Invocant
            $flags := $flags + 2048 if $optional;
            nqp::bindattr_i($param, Parameter, '$!flags', $flags);
            if $named {
                nqp::bindattr($param, Parameter, '@!named_names',
                    nqp::list_s(nqp::substr($name, 1)));
            }
            nqp::push(@params, $param);
        }
        my $signature := nqp::create(Signature);
        nqp::bindattr($signature, Signature, '@!params', @params);
        nqp::bindattr($signature, Signature, '$!returns', Mu);

        # Wrap code up in a Method object.
        my $static-code := nqp::getstaticcode($impl);
        my $wrapper := nqp::create(Method);
        nqp::bindattr($wrapper, Code, '$!do', $static-code);
        nqp::bindattr($wrapper, Code, '$!signature', $signature);
        nqp::bindattr($wrapper, Routine, '$!package', $class);
        $wrapper.set_name($name);
        $class.HOW.add_method($class, $name, $wrapper);
    }

    sub compose($type) {
        $type.HOW.compose_repr($type);
        $type.HOW.publish_type_cache($type);
        $type.HOW.publish_method_cache($type);
    }

    parent(RakuAST::IMPL::QASTContext, Any);
    add-attribute(RakuAST::IMPL::QASTContext, Mu, '$!sc');
    add-attribute(RakuAST::IMPL::QASTContext, Mu, '$!post-deserialize');
    add-attribute(RakuAST::IMPL::QASTContext, Mu, '$!code-ref-blocks');
    add-attribute(RakuAST::IMPL::QASTContext, int, '$!precompilation-mode');
    add-attribute(RakuAST::IMPL::QASTContext, Hash, '$!sub-id-to-code-object');
    add-attribute(RakuAST::IMPL::QASTContext, Hash, '$!sub-id-to-cloned-code-objects');
    add-attribute(RakuAST::IMPL::QASTContext, Hash, '$!sub-id-to-sc-idx');
    add-attribute(RakuAST::IMPL::QASTContext, List, '$!cleanup-tasks');
    add-attribute(RakuAST::IMPL::QASTContext, int, '$!is-nested');
    add-method(RakuAST::IMPL::QASTContext, 'new', [RakuAST::IMPL::QASTContext, '', 0, 0, Mu, '$sc', 1, 0, int, '$precompilation-mode', 1, 1], anon sub new ($SELF_CONT, :$sc!, :$precompilation-mode?) {
        my $SELF := nqp::decont($SELF_CONT);
        $sc := nqp::decont($sc);
        $precompilation-mode := nqp::decont($precompilation-mode);
#line 28 src/Raku/ast/impl.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::IMPL::QASTContext, '$!sc', $sc);
        nqp::bindattr_i($obj, RakuAST::IMPL::QASTContext, '$!precompilation-mode', $precompilation-mode);
        nqp::bindattr($obj, RakuAST::IMPL::QASTContext, '$!post-deserialize', []);
        nqp::bindattr($obj, RakuAST::IMPL::QASTContext, '$!code-ref-blocks', []);
        nqp::bindattr($obj, RakuAST::IMPL::QASTContext, '$!sub-id-to-code-object', {});
        nqp::bindattr($obj, RakuAST::IMPL::QASTContext, '$!sub-id-to-cloned-code-objects', {});
        nqp::bindattr($obj, RakuAST::IMPL::QASTContext, '$!sub-id-to-sc-idx', {});
        nqp::bindattr($obj, RakuAST::IMPL::QASTContext, '$!cleanup-tasks', []);
        nqp::bindattr_i($obj, RakuAST::IMPL::QASTContext, '$!is-nested', 0);
        $obj
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'create-nested', [RakuAST::IMPL::QASTContext, '', 0, 0], anon sub create-nested ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 42 src/Raku/ast/impl.rakumod
        
        my $context := nqp::clone($SELF);
        nqp::bindattr($context, RakuAST::IMPL::QASTContext, '$!cleanup-tasks', []);
        nqp::bindattr_i($context, RakuAST::IMPL::QASTContext, '$!is-nested', 1);
        $context
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'sc-handle', [RakuAST::IMPL::QASTContext, '', 0, 0], anon sub sc-handle ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 50 src/Raku/ast/impl.rakumod
        
        nqp::scgethandle(nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sc'))
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'lang-version', [RakuAST::IMPL::QASTContext, '', 0, 0], anon sub lang-version ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 56 src/Raku/ast/impl.rakumod
         'd' 
    });
    add-method(RakuAST::IMPL::QASTContext, 'is-moar', [RakuAST::IMPL::QASTContext, '', 0, 0], anon sub is-moar ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 58 src/Raku/ast/impl.rakumod
        
        nqp::getcomp('Raku').backend.name eq 'moar'
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'is-precompilation-mode', [RakuAST::IMPL::QASTContext, '', 0, 0], anon sub is-precompilation-mode ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 62 src/Raku/ast/impl.rakumod
        
        nqp::getattr_i($SELF, RakuAST::IMPL::QASTContext, '$!precompilation-mode')
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'ensure-sc', [RakuAST::IMPL::QASTContext, '', 0, 0, Mu, '$obj', 0, 0], anon sub ensure-sc ($SELF_CONT, $obj!) {
        my $SELF := nqp::decont($SELF_CONT);
#line 67 src/Raku/ast/impl.rakumod
        
        if nqp::isnull(nqp::getobjsc($obj)) {
            my $sc := nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sc');
            nqp::setobjsc($obj, $sc);
            my int $idx := nqp::scobjcount($sc);
            nqp::scsetobj($sc, $idx, $obj);
        }
        $obj
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'add-code-ref', [RakuAST::IMPL::QASTContext, '', 0, 0, Mu, '$code-ref', 0, 0, Mu, '$block', 0, 0], anon sub add-code-ref ($SELF_CONT, $code-ref!, $block!) {
        my $SELF := nqp::decont($SELF_CONT);
        $code-ref := nqp::decont($code-ref);
        $block := nqp::decont($block);
#line 77 src/Raku/ast/impl.rakumod
        
        my int $code-ref-idx := nqp::elems(nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!code-ref-blocks'));
        nqp::push(nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!code-ref-blocks'), $block);
        nqp::scsetcode(nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sc'), $code-ref-idx, $code-ref);
        nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sub-id-to-sc-idx'){$block.cuid} := $code-ref-idx;
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'add-fixup-task', [RakuAST::IMPL::QASTContext, '', 0, 0, Mu, '$fixup-producer', 0, 0], anon sub add-fixup-task ($SELF_CONT, $fixup-producer!) {
        my $SELF := nqp::decont($SELF_CONT);
        $fixup-producer := nqp::decont($fixup-producer);
#line 86 src/Raku/ast/impl.rakumod
        
        # TODO conditional on if we're doing precomp
        nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!post-deserialize').push($fixup-producer());
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'add-fixup-and-deserialize-task', [RakuAST::IMPL::QASTContext, '', 0, 0, Mu, '$qast', 0, 0], anon sub add-fixup-and-deserialize-task ($SELF_CONT, $qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $qast := nqp::decont($qast);
#line 93 src/Raku/ast/impl.rakumod
        
        nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!post-deserialize').push($qast);
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'sub-id-to-code-object', [RakuAST::IMPL::QASTContext, '', 0, 0], anon sub sub-id-to-code-object ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 97 src/Raku/ast/impl.rakumod
        
        nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sub-id-to-code-object')
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'sub-id-to-sc-idx', [RakuAST::IMPL::QASTContext, '', 0, 0], anon sub sub-id-to-sc-idx ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 101 src/Raku/ast/impl.rakumod
        
        nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sub-id-to-sc-idx')
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'add-clone-for-cuid', [RakuAST::IMPL::QASTContext, '', 0, 0, Any, '$clone', 0, 0, Any, '$cuid', 0, 0], anon sub add-clone-for-cuid ($SELF_CONT, $clone!, $cuid!) {
        my $SELF := nqp::decont($SELF_CONT);
        $clone := nqp::decont($clone);
        $cuid := nqp::decont($cuid);
#line 105 src/Raku/ast/impl.rakumod
        
        unless nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sub-id-to-cloned-code-objects'){$cuid} {
            nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sub-id-to-cloned-code-objects'){$cuid} := [];
        }
        nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sub-id-to-cloned-code-objects'){$cuid}.push($clone);
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'sub-id-to-cloned-code-objects', [RakuAST::IMPL::QASTContext, '', 0, 0], anon sub sub-id-to-cloned-code-objects ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 112 src/Raku/ast/impl.rakumod
        
        nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!sub-id-to-cloned-code-objects')
    
    });
    add-method(RakuAST::IMPL::QASTContext, 'add-cleanup-task', [RakuAST::IMPL::QASTContext, '', 0, 0, Any, '$task', 0, 0], anon sub add-cleanup-task ($SELF_CONT, $task!) {
        my $SELF := nqp::decont($SELF_CONT);
        $task := nqp::decont($task);
#line 116 src/Raku/ast/impl.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::IMPL::QASTContext, '$!cleanup-tasks'), $task)
    
    });
#line 4 src/Raku/ast/impl.rakumod
    add-method(RakuAST::IMPL::QASTContext, 'sc', [], anon sub sc ($self) { nqp::getattr(nqp::decont($self), RakuAST::IMPL::QASTContext, '$!sc') });
#line 5 src/Raku/ast/impl.rakumod
    add-method(RakuAST::IMPL::QASTContext, 'post-deserialize', [], anon sub post-deserialize ($self) { nqp::getattr(nqp::decont($self), RakuAST::IMPL::QASTContext, '$!post-deserialize') });
#line 26 src/Raku/ast/impl.rakumod
    add-method(RakuAST::IMPL::QASTContext, 'is-nested', [], anon sub is-nested ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::IMPL::QASTContext, '$!is-nested') });
#line 6 src/Raku/ast/impl.rakumod
    add-method(RakuAST::IMPL::QASTContext, 'code-ref-blocks', [], anon sub code-ref-blocks ($self) { nqp::getattr(nqp::decont($self), RakuAST::IMPL::QASTContext, '$!code-ref-blocks') });
#line 24 src/Raku/ast/impl.rakumod
    add-method(RakuAST::IMPL::QASTContext, 'cleanup-tasks', [], anon sub cleanup-tasks ($self) { nqp::getattr(nqp::decont($self), RakuAST::IMPL::QASTContext, '$!cleanup-tasks') });
    compose(RakuAST::IMPL::QASTContext);
    parent(RakuAST::IMPL::InterpContext, Any);
    compose(RakuAST::IMPL::InterpContext);
    parent(RakuAST::Resolver, Any);
    add-attribute(RakuAST::Resolver, Mu, '$!setting');
    add-attribute(RakuAST::Resolver, Mu, '$!outer');
    add-attribute(RakuAST::Resolver, Mu, '$!global');
    add-attribute(RakuAST::Resolver, Mu, '$!attach-targets');
    add-attribute(RakuAST::Resolver, Mu, '$!packages');
    add-attribute(RakuAST::Resolver, Mu, '$!nodes-with-check-time-problems');
    add-attribute(RakuAST::Resolver, Mu, '$!nodes-unresolved-after-check-time');
    add-attribute(RakuAST::Resolver, Mu, '$!export-package');
    add-method(RakuAST::Resolver, 'clone', [RakuAST::Resolver, '', 0, 0], anon sub clone ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 29 src/Raku/ast/resolver.rakumod
        
        my $clone := nqp::clone($SELF);
        nqp::bindattr($clone,RakuAST::Resolver,'$!attach-targets',
          nqp::clone(nqp::getattr($SELF, RakuAST::Resolver, '$!attach-targets')));
        nqp::bindattr($clone,RakuAST::Resolver,'$!packages',
          nqp::clone(nqp::getattr($SELF, RakuAST::Resolver, '$!packages')));
        $clone
    
    });
    add-method(RakuAST::Resolver, 'push-attach-target', [RakuAST::Resolver, '', 0, 0, RakuAST::AttachTarget, '$target', 0, 0], anon sub push-attach-target ($SELF_CONT, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $target := nqp::decont($target);
#line 39 src/Raku/ast/resolver.rakumod
        
        $target.clear-attachments();
        for $target.IMPL-UNWRAP-LIST($target.attach-target-names()) -> str $name {
            my @stack := nqp::getattr($SELF, RakuAST::Resolver, '$!attach-targets'){$name};
            unless nqp::isconcrete(@stack) {
                @stack := [];
                nqp::getattr($SELF, RakuAST::Resolver, '$!attach-targets'){$name} := @stack;
            }
            nqp::push(@stack, $target);
        }
        Nil
    
    });
    add-method(RakuAST::Resolver, 'pop-attach-target', [RakuAST::Resolver, '', 0, 0, RakuAST::AttachTarget, '$target', 0, 0], anon sub pop-attach-target ($SELF_CONT, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $target := nqp::decont($target);
#line 53 src/Raku/ast/resolver.rakumod
        
        for $target.IMPL-UNWRAP-LIST($target.attach-target-names()) -> str $name {
            my @stack := nqp::getattr($SELF, RakuAST::Resolver, '$!attach-targets'){$name};
            unless nqp::eqaddr(nqp::pop(@stack),$target) {
                nqp::die('Inconsistent attachment target stack for '
                  ~ $target.HOW.name($target));
            }
        }
        Nil
    
    });
    add-method(RakuAST::Resolver, 'find-attach-target', [RakuAST::Resolver, '', 0, 0, str, '$name', 0, 0], anon sub find-attach-target ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 67 src/Raku/ast/resolver.rakumod
        
        my @stack := nqp::getattr($SELF, RakuAST::Resolver, '$!attach-targets'){$name};
        nqp::isconcrete(@stack) && nqp::elems(@stack)
          ?? @stack[nqp::elems(@stack) - 1]
          !! Nil
    
    });
    add-method(RakuAST::Resolver, 'set-global', [RakuAST::Resolver, '', 0, 0, Mu, '$global', 0, 0], anon sub set-global ($SELF_CONT, $global!) {
        my $SELF := nqp::decont($SELF_CONT);
        $global := nqp::decont($global);
#line 75 src/Raku/ast/resolver.rakumod
        
        nqp::die("This resolver's GLOBAL is already set")
          unless nqp::eqaddr(nqp::getattr($SELF, RakuAST::Resolver, '$!global'),Mu);
        nqp::bindattr($SELF, RakuAST::Resolver, '$!global', $global);
        Nil
    
    });
    add-method(RakuAST::Resolver, 'get-global', [RakuAST::Resolver, '', 0, 0], anon sub get-global ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 82 src/Raku/ast/resolver.rakumod
         nqp::getattr($SELF, RakuAST::Resolver, '$!global') 
    });
    add-method(RakuAST::Resolver, 'set-export-package', [RakuAST::Resolver, '', 0, 0, Mu, '$package', 0, 0], anon sub set-export-package ($SELF_CONT, $package!) {
        my $SELF := nqp::decont($SELF_CONT);
        $package := nqp::decont($package);
#line 85 src/Raku/ast/resolver.rakumod
        
        nqp::die("This resolver's EXPORT is already set")
          unless nqp::eqaddr(nqp::getattr($SELF, RakuAST::Resolver, '$!export-package'),Mu);
        nqp::bindattr($SELF,RakuAST::Resolver,'$!export-package',$package);
        Nil
    
    });
    add-method(RakuAST::Resolver, 'push-package', [RakuAST::Resolver, '', 0, 0, RakuAST::Package, '$package', 0, 0], anon sub push-package ($SELF_CONT, $package!) {
        my $SELF := nqp::decont($SELF_CONT);
        $package := nqp::decont($package);
#line 93 src/Raku/ast/resolver.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Resolver, '$!packages'), $package);
        $SELF.push-attach-target($package);
        Nil
    
    });
    add-method(RakuAST::Resolver, 'current-package', [RakuAST::Resolver, '', 0, 0], anon sub current-package ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 101 src/Raku/ast/resolver.rakumod
        
        if nqp::elems(nqp::getattr($SELF, RakuAST::Resolver, '$!packages')) {
            nqp::getattr($SELF, RakuAST::Resolver, '$!packages')[nqp::elems(nqp::getattr($SELF, RakuAST::Resolver, '$!packages')) - 1].compile-time-value
        }
        else {
            my $current := nqp::getattr($SELF, RakuAST::Resolver, '$!outer');
            until nqp::eqaddr($current, nqp::getattr($SELF, RakuAST::Resolver, '$!setting')) {
                return nqp::atkey($current, '$?PACKAGE')
                  if nqp::existskey($current, '$?PACKAGE');
                $current := nqp::ctxouterskipthunks($current);
            }
            nqp::getattr($SELF, RakuAST::Resolver, '$!global')
        }
    
    });
    add-method(RakuAST::Resolver, 'pop-package', [RakuAST::Resolver, '', 0, 0], anon sub pop-package ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 117 src/Raku/ast/resolver.rakumod
        
        my $package := nqp::pop(nqp::getattr($SELF, RakuAST::Resolver, '$!packages'));
        $SELF.pop-attach-target($package);
        Nil
    
    });
    add-method(RakuAST::Resolver, 'packages', [RakuAST::Resolver, '', 0, 0], anon sub packages ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 124 src/Raku/ast/resolver.rakumod
        
        my $result := nqp::create(List);
        nqp::bindattr($result, List, '$!reified', nqp::getattr($SELF, RakuAST::Resolver, '$!packages'));
        $result
    
    });
    add-method(RakuAST::Resolver, 'resolve-infix', [RakuAST::Resolver, '', 0, 0, Str, '$name', 0, 0], anon sub resolve-infix ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 131 src/Raku/ast/resolver.rakumod
        
        $SELF.resolve-lexical('&infix' ~ $SELF.IMPL-CANONICALIZE-PAIR($name))
    
    });
    add-method(RakuAST::Resolver, 'resolve-prefix', [RakuAST::Resolver, '', 0, 0, Str, '$name', 0, 0], anon sub resolve-prefix ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 136 src/Raku/ast/resolver.rakumod
        
        $SELF.resolve-lexical('&prefix' ~ $SELF.IMPL-CANONICALIZE-PAIR($name))
    
    });
    add-method(RakuAST::Resolver, 'resolve-postfix', [RakuAST::Resolver, '', 0, 0, Str, '$name', 0, 0], anon sub resolve-postfix ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 141 src/Raku/ast/resolver.rakumod
        
        $SELF.resolve-lexical('&postfix' ~ $SELF.IMPL-CANONICALIZE-PAIR($name))
    
    });
    add-method(RakuAST::Resolver, 'resolve-term', [RakuAST::Resolver, '', 0, 0, Str, '$name', 0, 0], anon sub resolve-term ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 146 src/Raku/ast/resolver.rakumod
        
        $SELF.resolve-lexical('&term' ~ $SELF.IMPL-CANONICALIZE-PAIR($name))
    
    });
    add-method(RakuAST::Resolver, 'global-package', [RakuAST::Resolver, '', 0, 0], anon sub global-package ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 151 src/Raku/ast/resolver.rakumod
        
        RakuAST::VarDeclaration::Implicit::Constant.new(
          :name<GLOBAL>, :value(nqp::getattr($SELF, RakuAST::Resolver, '$!global'))
        )
    
    });
    add-method(RakuAST::Resolver, 'resolve-name', [RakuAST::Resolver, '', 0, 0, RakuAST::Name, '$Rname', 0, 0, str, '$sigil', 1, 1], anon sub resolve-name ($SELF_CONT, $Rname!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $Rname := nqp::decont($Rname);
        $sigil := nqp::decont($sigil);
#line 159 src/Raku/ast/resolver.rakumod
        
        my $found;
        if $Rname.is-identifier {
            my str $name := $Rname.canonicalize;
            return $SELF.global-package() if $name eq 'GLOBAL';

            # Single-part name, so look lexically.
            $name  := $sigil ~ $name if $sigil;
            $found := $SELF.resolve-lexical($name)
        }
        else {
            # All package name installations happen via the symbol table as
            # BEGIN-time effects, so chase it down as if it were a constant.
            $found := $SELF.resolve-name-constant($Rname, :$sigil)
        }

        $found || $SELF.IMPL-RESOLVE-NAME-IN-PACKAGES($Rname, :$sigil)
    
    });
    add-method(RakuAST::Resolver, 'resolve-name-constant', [RakuAST::Resolver, '', 0, 0, RakuAST::Name, '$Rname', 0, 0, str, '$sigil', 1, 1], anon sub resolve-name-constant ($SELF_CONT, $Rname!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $Rname := nqp::decont($Rname);
        $sigil := nqp::decont($sigil);
#line 179 src/Raku/ast/resolver.rakumod
        
        $SELF.IMPL-RESOLVE-NAME-CONSTANT($Rname, :$sigil)
          // $SELF.IMPL-RESOLVE-NAME-IN-PACKAGES($Rname, :$sigil)
    
    });
    add-method(RakuAST::Resolver, 'resolve-name-constant-in-setting', [RakuAST::Resolver, '', 0, 0, RakuAST::Name, '$Rname', 0, 0], anon sub resolve-name-constant-in-setting ($SELF_CONT, $Rname!) {
        my $SELF := nqp::decont($SELF_CONT);
        $Rname := nqp::decont($Rname);
#line 185 src/Raku/ast/resolver.rakumod
        
        $SELF.IMPL-RESOLVE-NAME-CONSTANT($Rname, :setting)
    
    });
    add-method(RakuAST::Resolver, 'external-constant', [RakuAST::Resolver, '', 0, 0, Mu, '$stash', 0, 0, str, '$lexical-name', 0, 0], anon sub external-constant ($SELF_CONT, $stash!, $lexical-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $stash := nqp::decont($stash);
        $lexical-name := nqp::decont($lexical-name);
#line 190 src/Raku/ast/resolver.rakumod
        
        RakuAST::Declaration::External::Constant.new(
          :$lexical-name, :compile-time-value(nqp::atkey($stash,$lexical-name))
        )
    
    });
    add-method(RakuAST::Resolver, 'IMPL-RESOLVE-NAME-IN-PACKAGES', [RakuAST::Resolver, '', 0, 0, Any, '$Rname', 0, 0, Any, '$sigil', 1, 1], anon sub IMPL-RESOLVE-NAME-IN-PACKAGES ($SELF_CONT, $Rname!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $Rname := nqp::decont($Rname);
        $sigil := nqp::decont($sigil);
#line 197 src/Raku/ast/resolver.rakumod
        

        # Try looking in the packages
        my str $name := $Rname.canonicalize;
# This breaks "our &foo" lookup.  But if the sigil isn't needed, why is
# it being passed as an argument then???   XXX
#        $name := $sigil ~ $name if $sigil;

        for nqp::getattr($SELF, RakuAST::Resolver, '$!packages') {
            my $stash := $SELF.IMPL-STASH-HASH($_.compile-time-value);
            return $SELF.external-constant($stash, $name)
              if nqp::existskey($stash,$name);
        }

        my $stash := $SELF.IMPL-STASH-HASH(nqp::getattr($SELF, RakuAST::Resolver, '$!global'));
        nqp::existskey($stash,$name)
          ?? $SELF.external-constant($stash, $name)
          !! Nil
    
    });
    add-method(RakuAST::Resolver, 'IMPL-RESOLVE-NAME-CONSTANT', [RakuAST::Resolver, '', 0, 0, RakuAST::Name, '$constant', 0, 0, Bool, '$setting', 1, 1, Bool, '$partial', 1, 1, str, '$sigil', 1, 1], anon sub IMPL-RESOLVE-NAME-CONSTANT ($SELF_CONT, $constant!, :$setting?, :$partial?, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $constant := nqp::decont($constant);
        $setting := nqp::decont($setting);
        $partial := nqp::decont($partial);
        $sigil := nqp::decont($sigil);
#line 222 src/Raku/ast/resolver.rakumod
        
        my @parts := nqp::clone($constant.IMPL-UNWRAP-LIST($constant.parts));
        nqp::die('0-part name lookup not possible as a constant')
          unless @parts;

        my $root := @parts.shift;
        # TODO pseudo-packages
        # TODO GLOBALish fallback
        if nqp::istype($root, RakuAST::Name::Part::Empty) {
            return Nil;
        }
        elsif nqp::istype($root, RakuAST::Name::Part::Expression) {
            return Nil;
        }

        # Resolve the root part.
        my $name     := $root.name;
        my $resolved := $name eq 'GLOBAL'
          ?? $SELF.global-package()
          !! $name eq 'EXPORT'
            ?? RakuAST::Declaration::ResolvedConstant.new(
                 compile-time-value => nqp::getattr($SELF, RakuAST::Resolver, '$!export-package')
               )
            !! $setting
              ?? $SELF.resolve-lexical-constant-in-setting($name)
              !! $SELF.resolve-lexical-constant($name);
        $resolved
          ?? (my $symbol := $resolved.compile-time-value)
          !! (return Nil);

        # Other parts to resolve.
        if @parts {
            # Chase down through the packages until we find something.
            while @parts {
                my $part := @parts.shift;
                $name    := nqp::istype($part,RakuAST::Name::Part::Simple)
                  ?? $part.name
                  !! '';

                # Add any sigil for last iteration
                $name := $sigil ~ $name unless @parts;

                # Lookup in the current symbol's stash
                my $next := nqp::atkey($SELF.IMPL-STASH-HASH($symbol),$name);
                if nqp::isnull($next) {
                    if $partial {
                        # put the symbol we failed to resolve back into the list
                        nqp::unshift(@parts, $part);
                        return ($symbol, $constant.IMPL-WRAP-LIST(@parts));
                    }
                    else {
                        return Nil
                    }
                }
                $symbol := $next;
            }

            # Wrap it.
            $resolved := RakuAST::Declaration::ResolvedConstant.new(
              compile-time-value => $symbol
            );
        }

        $partial ?? ($symbol, List.new) !! $resolved
    
    });
    add-method(RakuAST::Resolver, 'partially-resolve-name-constant', [RakuAST::Resolver, '', 0, 0, RakuAST::Name, '$Rname', 0, 0, str, '$sigil', 1, 1], anon sub partially-resolve-name-constant ($SELF_CONT, $Rname!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $Rname := nqp::decont($Rname);
        $sigil := nqp::decont($sigil);
#line 289 src/Raku/ast/resolver.rakumod
        
        $SELF.IMPL-RESOLVE-NAME-CONSTANT($Rname, :$sigil, :partial)
    
    });
    add-method(RakuAST::Resolver, 'IMPL-STASH-HASH', [RakuAST::Resolver, '', 0, 0, Mu, '$pkg', 0, 0], anon sub IMPL-STASH-HASH ($SELF_CONT, $pkg!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pkg := nqp::decont($pkg);
#line 293 src/Raku/ast/resolver.rakumod
        
        nqp::ishash(my $hash := $pkg.WHO)
          ?? $hash
          !! $hash.FLATTENABLE_HASH()
    
    });
    add-method(RakuAST::Resolver, 'resolve-lexical-in-outer', [RakuAST::Resolver, '', 0, 0, Str, '$name', 0, 0, Bool, '$current-scope-only', 1, 1], anon sub resolve-lexical-in-outer ($SELF_CONT, $name!, :$current-scope-only?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $current-scope-only := nqp::decont($current-scope-only);
#line 300 src/Raku/ast/resolver.rakumod
        

        # Mapping primspec to apprpriate native type
        my constant PRIMSPEC-TO-TYPE := nqp::list(Mu, int, num, str);

        # Look through the contexts for the name.
        my $context := nqp::getattr($SELF, RakuAST::Resolver, '$!outer');
        my int $seen-setting;
        until nqp::isnull($context) {
            $seen-setting := 1 if nqp::existskey($context,'CORE-SETTING-REV');

            # found it!
            if nqp::existskey($context,$name) {
                my $prim-spec := nqp::lexprimspec($context,$name);
                if $prim-spec {
                    return RakuAST::Declaration::External.new(
                      :lexical-name($name),
                      :native-type(PRIMSPEC-TO-TYPE[$prim-spec])
                    );
                }

                # Non-native things in the setting are assumed constant
                elsif $seen-setting {
                    return RakuAST::Declaration::External::Setting.new(
                      :lexical-name($name),
                      :compile-time-value(nqp::atkey($context, $name))
                    );
                }

                # 
                else {
                    return RakuAST::Declaration::External.new(
                      :lexical-name($name)
                    );
                }
            }

            # not found, and requested to only look in this scope
            elsif $current-scope-only {
                return Nil;
            }

            $context := nqp::ctxouter($context);
        }

        # Nothing found.
        Nil
    
    });
    add-method(RakuAST::Resolver, 'setting-constant', [RakuAST::Resolver, '', 0, 0, Str, '$name', 0, 0], anon sub setting-constant ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 351 src/Raku/ast/resolver.rakumod
        
        nqp::isconcrete(
          my $resolved := $SELF.resolve-lexical-constant-in-setting($name)
        ) ?? $resolved.compile-time-value
          !! $resolved
    
    });
    add-method(RakuAST::Resolver, 'resolve-lexical-constant-in-context', [RakuAST::Resolver, '', 0, 0, Mu, '$context', 0, 0, Str, '$name', 0, 0], anon sub resolve-lexical-constant-in-context ($SELF_CONT, $context!, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $name := nqp::decont($name);
#line 360 src/Raku/ast/resolver.rakumod
        
        until nqp::isnull($context) {
            nqp::existskey($context, $name)
              ?? (return $SELF.external-constant($context, $name))
              !! ($context := nqp::ctxouter($context));
        }
        Nil
    
    });
    add-method(RakuAST::Resolver, 'resolve-lexical-constant-in-outer', [RakuAST::Resolver, '', 0, 0, Str, '$name', 0, 0], anon sub resolve-lexical-constant-in-outer ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 371 src/Raku/ast/resolver.rakumod
        
        $SELF.resolve-lexical-constant-in-context(nqp::getattr($SELF, RakuAST::Resolver, '$!outer'), $name)
    
    });
    add-method(RakuAST::Resolver, 'resolve-lexical-constant-in-setting', [RakuAST::Resolver, '', 0, 0, Str, '$name', 0, 0], anon sub resolve-lexical-constant-in-setting ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 377 src/Raku/ast/resolver.rakumod
        
        $SELF.resolve-lexical-constant-in-context(nqp::getattr($SELF, RakuAST::Resolver, '$!setting'), $name)
    
    });
    add-method(RakuAST::Resolver, 'IMPL-SETTING-FROM-CONTEXT', [RakuAST::Resolver, '', 0, 0, Mu, '$context', 0, 0], anon sub IMPL-SETTING-FROM-CONTEXT ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 382 src/Raku/ast/resolver.rakumod
        
        # TODO locate the setting frame
        until nqp::isnull($context) {
            nqp::existskey(nqp::ctxlexpad($context),'CORE-SETTING-REV')
              ?? (return $context)
              !! ($context := nqp::ctxouterskipthunks($context));
        }
        Nil
    
    });
    add-method(RakuAST::Resolver, 'IMPL-CANONICALIZE-PAIR', [RakuAST::Resolver, '', 0, 0, Str, '$v', 0, 0], anon sub IMPL-CANONICALIZE-PAIR ($SELF_CONT, $v!) {
        my $SELF := nqp::decont($SELF_CONT);
        $v := nqp::decont($v);
#line 395 src/Raku/ast/resolver.rakumod
        
        if $v ~~ /<[ < > ]>/ && !($v ~~ /<[ « » $ \\ " ' ]>/) {
            ':«' ~ $v ~ '»'
        }
        else {
            my $new := '';
            my int $i := 0;
            my int $e := nqp::chars($v);
            while $i < $e {
                my $ch := nqp::substr($v,$i,1);
                $new := $new ~ '\\' if $ch eq '<' || $ch eq '>';
                $new := $new ~ $ch;
                ++$i;
            }
            ':<' ~ $new ~ '>';
        }
    
    });
    add-method(RakuAST::Resolver, 'is-identifier-type', [RakuAST::Resolver, '', 0, 0, Str, '$identifier', 0, 0], anon sub is-identifier-type ($SELF_CONT, $identifier!) {
        my $SELF := nqp::decont($SELF_CONT);
        $identifier := nqp::decont($identifier);
#line 414 src/Raku/ast/resolver.rakumod
        
        # Can optimize this later to avoid the throwaway name creation
        $SELF.is-name-type(RakuAST::Name.from-identifier($identifier))
    
    });
    add-method(RakuAST::Resolver, 'is-name-type', [RakuAST::Resolver, '', 0, 0, RakuAST::Name, '$Rname', 0, 0], anon sub is-name-type ($SELF_CONT, $Rname!) {
        my $SELF := nqp::decont($SELF_CONT);
        $Rname := nqp::decont($Rname);
#line 420 src/Raku/ast/resolver.rakumod
        
        my $constant := $SELF.resolve-name($Rname);
        nqp::istype($constant, RakuAST::CompileTimeValue)
             # Name resolves, but is it an instance or a type object?
          ?? nqp::isconcrete($constant.compile-time-value)
            ?? (Bool.WHO)<False>
            !! (Bool.WHO)<True>
             # Name doesn't resolve to a constant at all, so can't be a type.
          !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Resolver, 'is-identifier-known', [RakuAST::Resolver, '', 0, 0, Str, '$identifier', 0, 0, Any, '$exact', 1, 1], anon sub is-identifier-known ($SELF_CONT, $identifier!, :$exact?) {
        my $SELF := nqp::decont($SELF_CONT);
        $identifier := nqp::decont($identifier);
        $exact := nqp::decont($exact);
#line 432 src/Raku/ast/resolver.rakumod
        
        nqp::isconcrete($SELF.resolve-lexical($identifier))
          ?? (Bool.WHO)<True>
          !! $exact
            ?? (Bool.WHO)<False>
            !! nqp::isconcrete($SELF.resolve-lexical('&' ~ $identifier))
              ?? (Bool.WHO)<True>
              !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Resolver, 'is-name-known', [RakuAST::Resolver, '', 0, 0, RakuAST::Name, '$Rname', 0, 0], anon sub is-name-known ($SELF_CONT, $Rname!) {
        my $SELF := nqp::decont($SELF_CONT);
        $Rname := nqp::decont($Rname);
#line 443 src/Raku/ast/resolver.rakumod
        
        $Rname.is-pseudo-package || nqp::isconcrete($SELF.resolve-name($Rname))
          ?? (Bool.WHO)<True>
          !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Resolver, 'build-exception', [RakuAST::Resolver, '', 0, 0, Str, '$type-name', 0, 0, Any, '%opts', 0, 0], anon sub build-exception ($SELF_CONT, $type-name!, *%opts) {
        my $SELF := nqp::decont($SELF_CONT);
        $type-name := nqp::decont($type-name);
        %opts := nqp::decont(%opts);
#line 450 src/Raku/ast/resolver.rakumod
        
        my $name := RakuAST::Name.from-identifier-parts(|nqp::split('::', $type-name));
        my $type-res := $SELF.resolve-name-constant-in-setting($name);
        my $XComp-res := $SELF.resolve-name-constant-in-setting:
            RakuAST::Name.from-identifier-parts('X', 'Comp');
        if $type-res && $XComp-res {
            # Successfully resolved. Maka sure it is an X::Comp.
            my $type := $type-res.compile-time-value;
            my $XComp := $XComp-res.compile-time-value;
            unless nqp::istype($type, $XComp) {
                $type := $type.HOW.mixin($type, $XComp);
            }

            # Ensure that the options are Raku types.
            for %opts -> $p {
                if nqp::islist($p.value) {
                    my @a := [];
                    for $p.value {
                        nqp::push(@a, nqp::hllizefor($_, 'Raku'));
                    }
                    %opts{$p.key} := nqp::hllizefor(@a, 'Raku');
                }
                else {
                    %opts{$p.key} := nqp::hllizefor($p.value, 'Raku');
                }
            }

            # Construct the exception object and return it.
            %opts<is-compile-time> := (Bool.WHO)<True>;
            $type.new(|%opts)
        }
        else {
            # Could not find exception type, so build a fake (typically happens
            # during CORE.setting compilation).
            nqp::die('nyi missing exception type fallback')
        }
    
    });
    add-method(RakuAST::Resolver, 'add-node-with-check-time-problems', [RakuAST::Resolver, '', 0, 0, RakuAST::CheckTime, '$node', 0, 0], anon sub add-node-with-check-time-problems ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 489 src/Raku/ast/resolver.rakumod
        
        unless nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-with-check-time-problems') {
            nqp::bindattr($SELF, RakuAST::Resolver, '$!nodes-with-check-time-problems', []);
        }
        nqp::push(nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-with-check-time-problems'), $node);
        Nil
    
    });
    add-method(RakuAST::Resolver, 'add-node-unresolved-after-check-time', [RakuAST::Resolver, '', 0, 0, RakuAST::Lookup, '$node', 0, 0], anon sub add-node-unresolved-after-check-time ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 498 src/Raku/ast/resolver.rakumod
        
        unless nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-unresolved-after-check-time') {
            nqp::bindattr($SELF, RakuAST::Resolver, '$!nodes-unresolved-after-check-time', []);
        }
        nqp::push(nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-unresolved-after-check-time'), $node);
        Nil
    
    });
    add-method(RakuAST::Resolver, 'produce-compilation-exception', [RakuAST::Resolver, '', 0, 0, Any, '$panic', 1, 1], anon sub produce-compilation-exception ($SELF_CONT, :$panic?) {
        my $SELF := nqp::decont($SELF_CONT);
        $panic := nqp::decont($panic);
#line 511 src/Raku/ast/resolver.rakumod
        
        my $sorries := $SELF.all-sorries;
        my $worries := $SELF.all-worries;
        my int $num-sorries := $sorries.elems;
        my int $num-worries := $worries.elems;

        if $panic && $num-sorries == 0 && $num-worries == 0 {
            # There's just the panic, so return it without an enclosing group.
            $panic
        }
        elsif !$panic && $num-sorries == 1 && $num-worries == 0 {
            # Only one sorry and no worries, so no need to wrap that either.
            $sorries.AT-POS(0)
        }
        elsif $num-sorries || $num-worries {
            # Resolve the group exception type.
            my $XCompGroup-res := $SELF.resolve-name-constant-in-setting:
                RakuAST::Name.from-identifier-parts('X', 'Comp', 'Group');
            if $XCompGroup-res {
                my $XCompGroup := $XCompGroup-res.compile-time-value;
                $panic
                  ?? $XCompGroup.new(:$panic, :$sorries, :$worries)
                  !! $XCompGroup.new(         :$sorries, :$worries)
            }
            # Fallback if missing group.
            else {
                $panic || $sorries.AT-POS(0)
            }
        }
        else {
            Nil
        }
    
    });
    add-method(RakuAST::Resolver, 'has-compilation-errors', [RakuAST::Resolver, '', 0, 0], anon sub has-compilation-errors ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 546 src/Raku/ast/resolver.rakumod
         $SELF.all-sorries.Bool 
    });
    add-method(RakuAST::Resolver, 'all-sorries', [RakuAST::Resolver, '', 0, 0], anon sub all-sorries ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 550 src/Raku/ast/resolver.rakumod
        
        my @sorries;
        if nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-with-check-time-problems') {
            for nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-with-check-time-problems') -> $node {
                for $node.IMPL-UNWRAP-LIST($node.sorries) {
                    @sorries.push($_);
                }
            }
        }
        for RakuAST::Node.IMPL-UNWRAP-LIST($SELF.unresolved-symbol-exceptions) {
            @sorries.push($_);
        }
        RakuAST::Node.IMPL-WRAP-LIST(@sorries)
    
    });
    add-method(RakuAST::Resolver, 'all-worries', [RakuAST::Resolver, '', 0, 0], anon sub all-worries ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 567 src/Raku/ast/resolver.rakumod
        
        my @worries;
        if nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-with-check-time-problems') {
            for nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-with-check-time-problems') -> $node {
                for $node.IMPL-UNWRAP-LIST($node.worries) {
                    @worries.push($_);
                }
            }
        }
        RakuAST::Node.IMPL-WRAP-LIST(@worries)
    
    });
    add-method(RakuAST::Resolver, 'unresolved-symbol-exceptions', [RakuAST::Resolver, '', 0, 0], anon sub unresolved-symbol-exceptions ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 581 src/Raku/ast/resolver.rakumod
        
        my %types;
        my %routines;
        my @exceptions;
        if nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-unresolved-after-check-time') {
            for nqp::getattr($SELF, RakuAST::Resolver, '$!nodes-unresolved-after-check-time') -> $node {
                my $problem := $node.undeclared-symbol-details();
                if $problem {
                    $problem.IMPL-REPORT($node, %types, %routines, @exceptions);
                }
            }
        }
        if %routines || %types {
            @exceptions.push: $SELF.build-exception: 'X::Undeclared::Symbols',
                :unk_types(nqp::hllizefor(%types, 'Raku')),
                :unk_routines(nqp::hllizefor(%routines, 'Raku'));
        }
        RakuAST::Node.IMPL-WRAP-LIST(@exceptions)
    
    });
#line 4 src/Raku/ast/resolver.rakumod
    add-method(RakuAST::Resolver, 'setting', [], anon sub setting ($self) { nqp::getattr(nqp::decont($self), RakuAST::Resolver, '$!setting') });
    compose(RakuAST::Resolver);
    parent(RakuAST::Resolver::EVAL, RakuAST::Resolver);
    add-attribute(RakuAST::Resolver::EVAL, Mu, '$!scopes');
    add-method(RakuAST::Resolver::EVAL, 'new', [RakuAST::Resolver::EVAL, '', 0, 0, Mu, '$global', 1, 0, Mu, '$context', 1, 0], anon sub new ($SELF_CONT, :$global!, :$context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $global := nqp::decont($global);
        $context := nqp::decont($context);
#line 612 src/Raku/ast/resolver.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Resolver, '$!outer', $context);
        nqp::bindattr($obj, RakuAST::Resolver, '$!setting',
            $SELF.IMPL-SETTING-FROM-CONTEXT($context));
        nqp::bindattr($obj, RakuAST::Resolver, '$!global', $global);
        nqp::bindattr($obj, RakuAST::Resolver, '$!attach-targets', nqp::hash());
        my $cur-package := $obj.resolve-lexical-constant-in-outer('$?PACKAGE');
        nqp::bindattr($obj, RakuAST::Resolver, '$!packages',
            $cur-package ?? [$cur-package] !! []);
        nqp::bindattr($obj, RakuAST::Resolver::EVAL, '$!scopes', []);
        $obj
    
    });
    add-method(RakuAST::Resolver::EVAL, 'clone', [RakuAST::Resolver::EVAL, '', 0, 0], anon sub clone ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 627 src/Raku/ast/resolver.rakumod
        
        my $clone := nqp::findmethod(RakuAST::Resolver, 'clone')($SELF);
        nqp::bindattr($clone, RakuAST::Resolver::EVAL, '$!scopes', nqp::clone(nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes')));
        $clone
    
    });
    add-method(RakuAST::Resolver::EVAL, 'push-scope', [RakuAST::Resolver::EVAL, '', 0, 0, RakuAST::LexicalScope, '$scope', 0, 0], anon sub push-scope ($SELF_CONT, $scope!) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
#line 634 src/Raku/ast/resolver.rakumod
        
        nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes').push($scope);
        if nqp::istype($scope, RakuAST::AttachTarget) {
            $SELF.push-attach-target($scope);
        }
        Nil
    
    });
    add-method(RakuAST::Resolver::EVAL, 'current-scope', [RakuAST::Resolver::EVAL, '', 0, 0], anon sub current-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 643 src/Raku/ast/resolver.rakumod
        
        nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes')[nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes')) - 1]
    
    });
    add-method(RakuAST::Resolver::EVAL, 'outer-scope', [RakuAST::Resolver::EVAL, '', 0, 0], anon sub outer-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 646 src/Raku/ast/resolver.rakumod
        
        nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes')[nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes')) - 2]
    
    });
    add-method(RakuAST::Resolver::EVAL, 'pop-scope', [RakuAST::Resolver::EVAL, '', 0, 0], anon sub pop-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 651 src/Raku/ast/resolver.rakumod
        
        my $scope := nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes').pop;
        $SELF.pop-attach-target($scope)
          if nqp::istype($scope, RakuAST::AttachTarget);
        Nil
    
    });
    add-method(RakuAST::Resolver::EVAL, 'resolve-lexical', [RakuAST::Resolver::EVAL, '', 0, 0, Str, '$name', 0, 0, Bool, '$current-scope-only', 1, 1], anon sub resolve-lexical ($SELF_CONT, $name!, :$current-scope-only?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $current-scope-only := nqp::decont($current-scope-only);
#line 660 src/Raku/ast/resolver.rakumod
        
        my @scopes := nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes');

        # If it's in the current scope only, just look at the top one, if any
        if $current-scope-only {
            return nqp::elems(@scopes)
              ?? @scopes[nqp::elems(@scopes) - 1].find-lexical($name)
              !! Nil;
        }

        # No need to look further
        if $name eq 'GLOBAL' {
            $SELF.global-package;
        }

        # Walk active scopes, most nested first.
        else {
            my int $i := nqp::elems(@scopes);
            while $i-- {
                my $found := @scopes[$i].find-lexical($name);
                return $found if nqp::isconcrete($found);
            }

            # Fallback handling
            $SELF.resolve-lexical-in-outer($name)
        }
    
    });
    add-method(RakuAST::Resolver::EVAL, 'resolve-lexical-constant', [RakuAST::Resolver::EVAL, '', 0, 0, Str, '$name', 0, 0], anon sub resolve-lexical-constant ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 690 src/Raku/ast/resolver.rakumod
        

        # No need to look further
        if $name eq 'GLOBAL' {
            $SELF.global-package;
        }

        # Walk active scopes, most nested first.
        else {
            my @scopes := nqp::getattr($SELF, RakuAST::Resolver::EVAL, '$!scopes');
            my int $i  := nqp::elems(@scopes);
            while $i-- {
                my $found := @scopes[$i].find-lexical($name);
                if nqp::isconcrete($found) {
                    nqp::istype($found,RakuAST::CompileTimeValue)
                      ?? (return $found)
                      !! nqp::die(
                           "Symbol '$name' does not have a compile-time value"
                         );
                }
            }

            # Fallback handling
            $SELF.resolve-lexical-constant-in-outer($name)
        }
    
    });
    compose(RakuAST::Resolver::EVAL);
    parent(RakuAST::Resolver::Compile, RakuAST::Resolver);
    add-attribute(RakuAST::Resolver::Compile, Mu, '$!scopes');
    add-attribute(RakuAST::Resolver::Compile, Mu, '$!sorries');
    add-attribute(RakuAST::Resolver::Compile, Mu, '$!worries');
    add-method(RakuAST::Resolver::Compile, 'new', [RakuAST::Resolver::Compile, '', 0, 0, Mu, '$setting', 1, 0, Mu, '$outer', 1, 0, Mu, '$global', 1, 0, Mu, '$scopes', 1, 1], anon sub new ($SELF_CONT, :$setting!, :$outer!, :$global!, :$scopes?) {
        my $SELF := nqp::decont($SELF_CONT);
        $setting := nqp::decont($setting);
        $outer := nqp::decont($outer);
        $global := nqp::decont($global);
        $scopes := nqp::decont($scopes);
#line 735 src/Raku/ast/resolver.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Resolver, '$!setting', $setting);
        nqp::bindattr($obj, RakuAST::Resolver, '$!outer', $outer);
        nqp::bindattr($obj, RakuAST::Resolver, '$!attach-targets', nqp::hash());
        nqp::bindattr($obj, RakuAST::Resolver, '$!global', $global);
        nqp::bindattr($obj, RakuAST::Resolver, '$!packages', []);

        nqp::bindattr($obj, RakuAST::Resolver::Compile, '$!scopes',
          $scopes // []);
        nqp::bindattr($obj, RakuAST::Resolver::Compile, '$!sorries', []);
        nqp::bindattr($obj, RakuAST::Resolver::Compile, '$!worries', []);
        $obj
    
    });
    add-method(RakuAST::Resolver::Compile, 'from-context', [RakuAST::Resolver::Compile, '', 0, 0, Mu, '$context', 1, 0, Mu, '$global', 1, 0, RakuAST::Resolver, '$resolver', 1, 1], anon sub from-context ($SELF_CONT, :$context!, :$global!, :$resolver?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $global := nqp::decont($global);
        $resolver := nqp::decont($resolver);
#line 752 src/Raku/ast/resolver.rakumod
        
        my $setting := $resolver
            ?? nqp::getattr($resolver, RakuAST::Resolver, '$!setting')
            !! $SELF.IMPL-SETTING-FROM-CONTEXT($context);
        $SELF.new(
            :$setting,
            :outer($resolver ?? $setting !! $context),
            :$global,
            :scopes($resolver ?? nqp::getattr($resolver, RakuAST::Resolver::Compile, '$!scopes') !! Mu)
        )
    
    });
    add-method(RakuAST::Resolver::Compile, 'clone', [RakuAST::Resolver::Compile, '', 0, 0], anon sub clone ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 764 src/Raku/ast/resolver.rakumod
        
        my $clone := nqp::findmethod(RakuAST::Resolver, 'clone')($SELF);
        nqp::bindattr($clone, RakuAST::Resolver::Compile, '$!scopes', nqp::clone(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')));
        $clone
    
    });
    add-method(RakuAST::Resolver::Compile, 'from-setting', [RakuAST::Resolver::Compile, '', 0, 0, Str, '$setting-name', 1, 0], anon sub from-setting ($SELF_CONT, :$setting-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $setting-name := nqp::decont($setting-name);
#line 772 src/Raku/ast/resolver.rakumod
        
        my $loader := nqp::gethllsym('Raku', 'ModuleLoader');
        my $setting := $loader.load_setting($setting-name);
        # We can't actually have the global yet, since the resolver is
        # needed in order to look up the package meta-object used to
        # create it. Thus it's set later.
        $SELF.new(:$setting, :outer($setting), :global(Mu))
    
    });
    add-method(RakuAST::Resolver::Compile, 'set-setting', [RakuAST::Resolver::Compile, '', 0, 0, Str, '$setting-name', 1, 0], anon sub set-setting ($SELF_CONT, :$setting-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $setting-name := nqp::decont($setting-name);
#line 781 src/Raku/ast/resolver.rakumod
        
        my $loader := nqp::gethllsym('Raku', 'ModuleLoader');
        my $setting := $loader.load_setting($setting-name);
        nqp::bindattr($SELF, RakuAST::Resolver, '$!setting', $setting);
        nqp::bindattr($SELF, RakuAST::Resolver, '$!outer', $setting);
    
    });
    add-method(RakuAST::Resolver::Compile, 'push-scope', [RakuAST::Resolver::Compile, '', 0, 0, RakuAST::LexicalScope, '$scope', 0, 0], anon sub push-scope ($SELF_CONT, $scope!) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
#line 790 src/Raku/ast/resolver.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes'), RakuAST::Resolver::Compile::Scope.new(:$scope, :batch-mode));
        if nqp::istype($scope, RakuAST::AttachTarget) {
            $SELF.push-attach-target($scope);
        }
        Nil
    
    });
    add-method(RakuAST::Resolver::Compile, 'current-scope', [RakuAST::Resolver::Compile, '', 0, 0], anon sub current-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 799 src/Raku/ast/resolver.rakumod
        
        nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')[nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')) - 1].scope
    
    });
    add-method(RakuAST::Resolver::Compile, 'outer-scope', [RakuAST::Resolver::Compile, '', 0, 0], anon sub outer-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 802 src/Raku/ast/resolver.rakumod
        
        nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')[nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')) - 2].scope
    
    });
    add-method(RakuAST::Resolver::Compile, 'pop-scope', [RakuAST::Resolver::Compile, '', 0, 0], anon sub pop-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 807 src/Raku/ast/resolver.rakumod
        
        my $scope := nqp::pop(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes'));
        $scope.batch-mode ||
            nqp::die('pop-scope should only be used on batch mode scopes');
        if nqp::istype($scope.scope, RakuAST::AttachTarget) {
            $SELF.pop-attach-target($scope.scope);
        }
        Nil
    
    });
    add-method(RakuAST::Resolver::Compile, 'enter-scope', [RakuAST::Resolver::Compile, '', 0, 0, RakuAST::LexicalScope, '$scope', 0, 0], anon sub enter-scope ($SELF_CONT, $scope!) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
#line 820 src/Raku/ast/resolver.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes'), RakuAST::Resolver::Compile::Scope.new(:$scope, :!batch-mode));
        if nqp::istype($scope, RakuAST::AttachTarget) {
            $SELF.push-attach-target($scope);
        }
        Nil
    
    });
    add-method(RakuAST::Resolver::Compile, 'create-scope-implicits', [RakuAST::Resolver::Compile, '', 0, 0], anon sub create-scope-implicits ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 831 src/Raku/ast/resolver.rakumod
        
        nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')[nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')) - 1].create-implicits();
        Nil
    
    });
    add-method(RakuAST::Resolver::Compile, 'leave-scope', [RakuAST::Resolver::Compile, '', 0, 0], anon sub leave-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 837 src/Raku/ast/resolver.rakumod
        
        my $scope := nqp::pop(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes'));
        $scope.batch-mode &&
            nqp::die('leave-scope should never be used on batch mode scopes');
        if nqp::istype($scope.scope, RakuAST::AttachTarget) {
            $SELF.pop-attach-target($scope.scope);
        }
        Nil
    
    });
    add-method(RakuAST::Resolver::Compile, 'declare-lexical', [RakuAST::Resolver::Compile, '', 0, 0, RakuAST::Declaration, '$decl', 0, 0], anon sub declare-lexical ($SELF_CONT, $decl!) {
        my $SELF := nqp::decont($SELF_CONT);
        $decl := nqp::decont($decl);
#line 850 src/Raku/ast/resolver.rakumod
        
        nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')[nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')) - 1].declare-lexical($decl)
    
    });
    add-method(RakuAST::Resolver::Compile, 'declare-lexical-in-outer', [RakuAST::Resolver::Compile, '', 0, 0, RakuAST::Declaration, '$decl', 0, 0], anon sub declare-lexical-in-outer ($SELF_CONT, $decl!) {
        my $SELF := nqp::decont($SELF_CONT);
        $decl := nqp::decont($decl);
#line 857 src/Raku/ast/resolver.rakumod
        
        nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')[nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes')) - 2].declare-lexical($decl)
    
    });
    add-method(RakuAST::Resolver::Compile, 'resolve-lexical', [RakuAST::Resolver::Compile, '', 0, 0, Str, '$name', 0, 0, Bool, '$current-scope-only', 1, 1], anon sub resolve-lexical ($SELF_CONT, $name!, :$current-scope-only?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $current-scope-only := nqp::decont($current-scope-only);
#line 863 src/Raku/ast/resolver.rakumod
        
        # If it's in the current scope only, we just look at the top one.
        if $current-scope-only {
            my @scopes := nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes');
            my int $i := nqp::elems(@scopes);
            return $i > 0 ?? @scopes[$i - 1].find-lexical($name) !! Nil;
        }

        if $name eq 'GLOBAL' {
            return $SELF.global-package;
        }

        # Walk active scopes, most nested first.
        my @scopes := nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes');
        my int $i := nqp::elems(@scopes);
        while $i-- {
            my $scope := @scopes[$i];
            my $found := $scope.find-lexical($name);
            return $found if nqp::isconcrete($found);
        }

        $SELF.resolve-lexical-in-outer($name)
    
    });
    add-method(RakuAST::Resolver::Compile, 'resolve-lexical-constant', [RakuAST::Resolver::Compile, '', 0, 0, Str, '$name', 0, 0], anon sub resolve-lexical-constant ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 889 src/Raku/ast/resolver.rakumod
        
        if $name eq 'GLOBAL' {
            return $SELF.global-package;
        }

        # Walk active scopes, most nested first.
        my @scopes := nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes');
        my int $i := nqp::elems(@scopes);
        while $i-- {
            my $scope := @scopes[$i];
            my $found := $scope.find-lexical($name);
            if nqp::isconcrete($found) {
                if nqp::istype($found, RakuAST::CompileTimeValue) {
                    return $found;
                }
                else {
                    nqp::die("Symbol '$name' does not have a compile-time value");
                }
            }
        }

        # Fall back to looking in outer scopes.
        $SELF.resolve-lexical-constant-in-outer($name);
    
    });
    add-method(RakuAST::Resolver::Compile, 'add-sorry', [RakuAST::Resolver::Compile, '', 0, 0, Any, '$exception', 0, 0], anon sub add-sorry ($SELF_CONT, $exception!) {
        my $SELF := nqp::decont($SELF_CONT);
        $exception := nqp::decont($exception);
#line 915 src/Raku/ast/resolver.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!sorries'), $exception);
        Nil
    
    });
    add-method(RakuAST::Resolver::Compile, 'has-sorries', [RakuAST::Resolver::Compile, '', 0, 0], anon sub has-sorries ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 919 src/Raku/ast/resolver.rakumod
         nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!sorries')) > 0 
    });
    add-method(RakuAST::Resolver::Compile, 'add-worry', [RakuAST::Resolver::Compile, '', 0, 0, Any, '$exception', 0, 0], anon sub add-worry ($SELF_CONT, $exception!) {
        my $SELF := nqp::decont($SELF_CONT);
        $exception := nqp::decont($exception);
#line 922 src/Raku/ast/resolver.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!worries'), $exception);
        Nil
    
    });
    add-method(RakuAST::Resolver::Compile, 'has-worries', [RakuAST::Resolver::Compile, '', 0, 0], anon sub has-worries ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 926 src/Raku/ast/resolver.rakumod
         nqp::elems(nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!worries')) > 0 
    });
    add-method(RakuAST::Resolver::Compile, 'panic', [RakuAST::Resolver::Compile, '', 0, 0, Any, '$exception', 0, 0], anon sub panic ($SELF_CONT, $exception!) {
        my $SELF := nqp::decont($SELF_CONT);
        $exception := nqp::decont($exception);
#line 930 src/Raku/ast/resolver.rakumod
        
        $SELF.produce-compilation-exception(:panic($exception)).throw
    
    });
    add-method(RakuAST::Resolver::Compile, 'all-sorries', [RakuAST::Resolver::Compile, '', 0, 0], anon sub all-sorries ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 935 src/Raku/ast/resolver.rakumod
        
        my @sorries := RakuAST::Node.IMPL-UNWRAP-LIST:
            nqp::findmethod(RakuAST::Resolver,'all-sorries')($SELF);
        for nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!sorries') {
            @sorries.push($_);
        }
        RakuAST::Node.IMPL-WRAP-LIST(@sorries)
    
    });
    add-method(RakuAST::Resolver::Compile, 'all-worries', [RakuAST::Resolver::Compile, '', 0, 0], anon sub all-worries ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 945 src/Raku/ast/resolver.rakumod
        
        my @worries := RakuAST::Node.IMPL-UNWRAP-LIST:
            nqp::findmethod(RakuAST::Resolver,'all-worries')($SELF);
        for nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!worries') {
            @worries.push($_);
        }
        RakuAST::Node.IMPL-WRAP-LIST(@worries)
    
    });
    add-method(RakuAST::Resolver::Compile, 'levenshtein', [RakuAST::Resolver::Compile, '', 0, 0, Any, '$a', 0, 0, Any, '$b', 0, 0], anon sub levenshtein ($SELF_CONT, $a!, $b!) {
        my $SELF := nqp::decont($SELF_CONT);
        $a := nqp::decont($a);
        $b := nqp::decont($b);
#line 956 src/Raku/ast/resolver.rakumod
        
        my %memo;
        my int $alen := nqp::chars($a);
        my int $blen := nqp::chars($b);

        return 0 if $alen == 0 || $blen == 0;

        my sub changecost(str $ac, str $bc) {
            my sub issigil($_) { nqp::index('$@%&|', $_) != -1 };
            return 0 if $ac eq $bc;
            return 0.1 if nqp::fc($ac) eq nqp::fc($bc);
            return 0.5 if issigil($ac) && issigil($bc);
            1;
        }

        my sub levenshtein_impl(int $apos, int $bpos, num $estimate) {
            my $key := "$apos:$bpos";

            return %memo{$key} if nqp::existskey(%memo, $key);

            # if either cursor reached the end of the respective string,
            # the result is the remaining length of the other string.
            my sub check(int $pos1, int $len1, int $pos2, int $len2) {
                if $pos2 == $len2 {
                    return $len1 - $pos1;
                }
                -1;
            }

            my int $check := check($apos, $alen, $bpos, $blen);
            return $check unless $check == -1;
            $check := check($bpos, $blen, $apos, $alen);
            return $check unless $check == -1;

            my str $achar := nqp::substr($a, $apos, 1);
            my str $bchar := nqp::substr($b, $bpos, 1);

            my num $cost := changecost($achar, $bchar);

            # hyphens and underscores cost half when adding/deleting.
            my num $addcost := 1;
            $addcost := 0.5 if $bchar eq "-" || $bchar eq "_";

            my num $delcost := 1;
            $delcost := 0.5 if $achar eq "-" || $achar eq "_";

            my num $ca := nqp::add_n(levenshtein_impl($apos+1, $bpos,   nqp::add_n($estimate, $delcost)), $delcost); # what if we remove the current letter from A?
            my num $cb := nqp::add_n(levenshtein_impl($apos,   $bpos+1, nqp::add_n($estimate, $addcost)), $addcost); # what if we add the current letter from B?
            my num $cc := nqp::add_n(levenshtein_impl($apos+1, $bpos+1, nqp::add_n($estimate, $cost)), $cost); # what if we change/keep the current letter?

            # the result is the shortest of the three sub-tasks
            my num $distance;
            $distance := $ca if nqp::isle_n($ca, $cb) && nqp::isle_n($ca, $cc);
            $distance := $cb if nqp::isle_n($cb, $ca) && nqp::isle_n($cb, $cc);
            $distance := $cc if nqp::isle_n($cc, $ca) && nqp::isle_n($cc, $cb);

            # switching two letters costs only 1 instead of 2.
            if $apos + 1 <= $alen && $bpos + 1 <= $blen &&
               nqp::eqat($a, $bchar, $apos + 1) && nqp::eqat($b, $achar, $bpos + 1) {
                my num $cd := nqp::add_n(levenshtein_impl($apos+2, $bpos+2, nqp::add_n($estimate, 1)), 1);
                $distance := $cd if nqp::islt_n($cd, $distance);
            }

            %memo{$key} := $distance;
        }

        return levenshtein_impl(0, 0, 0e0);
    
    });
    add-method(RakuAST::Resolver::Compile, 'make_levenshtein_evaluator', [RakuAST::Resolver::Compile, '', 0, 0, Any, '$orig_name', 0, 0, Any, '@candidates', 0, 0], anon sub make_levenshtein_evaluator ($SELF_CONT, $orig_name!, @candidates!) {
        my $SELF := nqp::decont($SELF_CONT);
        $orig_name := nqp::decont($orig_name);
        @candidates := nqp::decont(@candidates);
#line 1025 src/Raku/ast/resolver.rakumod
        
        my $find-count := 0;
        my $try-count := 0;
        my &inner := my sub ($name) {
            # difference in length is a good lower bound.
            $try-count := $try-count + 1;
            return 0 if $find-count > 20 || $try-count > 1000;
            my $parlen := nqp::chars($orig_name);
            my $lendiff := nqp::chars($name) - $parlen;
            $lendiff := -$lendiff if $lendiff < 0;
            return 1 if nqp::isge_n($lendiff, nqp::mul_n($parlen, 0.3));

            my num $dist := nqp::div_n($SELF.levenshtein($orig_name, $name), $parlen);
            my $target := -1;
            $target := @candidates[0] if nqp::isle_n($dist, 0.1);
            $target := @candidates[1] if nqp::islt_n(0.1, $dist) && nqp::isle_n($dist, 0.2);
            $target := @candidates[2] if nqp::islt_n(0.2, $dist) && nqp::isle_n($dist, 0.35);
            if $target != -1 {
                my $name-str := nqp::box_s($name, Str);
                nqp::push($target, $name-str);
                $find-count := $find-count + 1;
            }
            1;
        }
        return &inner;
    
    });
    add-method(RakuAST::Resolver::Compile, 'levenshtein_candidate_heuristic', [RakuAST::Resolver::Compile, '', 0, 0, Any, '@candidates', 0, 0, Any, '$target', 0, 0], anon sub levenshtein_candidate_heuristic ($SELF_CONT, @candidates!, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        @candidates := nqp::decont(@candidates);
        $target := nqp::decont($target);
#line 1052 src/Raku/ast/resolver.rakumod
        
        # only take a few suggestions
        my $to-add := 5;
        for @candidates[0] {
            $target.push($_) if $to-add > 0;
            $to-add := $to-add - 1;
        }
        $to-add := $to-add - 1 if +@candidates[0] > 0;
        for @candidates[1] {
            $target.push($_) if $to-add > 0;
            $to-add := $to-add - 1;
        }
        $to-add := $to-add - 2 if +@candidates[1] > 0;
        for @candidates[2] {
            $target.push($_) if $to-add > 0;
            $to-add := $to-add - 1;
        }
    
    });
    add-method(RakuAST::Resolver::Compile, 'suggest-lexicals', [RakuAST::Resolver::Compile, '', 0, 0, Str, '$name', 0, 0], anon sub suggest-lexicals ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 1071 src/Raku/ast/resolver.rakumod
        
        my @suggestions;
        my @candidates := [[], [], []];
        my &inner-evaluator := $SELF.make_levenshtein_evaluator($name, @candidates);
        my %seen;
        %seen{$name} := 1;
        sub evaluate($name, $value, $has_value) {
            # the descriptor identifies variables.
            return 1 if nqp::existskey(%seen, $name);
            %seen{$name} := 1;
            return &inner-evaluator($name);
        }

        # Walk active scopes, most nested first.
        my @scopes := nqp::getattr($SELF, RakuAST::Resolver::Compile, '$!scopes');
        my int $i := nqp::elems(@scopes);
        while $i-- {
            my $scope := @scopes[$i];
            for $scope.lexical-declarations {
                my $name := $_.lexical-name;
                next if nqp::existskey(%seen, $name);
                %seen{$name} := 1;
                &inner-evaluator($name);
            }
        }

        my $ctx := nqp::getattr($SELF, RakuAST::Resolver, '$!outer');
        while !nqp::isnull($ctx) {
            for $ctx -> $name {
                next if nqp::existskey(%seen, $name);
                %seen{$name} := 1;
                &inner-evaluator($name);
            }
            $ctx := nqp::ctxouter($ctx);
        }

        $SELF.levenshtein_candidate_heuristic(@candidates, @suggestions);
        return @suggestions;
    
    });
    compose(RakuAST::Resolver::Compile);
    parent(RakuAST::Resolver::Compile::Scope, RakuAST::Resolver);
    add-attribute(RakuAST::Resolver::Compile::Scope, RakuAST::LexicalScope, '$!scope');
    add-attribute(RakuAST::Resolver::Compile::Scope, int, '$!batch-mode');
    add-attribute(RakuAST::Resolver::Compile::Scope, Mu, '$!live-decl-map');
    add-method(RakuAST::Resolver::Compile::Scope, 'new', [RakuAST::Resolver::Compile::Scope, '', 0, 0, RakuAST::LexicalScope, '$scope', 1, 0, int, '$batch-mode', 1, 1], anon sub new ($SELF_CONT, :$scope!, :$batch-mode?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $batch-mode := nqp::decont($batch-mode);
#line 1128 src/Raku/ast/resolver.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Resolver::Compile::Scope, '$!scope', $scope);
        nqp::bindattr_i($obj, RakuAST::Resolver::Compile::Scope, '$!batch-mode', $batch-mode);
        unless $batch-mode {
            nqp::bindattr($obj, RakuAST::Resolver::Compile::Scope, '$!live-decl-map', {});
        }
        $obj
    
    });
    add-method(RakuAST::Resolver::Compile::Scope, 'batch-mode', [RakuAST::Resolver::Compile::Scope, '', 0, 0], anon sub batch-mode ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1138 src/Raku/ast/resolver.rakumod
        
        nqp::getattr_i($SELF, RakuAST::Resolver::Compile::Scope, '$!batch-mode') ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Resolver::Compile::Scope, 'find-lexical', [RakuAST::Resolver::Compile::Scope, '', 0, 0, Str, '$name', 0, 0], anon sub find-lexical ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 1142 src/Raku/ast/resolver.rakumod
        
        if nqp::getattr_i($SELF, RakuAST::Resolver::Compile::Scope, '$!batch-mode') {
            nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!scope').find-lexical($name) // Nil
        }
        else {
            nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!live-decl-map'){$name} // nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!scope').find-generated-lexical($name) // Nil
        }
    
    });
    add-method(RakuAST::Resolver::Compile::Scope, 'lexical-declarations', [RakuAST::Resolver::Compile::Scope, '', 0, 0], anon sub lexical-declarations ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1151 src/Raku/ast/resolver.rakumod
        
        my $declarations := nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!scope').lexical-declarations;
        my @declarations := nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!scope').IMPL-UNWRAP-LIST($declarations);
        unless nqp::getattr_i($SELF, RakuAST::Resolver::Compile::Scope, '$!batch-mode') {
            for nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!live-decl-map') {
                nqp::push(@declarations, $_.value);
            }
        }
        @declarations
    
    });
    add-method(RakuAST::Resolver::Compile::Scope, 'declare-lexical', [RakuAST::Resolver::Compile::Scope, '', 0, 0, RakuAST::Declaration, '$decl', 0, 0], anon sub declare-lexical ($SELF_CONT, $decl!) {
        my $SELF := nqp::decont($SELF_CONT);
        $decl := nqp::decont($decl);
#line 1162 src/Raku/ast/resolver.rakumod
        
        nqp::die('Should not be calling declare-lexical in batch mode')
          if nqp::getattr_i($SELF, RakuAST::Resolver::Compile::Scope, '$!batch-mode');
        my $name    := $decl.lexical-name;
        my $existed := nqp::existskey(nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!live-decl-map'), $name);
        nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!live-decl-map'){$decl.lexical-name} := $decl;
        $existed
    
    });
    add-method(RakuAST::Resolver::Compile::Scope, 'create-implicits', [RakuAST::Resolver::Compile::Scope, '', 0, 0], anon sub create-implicits ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1171 src/Raku/ast/resolver.rakumod
        
        nqp::die('Should not be calling create-implicits in batch mode')
          if nqp::getattr_i($SELF, RakuAST::Resolver::Compile::Scope, '$!batch-mode');
        if nqp::istype(nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!scope'), RakuAST::ImplicitDeclarations) {
            for nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!scope').IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!scope').get-implicit-declarations) -> $decl {
                if $decl.is-lexical {
                    nqp::getattr($SELF, RakuAST::Resolver::Compile::Scope, '$!live-decl-map'){$decl.lexical-name} := $decl;
                }
            }
        }
        Nil
    
    });
#line 1118 src/Raku/ast/resolver.rakumod
    add-method(RakuAST::Resolver::Compile::Scope, 'scope', [], anon sub scope ($self) { nqp::getattr(nqp::decont($self), RakuAST::Resolver::Compile::Scope, '$!scope') });
    compose(RakuAST::Resolver::Compile::Scope);
    parent(RakuAST::Origin, Any);
    add-attribute(RakuAST::Origin, int, '$!from');
    add-attribute(RakuAST::Origin, int, '$!to');
    add-attribute(RakuAST::Origin, RakuAST::Origin::Source, '$!source');
    add-attribute(RakuAST::Origin, Mu, '$!nestings');
    add-method(RakuAST::Origin, 'new', [RakuAST::Origin, '', 0, 0, int, '$from', 1, 1, int, '$to', 1, 1, Mu, '$nestings', 1, 1, RakuAST::Origin::Source, '$source', 1, 1], anon sub new ($SELF_CONT, :$from?, :$to?, :$nestings?, :$source?) {
        my $SELF := nqp::decont($SELF_CONT);
        $from := nqp::decont($from);
        $to := nqp::decont($to);
        $nestings := nqp::decont($nestings);
        $source := nqp::decont($source);
#line 14 src/Raku/ast/origins.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_i($obj, RakuAST::Origin, '$!from', $from);
        nqp::bindattr_i($obj, RakuAST::Origin, '$!to', $to);
        if nqp::isconcrete($nestings) {
            nqp::bindattr($obj, RakuAST::Origin, '$!nestings', $nestings);
        }
        if nqp::isconcrete($source) || nqp::isconcrete($*ORIGIN-SOURCE) {
            nqp::bindattr($obj, RakuAST::Origin, '$!source', ($source // $*ORIGIN-SOURCE))
        }
        $obj
    
    });
    add-method(RakuAST::Origin, 'set-nestings', [RakuAST::Origin, '', 0, 0, Mu, '$nestings', 0, 0], anon sub set-nestings ($SELF_CONT, $nestings!) {
        my $SELF := nqp::decont($SELF_CONT);
        $nestings := nqp::decont($nestings);
#line 27 src/Raku/ast/origins.rakumod
        
        nqp::bindattr($SELF, RakuAST::Origin, '$!nestings', $nestings);
    
    });
    add-method(RakuAST::Origin, 'is-key', [RakuAST::Origin, '', 0, 0], anon sub is-key ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 31 src/Raku/ast/origins.rakumod
         nqp::isconcrete(nqp::getattr($SELF, RakuAST::Origin, '$!nestings')) ?? (Bool.WHO)<True> !! (Bool.WHO)<False> 
    });
    add-method(RakuAST::Origin, 'as-match', [RakuAST::Origin, '', 0, 0], anon sub as-match ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 33 src/Raku/ast/origins.rakumod
         nqp::getattr($SELF, RakuAST::Origin, '$!source').match-from($SELF) 
    });
    add-method(RakuAST::Origin, 'Str', [RakuAST::Origin, '', 0, 0], anon sub Str ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 35 src/Raku/ast/origins.rakumod
        
        nqp::substr(nqp::getattr($SELF, RakuAST::Origin, '$!source').orig, nqp::getattr_i($SELF, RakuAST::Origin, '$!from'), nqp::getattr_i($SELF, RakuAST::Origin, '$!to') - nqp::getattr_i($SELF, RakuAST::Origin, '$!from'))
    
    });
#line 3 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin, 'to', [], anon sub to ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Origin, '$!to') });
#line 4 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin, 'source', [], anon sub source ($self) { nqp::getattr(nqp::decont($self), RakuAST::Origin, '$!source') });
#line 12 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin, 'nestings', [], anon sub nestings ($self) { nqp::getattr(nqp::decont($self), RakuAST::Origin, '$!nestings') });
#line 2 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin, 'from', [], anon sub from ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Origin, '$!from') });
    compose(RakuAST::Origin);
    parent(RakuAST::Origin::Match, Any);
    add-attribute(RakuAST::Origin::Match, str, '$!file');
    add-attribute(RakuAST::Origin::Match, str, '$!orig');
    add-attribute(RakuAST::Origin::Match, int, '$!line');
    add-attribute(RakuAST::Origin::Match, int, '$!orig-line');
    add-attribute(RakuAST::Origin::Match, int, '$!from');
    add-attribute(RakuAST::Origin::Match, int, '$!to');
    add-method(RakuAST::Origin::Match, 'new', [RakuAST::Origin::Match, '', 0, 0, str, '$file', 1, 1, str, '$orig', 1, 1, int, '$line', 1, 1, int, '$orig-line', 1, 1, int, '$from', 1, 1, int, '$to', 1, 1], anon sub new ($SELF_CONT, :$file?, :$orig?, :$line?, :$orig-line?, :$from?, :$to?) {
        my $SELF := nqp::decont($SELF_CONT);
        $file := nqp::decont($file);
        $orig := nqp::decont($orig);
        $line := nqp::decont($line);
        $orig-line := nqp::decont($orig-line);
        $from := nqp::decont($from);
        $to := nqp::decont($to);
#line 52 src/Raku/ast/origins.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Origin::Match, '$!file', $file);
        nqp::bindattr_s($obj, RakuAST::Origin::Match, '$!orig', $orig);
        nqp::bindattr_i($obj, RakuAST::Origin::Match, '$!line', $line);
        nqp::bindattr_i($obj, RakuAST::Origin::Match, '$!orig-line', $orig-line);
        nqp::bindattr_i($obj, RakuAST::Origin::Match, '$!from', $from);
        nqp::bindattr_i($obj, RakuAST::Origin::Match, '$!to', $to);
        $obj
    
    });
    add-method(RakuAST::Origin::Match, 'target', [RakuAST::Origin::Match, '', 0, 0], anon sub target ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 63 src/Raku/ast/origins.rakumod
         nqp::getattr_s($SELF, RakuAST::Origin::Match, '$!orig') 
    });
    add-method(RakuAST::Origin::Match, 'chars', [RakuAST::Origin::Match, '', 0, 0], anon sub chars ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 64 src/Raku/ast/origins.rakumod
         nqp::getattr_i($SELF, RakuAST::Origin::Match, '$!to') - nqp::getattr_i($SELF, RakuAST::Origin::Match, '$!from') 
    });
    add-method(RakuAST::Origin::Match, 'Str', [RakuAST::Origin::Match, '', 0, 0], anon sub Str ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 65 src/Raku/ast/origins.rakumod
         nqp::substr(nqp::getattr_s($SELF, RakuAST::Origin::Match, '$!orig'), nqp::getattr_i($SELF, RakuAST::Origin::Match, '$!from'), nqp::getattr_i($SELF, RakuAST::Origin::Match, '$!to') - nqp::getattr_i($SELF, RakuAST::Origin::Match, '$!from')) 
    });
#line 50 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin::Match, 'to', [], anon sub to ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Origin::Match, '$!to') });
#line 48 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin::Match, 'orig-line', [], anon sub orig-line ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Origin::Match, '$!orig-line') });
#line 46 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin::Match, 'orig', [], anon sub orig ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Origin::Match, '$!orig') });
#line 47 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin::Match, 'line', [], anon sub line ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Origin::Match, '$!line') });
#line 49 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin::Match, 'from', [], anon sub from ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Origin::Match, '$!from') });
#line 45 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin::Match, 'file', [], anon sub file ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Origin::Match, '$!file') });
    compose(RakuAST::Origin::Match);
    parent(RakuAST::Origin::Source, Any);
    add-attribute(RakuAST::Origin::Source, str, '$!orig');
    add-attribute(RakuAST::Origin::Source, Mu, '$!line-ends');
    add-attribute(RakuAST::Origin::Source, Mu, '$!line-file');
    add-method(RakuAST::Origin::Source, 'new', [RakuAST::Origin::Source, '', 0, 0, str, '$orig', 1, 1], anon sub new ($SELF_CONT, :$orig?) {
        my $SELF := nqp::decont($SELF_CONT);
        $orig := nqp::decont($orig);
#line 79 src/Raku/ast/origins.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Origin::Source, '$!orig', $orig);

        my $file := %*COMPILING<%?OPTIONS><source-name>;
        if !nqp::isconcrete($file) {
            if nqp::isnull($file := nqp::getlexdyn('$?FILES')) {
                $file := '<unknown file>';
            }
            elsif !nqp::eqat($file,'/',0) && !nqp::eqat($file,'-',0) && !nqp::eqat($file,':',1) {
                $file := nqp::cwd ~ '/' ~ $file;
            }
        }
        nqp::bindattr($obj, RakuAST::Origin::Source, '$!line-file', nqp::list(nqp::list(0, 0, $file)));
        $obj.SETUP-LINE-POSITIONS();
        $obj
    
    });
    add-method(RakuAST::Origin::Source, 'SETUP-LINE-POSITIONS', [RakuAST::Origin::Source, '', 0, 0], anon sub SETUP-LINE-POSITIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 97 src/Raku/ast/origins.rakumod
        
        nqp::bindattr($SELF, RakuAST::Origin::Source, '$!line-ends', []);
        my int $nl-pos := 0;
        my int $total := nqp::chars(nqp::getattr_s($SELF, RakuAST::Origin::Source, '$!orig'));
        while ($nl-pos := nqp::findcclass(nqp::const::CCLASS_NEWLINE, nqp::getattr_s($SELF, RakuAST::Origin::Source, '$!orig'), $nl-pos, $total)) < $total {
            my $ord := nqp::ord(nqp::getattr_s($SELF, RakuAST::Origin::Source, '$!orig'), $nl-pos);
            nqp::push(nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-ends'), ++$nl-pos);
            # Treat \r\n as a single logical newline. Note that NFG
            # implementations, we should check it really is a lone \r,
            # not the first bit of a \r\n grapheme.
            if $ord == 13 && nqp::eqat(nqp::getattr_s($SELF, RakuAST::Origin::Source, '$!orig'), "\r", $nl-pos - 1)
                && $nl-pos < $total && nqp::ord(nqp::getattr_s($SELF, RakuAST::Origin::Source, '$!orig'), $nl-pos) == 10
            {
                ++$nl-pos;
            }
        }
    
    });
    add-method(RakuAST::Origin::Source, 'register-line-directive', [RakuAST::Origin::Source, '', 0, 0, int, '$orig-line', 0, 0, int, '$directive-line', 0, 0, Any, '$filename', 0, 0], anon sub register-line-directive ($SELF_CONT, $orig-line!, $directive-line!, $filename!) {
        my $SELF := nqp::decont($SELF_CONT);
        $orig-line := nqp::decont($orig-line);
        $directive-line := nqp::decont($directive-line);
        $filename := nqp::decont($filename);
#line 115 src/Raku/ast/origins.rakumod
        
        my $registered := nqp::elems(nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file'));
        # Make sure we're not trying to re-register an existing directive. This can happen when grammar retracts
        # and the same line directive gets parsed repeatedly.
        if $registered == 1 || nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file')[$registered - 1][0] < $orig-line {
            if nqp::isconcrete($filename) {
                $filename := $filename.Str;
            }
            else {
                $filename := nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file')[0][2];
            }
            nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file').push([$orig-line, $directive-line - $orig-line - 1, $filename]);
        }
    
    });
    add-method(RakuAST::Origin::Source, 'original-file', [RakuAST::Origin::Source, '', 0, 0], anon sub original-file ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 130 src/Raku/ast/origins.rakumod
        
        nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file')[0][2]
    
    });
    add-method(RakuAST::Origin::Source, 'original-line-column', [RakuAST::Origin::Source, '', 0, 0, int, '$pos', 0, 0], anon sub original-line-column ($SELF_CONT, $pos!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
#line 134 src/Raku/ast/origins.rakumod
        
        my @line-ends := nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-ends');
        my int $lo := 0;
        my int $hi := nqp::elems(@line-ends);
        my int $line;
        while $lo < $hi {
            $line := nqp::div_i(($lo + $hi), 2);
            if @line-ends[$line] > $pos {
                $hi := $line;
            }
            else {
                $lo := $line + 1;
            }
        }
        my $column := $lo == 0 ?? $pos !! ($pos - @line-ends[$lo - 1]);
        [$lo + 1, $column + 1]
    
    });
    add-method(RakuAST::Origin::Source, 'original-line', [RakuAST::Origin::Source, '', 0, 0, int, '$pos', 0, 0], anon sub original-line ($SELF_CONT, $pos!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
#line 152 src/Raku/ast/origins.rakumod
        
        $SELF.original-line-column($pos)[0]
    
    });
    add-method(RakuAST::Origin::Source, 'location-of-pos', [RakuAST::Origin::Source, '', 0, 0, int, '$pos', 0, 0], anon sub location-of-pos ($SELF_CONT, $pos!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
#line 157 src/Raku/ast/origins.rakumod
        
        my @orig-line-col := $SELF.original-line-column($pos);
        my $orig-line := @orig-line-col[0];
        my $column := @orig-line-col[1];
        my int $hi := nqp::elems(nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file'));
        my int $lo := 0;
        my int $idx;
        while $lo < $hi {
            $idx := nqp::div_i($lo + $hi, 2);
            if nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file')[$idx][0] > $orig-line {
                $hi := $idx;
            }
            else {
                $lo := $idx + 1;
            }
        }
        --$lo;
        [ $orig-line + nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file')[$lo][1], $column, nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file')[$lo][2] ]
    
    });
    add-method(RakuAST::Origin::Source, 'file-of-pos', [RakuAST::Origin::Source, '', 0, 0, int, '$pos', 0, 0], anon sub file-of-pos ($SELF_CONT, $pos!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
#line 177 src/Raku/ast/origins.rakumod
        
        return nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file')[0][2] if nqp::elems(nqp::getattr($SELF, RakuAST::Origin::Source, '$!line-file')) == 1;
        $SELF.location-of-pos($pos)[2]
    
    });
    add-method(RakuAST::Origin::Source, 'line-of-pos', [RakuAST::Origin::Source, '', 0, 0, int, '$pos', 0, 0], anon sub line-of-pos ($SELF_CONT, $pos!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
#line 182 src/Raku/ast/origins.rakumod
        
        $SELF.location-of-pos($pos)[0]
    
    });
    add-method(RakuAST::Origin::Source, 'column-of-pos', [RakuAST::Origin::Source, '', 0, 0, int, '$pos', 0, 0], anon sub column-of-pos ($SELF_CONT, $pos!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
#line 186 src/Raku/ast/origins.rakumod
        
        $SELF.location-of-pos($pos)[1]
    
    });
    add-method(RakuAST::Origin::Source, 'match-from', [RakuAST::Origin::Source, '', 0, 0, Any, '$from-to', 0, 0], anon sub match-from ($SELF_CONT, $from-to!) {
        my $SELF := nqp::decont($SELF_CONT);
        $from-to := nqp::decont($from-to);
#line 191 src/Raku/ast/origins.rakumod
        
        my $from := $from-to.from();
        my @location := $SELF.location-of-pos($from);
        RakuAST::Origin::Match.new(
            :from($from), :to($from-to.to()), :orig(nqp::getattr_s($SELF, RakuAST::Origin::Source, '$!orig')),
            :line(@location[0]), :file(@location[2]),
            :orig-line($SELF.original-line($from)))
    
    });
#line 70 src/Raku/ast/origins.rakumod
    add-method(RakuAST::Origin::Source, 'orig', [], anon sub orig ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Origin::Source, '$!orig') });
    compose(RakuAST::Origin::Source);
    parent(RakuAST::Node, Any);
    add-attribute(RakuAST::Node, RakuAST::Origin, '$!origin');
    add-method(RakuAST::Node, 'type', [RakuAST::Node, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 6 src/Raku/ast/base.rakumod
         Mu 
    });
    add-method(RakuAST::Node, 'pure', [RakuAST::Node, '', 0, 0], anon sub pure ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 10 src/Raku/ast/base.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Node, 'visit-children', [RakuAST::Node, '', 0, 0, Any, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 14 src/Raku/ast/base.rakumod
        
        # Default is that we have no children to visit.
        Nil
    
    });
    add-method(RakuAST::Node, 'apply-sink', [RakuAST::Node, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub apply-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 20 src/Raku/ast/base.rakumod
        
        # If we are sunk and this is a sinkable node, apply that.
        if $is-sunk && nqp::istype($SELF, RakuAST::Sinkable) {
            $SELF.mark-sunk();
        }

        # If this node knows how to propagate sinks itself, ask it to do so.
        if nqp::istype($SELF, RakuAST::SinkPropagator) {
            $SELF.propagate-sink($is-sunk);
        }

        # Otherwise, we assume it's a wanted child, and just walk its children,
        # unless it is a sink boundary.
        elsif !nqp::istype($SELF, RakuAST::SinkBoundary) {
            $SELF.visit-children: -> $child {
                $child.apply-sink((Bool.WHO)<False>);
            }
        }
    
    });
    add-method(RakuAST::Node, 'needs-sink-call', [RakuAST::Node, '', 0, 0], anon sub needs-sink-call ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 42 src/Raku/ast/base.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Node, 'can-be-bound-to', [RakuAST::Node, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 46 src/Raku/ast/base.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Node, 'resolve-all', [RakuAST::Node, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub resolve-all ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 50 src/Raku/ast/base.rakumod
        
        $SELF.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
    
    });
    add-method(RakuAST::Node, 'set-origin', [RakuAST::Node, '', 0, 0, RakuAST::Origin, '$origin', 0, 0], anon sub set-origin ($SELF_CONT, $origin!) {
        my $SELF := nqp::decont($SELF_CONT);
        $origin := nqp::decont($origin);
#line 54 src/Raku/ast/base.rakumod
        
        nqp::bindattr($SELF, RakuAST::Node, '$!origin', $origin);
    
    });
    add-method(RakuAST::Node, 'locate-node', [RakuAST::Node, '', 0, 0, int, '$pos', 0, 0, int, '$to', 0, 1, Any, '$key', 1, 1], anon sub locate-node ($SELF_CONT, $pos!, $to?, :$key?) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
        $to := nqp::decont($to);
        $key := nqp::decont($key);
#line 59 src/Raku/ast/base.rakumod
        
        return Nil unless nqp::isconcrete(nqp::getattr($SELF, RakuAST::Node, '$!origin'))
                            && $pos >= nqp::getattr($SELF, RakuAST::Node, '$!origin').from && $pos < nqp::getattr($SELF, RakuAST::Node, '$!origin').to
                            && (!nqp::isconcrete($to) || $to <= nqp::getattr($SELF, RakuAST::Node, '$!origin').to);

        if $key && !nqp::getattr($SELF, RakuAST::Node, '$!origin').is-key {
            nqp::die("Only a key node can search for key nodes")
        }
        if $key {
            my @nestings := nqp::getattr($SELF, RakuAST::Node, '$!origin').nestings;
            for @nestings {
                my $cand := $_.locate-node($pos, $to, :key);
                return $cand if nqp::isconcrete($cand);
            }
        }
        else {
            $SELF.visit-children(-> $child {
                my $cand := $child.locate-node($pos, $to);
                return $cand if nqp::isconcrete($cand);
            });
        }
        # If no nested key node gave a match then we are the one.
        $SELF
    
    });
    add-method(RakuAST::Node, 'IMPL-CHECK', [RakuAST::Node, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Bool, '$resolve-only', 0, 0], anon sub IMPL-CHECK ($SELF_CONT, $resolver!, $context!, $resolve-only!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $resolve-only := nqp::decont($resolve-only);
#line 85 src/Raku/ast/base.rakumod
        
        # Perform resolutions.
        if nqp::istype($SELF, RakuAST::Lookup) && !$SELF.is-resolved {
            $SELF.resolve-with($resolver);
            if !$resolve-only && !$SELF.is-resolved && $SELF.needs-resolution {
                $resolver.add-node-unresolved-after-check-time($SELF);
            }
        }
        if nqp::istype($SELF, RakuAST::ImplicitLookups) {
            $SELF.resolve-implicit-lookups-with($resolver);
        }
        if nqp::istype($SELF, RakuAST::Attaching) {
            $SELF.attach($resolver);
        }
        if nqp::istype($SELF, RakuAST::ImplicitBlockSemanticsProvider) {
            $SELF.apply-implicit-block-semantics();
        }

        # Apply any pre-children BEGIN-time effects that were not yet
        # performed (and figure out if we have to do the later).
        my int $needs-begin-after := nqp::istype($SELF, RakuAST::BeginTime) && $SELF.is-begin-performed-after-children();
        if nqp::istype($SELF, RakuAST::BeginTime) && $SELF.is-begin-performed-before-children() {
            $SELF.ensure-begin-performed($resolver, $context, :phase(1));
        }

        # Visit children. But don't run CHECK yet if this will be followed by more BEGIN handling
        my int $is-scope := nqp::istype($SELF, RakuAST::LexicalScope);
        my int $is-package := nqp::istype($SELF, RakuAST::Package);
        $resolver.push-scope($SELF) if $is-scope;
        $resolver.push-package($SELF) if $is-package;
        $SELF.visit-children(-> $child { $child.IMPL-CHECK($resolver, $context, $resolve-only || $needs-begin-after) });
        $resolver.pop-scope() if $is-scope;
        $resolver.pop-package() if $is-package;

        # Perform any after-children BEGIN-time effects.
        if $needs-begin-after {
            $SELF.ensure-begin-performed($resolver, $context, :phase(2));
        }

        # Unless in resolve-only mode, do other check-time activities.
        unless $resolve-only {
            if $needs-begin-after {
                # Run children's CHECK processing. Couldn't do it earlier as
                # that would have interfered with our BEGIN handling.
                $resolver.push-scope($SELF) if $is-scope;
                $resolver.push-package($SELF) if $is-package;
                $SELF.visit-children(-> $child { $child.IMPL-CHECK($resolver, $context, $resolve-only) });
                $resolver.pop-scope() if $is-scope;
                $resolver.pop-package() if $is-package;
            }

            if nqp::istype($SELF, RakuAST::SinkBoundary) && !$SELF.sink-calculated {
                $SELF.calculate-sink();
            }
            if nqp::istype($SELF, RakuAST::CheckTime) {
                $SELF.clear-check-time-problems();
                $SELF.PERFORM-CHECK($resolver, $context);
                if $SELF.has-check-time-problems {
                    $resolver.add-node-with-check-time-problems($SELF);
                }
            }
        }

        Nil
    
    });
    add-method(RakuAST::Node, 'find-nodes', [RakuAST::Node, '', 0, 0, Mu, '$type', 0, 0, Code, '$condition', 1, 1, Mu, '$stopper', 1, 1], anon sub find-nodes ($SELF_CONT, $type!, :$condition?, :$stopper?) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
        $condition := nqp::decont($condition);
        $stopper := nqp::decont($stopper);
#line 156 src/Raku/ast/base.rakumod
        
        # Walk the tree searching for matching nodes.
        my int $have-stopper := !nqp::eqaddr($stopper, Mu);
        my @visit-queue := [$SELF];
        my @result;
        my $collector := sub collector($node) {
            if nqp::istype($node, $type) {
                unless $condition && !$condition($node) {
                    nqp::push(@result, $node);
                }
            }
            unless $have-stopper && nqp::istype($node, $stopper) {
                nqp::push(@visit-queue, $node);
            }
        }
        while @visit-queue {
            nqp::shift(@visit-queue).visit-children($collector);
        }
        $SELF.IMPL-WRAP-LIST(@result)
    
    });
    add-method(RakuAST::Node, 'find-nodes-exclusive', [RakuAST::Node, '', 0, 0, Mu, '$type', 0, 0, Code, '$condition', 1, 1, Code, '$stopper', 1, 1], anon sub find-nodes-exclusive ($SELF_CONT, $type!, :$condition?, :$stopper?) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
        $condition := nqp::decont($condition);
        $stopper := nqp::decont($stopper);
#line 184 src/Raku/ast/base.rakumod
        
        # Walk the tree searching for matching nodes.;
        my @visit-queue := [$SELF];
        my @result;
        my $collector := sub collector($node) {
            if nqp::isconcrete($stopper) {
                my $do-stop := $stopper($node);
                if nqp::istype($node, $type) && !$do-stop {
                    unless $condition && !$condition($node) {
                        nqp::push(@result, $node);
                    }
                }
                unless $do-stop {
                    nqp::push(@visit-queue, $node)
                }
            } else {
                if nqp::istype($node, $type) {
                    unless $condition && !$condition($node) {
                        nqp::push(@result, $node);
                    }
                }
                nqp::push(@visit-queue, $node);
            }
        }
        while @visit-queue {
            nqp::shift(@visit-queue).visit-children($collector);
        }
        $SELF.IMPL-WRAP-LIST(@result)
    
    });
    add-method(RakuAST::Node, 'visit', [RakuAST::Node, '', 0, 0, Code, '$callback', 0, 0, Bool, '$strict', 1, 1], anon sub visit ($SELF_CONT, $callback!, :$strict?) {
        my $SELF := nqp::decont($SELF_CONT);
        $callback := nqp::decont($callback);
        $strict := nqp::decont($strict);
#line 218 src/Raku/ast/base.rakumod
        
        my @visit-queue;
        if $strict || $callback($SELF) {
            @visit-queue[0] := $SELF;
        }
        my $visitor := -> $node {
            if $callback($node) {
                nqp::push(@visit-queue, $node);
            }
        }
        while @visit-queue {
            nqp::shift(@visit-queue).visit-children($visitor);
        }
        Nil
    
    });
    add-method(RakuAST::Node, 'visit-dfs', [RakuAST::Node, '', 0, 0, Code, '$callback', 0, 0, Bool, '$strict', 1, 1], anon sub visit-dfs ($SELF_CONT, $callback!, :$strict?) {
        my $SELF := nqp::decont($SELF_CONT);
        $callback := nqp::decont($callback);
        $strict := nqp::decont($strict);
#line 234 src/Raku/ast/base.rakumod
        
        my $visitor;
        $visitor := -> $node {
            if $callback($node) {
                $node.visit-children($visitor);
            }
        }
        $SELF.visit-children($visitor) if $strict || $callback($SELF);
        Nil
    
    });
    add-method(RakuAST::Node, 'IMPL-CAN-INTERPRET', [RakuAST::Node, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 245 src/Raku/ast/base.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Node, 'IMPL-INTERPRET', [RakuAST::Node, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 247 src/Raku/ast/base.rakumod
        
        nqp::die('Missing IMPL-INTERPRET implementation on ' ~ $SELF.HOW.name($SELF))
    
    });
    add-method(RakuAST::Node, 'IMPL-WRAP-LIST', [RakuAST::Node, '', 0, 0, Mu, '$vm-array', 0, 0], anon sub IMPL-WRAP-LIST ($SELF_CONT, $vm-array!) {
        my $SELF := nqp::decont($SELF_CONT);
        $vm-array := nqp::decont($vm-array);
#line 251 src/Raku/ast/base.rakumod
        
        if nqp::istype($vm-array, List) {
            # It already is a list
            $vm-array
        }
        else {
            my $result := nqp::create(List);
            nqp::bindattr($result, List, '$!reified', $vm-array);
            $result
        }
    
    });
    add-method(RakuAST::Node, 'IMPL-UNWRAP-LIST', [RakuAST::Node, '', 0, 0, Mu, '$list', 0, 0], anon sub IMPL-UNWRAP-LIST ($SELF_CONT, $list!) {
        my $SELF := nqp::decont($SELF_CONT);
        $list := nqp::decont($list);
#line 263 src/Raku/ast/base.rakumod
        
        if nqp::islist($list) {
            # Wasn't wrapped anyway
            $list
        }
        elsif nqp::istype($list, List) {
            my $reified := nqp::getattr($list, List, '$!reified');
            nqp::isconcrete($reified)
                ?? $reified
                !! $list.FLATTENABLE_LIST
        }
        else {
            nqp::list($list)
        }
    
    });
    add-method(RakuAST::Node, 'IMPL-WRAP-MAP', [RakuAST::Node, '', 0, 0, Mu, '$vm-hash', 0, 0], anon sub IMPL-WRAP-MAP ($SELF_CONT, $vm-hash!) {
        my $SELF := nqp::decont($SELF_CONT);
        $vm-hash := nqp::decont($vm-hash);
#line 279 src/Raku/ast/base.rakumod
        
        if nqp::istype($vm-hash, Map) {
            # It already is a map
            $vm-hash
        }
        else {
            my $result := nqp::create(Map);
            nqp::bindattr($result, Map, '$!storage', $vm-hash);
            $result
        }
    
    });
    add-method(RakuAST::Node, 'IMPL-UNWRAP-MAP', [RakuAST::Node, '', 0, 0, Mu, '$map', 0, 0], anon sub IMPL-UNWRAP-MAP ($SELF_CONT, $map!) {
        my $SELF := nqp::decont($SELF_CONT);
        $map := nqp::decont($map);
#line 291 src/Raku/ast/base.rakumod
        
        if nqp::ishash($map) {
            # Wasn't wrapped anyway
            $map
        }
        elsif nqp::istype($map, Map) {
            my $storage := nqp::getattr($map, Map, '$!storage');
            nqp::isconcrete($storage)
                ?? $storage
                !! $map.FLATTENABLE_HASH
        }
        else {
            nqp::die("Cannot hashify " ~ $map.HOW.name($map));
        }
    
    });
    add-method(RakuAST::Node, 'dump-markers', [RakuAST::Node, '', 0, 0], anon sub dump-markers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 307 src/Raku/ast/base.rakumod
        
        my @markers;
        @markers.push('⚓') if nqp::istype($SELF, RakuAST::Sinkable) && $SELF.sunk;
        @markers.push('▪') if nqp::istype($SELF, RakuAST::BlockStatementSensitive) && $SELF.is-block-statement;
        if nqp::isconcrete(nqp::getattr($SELF, RakuAST::Node, '$!origin')) {
            @markers.push('𝄞') if nqp::getattr($SELF, RakuAST::Node, '$!origin').is-key();
        }
        nqp::join('', @markers)
    
    });
    add-method(RakuAST::Node, 'dump-extras', [RakuAST::Node, '', 0, 0, int, '$indent', 0, 0], anon sub dump-extras ($SELF_CONT, $indent!) {
        my $SELF := nqp::decont($SELF_CONT);
        $indent := nqp::decont($indent);
#line 320 src/Raku/ast/base.rakumod
         '' 
    });
    add-method(RakuAST::Node, 'dump-children', [RakuAST::Node, '', 0, 0, int, '$indent', 0, 0], anon sub dump-children ($SELF_CONT, $indent!) {
        my $SELF := nqp::decont($SELF_CONT);
        $indent := nqp::decont($indent);
#line 322 src/Raku/ast/base.rakumod
        
        my @chunks;
        $SELF.visit-children(-> $child {
            @chunks.push($child.dump($indent));
        });
        nqp::join('', @chunks)
    
    });
    add-method(RakuAST::Node, 'dump-origin', [RakuAST::Node, '', 0, 0], anon sub dump-origin ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 330 src/Raku/ast/base.rakumod
        
        my @chunks;
        if nqp::isconcrete(nqp::getattr($SELF, RakuAST::Node, '$!origin')) {
            my $from := nqp::getattr($SELF, RakuAST::Node, '$!origin').from;
            my $orig-source := nqp::getattr($SELF, RakuAST::Node, '$!origin').source;
            if nqp::getattr($SELF, RakuAST::Node, '$!origin').is-key {
                my @location := $orig-source.location-of-pos($from);
                @chunks.push(@location[2] ~ ':' ~ @location[0]);
            }

            my $src := nqp::escape(nqp::substr($orig-source.orig, $from, nqp::getattr($SELF, RakuAST::Node, '$!origin').to - $from));
            if nqp::chars($src) > 50 {
                $src := nqp::substr($src, 0, 49) ~ '…';
            }
            @chunks.push(' ⎡');
            @chunks.push($src ~ '⎤');
        }
        nqp::join('', @chunks)
    
    });
    add-method(RakuAST::Node, 'dump', [RakuAST::Node, '', 0, 0, int, '$indent', 0, 1], anon sub dump ($SELF_CONT, $indent?) {
        my $SELF := nqp::decont($SELF_CONT);
        $indent := nqp::decont($indent);
#line 350 src/Raku/ast/base.rakumod
        
        my @chunks := [
            nqp::x(' ', $indent),
            nqp::substr($SELF.HOW.name($SELF), nqp::chars('RakuAST::'))
        ];

        if (my $markers := $SELF.dump-markers()) {
            @chunks.push(' ' ~ $markers);
        }

        if (my $origin := $SELF.dump-origin()) {
            @chunks.push(' ' ~ $origin);
        }

        @chunks.push("\n");
        if (my $extras := $SELF.dump-extras($indent + 2)) {
            @chunks.push($extras);
        }
        if (my $children := $SELF.dump-children($indent + 2)) {
            @chunks.push($children);
        }
        nqp::join('', @chunks)
    
    });
    add-method(RakuAST::Node, 'mixin-role', [RakuAST::Node, '', 0, 0, Any, '$base', 0, 0, Any, '$role', 0, 0], anon sub mixin-role ($SELF_CONT, $base!, $role!) {
        my $SELF := nqp::decont($SELF_CONT);
        $base := nqp::decont($base);
        $role := nqp::decont($role);
#line 374 src/Raku/ast/base.rakumod
        
        my $class := nqp::clone($base);
        $class.HOW.mixin($class, $role).BUILD_LEAST_DERIVED({})
    
    });
    add-method(RakuAST::Node, 'DEPARSE', [RakuAST::Node, '', 0, 0, Any, '@roles', 0, 0], anon sub DEPARSE ($SELF_CONT, *@roles) {
        my $SELF := nqp::decont($SELF_CONT);
        @roles := nqp::decont(@roles);
#line 381 src/Raku/ast/base.rakumod
        
        my $class := my $core := nqp::gethllsym('Raku','DEPARSE');
        for @roles {
            if $_.HOW.name($_) eq 'Str' {  # XXX better way to detect HLL Str?
                $class := $SELF.mixin-role($class, $core.slang($_));
            }
            elsif nqp::can($_.HOW,'pun') {  # it's a role
                $class := $SELF.mixin-role($class, $_);
            }
            else {
                $class := $_;
            }
        }

        $class.deparse($SELF)
    
    });
    add-method(RakuAST::Node, 'IMPL-SORTED-KEYS', [RakuAST::Node, '', 0, 0, Mu, '$hash', 0, 0], anon sub IMPL-SORTED-KEYS ($SELF_CONT, $hash!) {
        my $SELF := nqp::decont($SELF_CONT);
        $hash := nqp::decont($hash);
#line 398 src/Raku/ast/base.rakumod
        
        # Due to these classes being pieced together at compile time we can't
        # reach the sorted_hash sub in the NQP setting, so it's copied here.
        my @keys;
        for $hash {
            nqp::push(@keys, $_.key);
        }

        my int $count := +@keys;
        my int $start := $count / 2 - 1;
        while $start >= 0 {
            $SELF.IMPL-SIFT-DOWN(@keys, $start, $count - 1);
            $start := $start - 1;
        }

        my int $end := +@keys - 1;
        while $end > 0 {
            my str $swap := @keys[$end];
            @keys[$end] := @keys[0];
            @keys[0] := $swap;
            $end := $end - 1;
            $SELF.IMPL-SIFT-DOWN(@keys, 0, $end);
        }

        return @keys;
    
    });
    add-method(RakuAST::Node, 'IMPL-SIFT-DOWN', [RakuAST::Node, '', 0, 0, Mu, '$a', 0, 0, int, '$start', 0, 0, int, '$end', 0, 0], anon sub IMPL-SIFT-DOWN ($SELF_CONT, $a!, $start!, $end!) {
        my $SELF := nqp::decont($SELF_CONT);
        $a := nqp::decont($a);
        $start := nqp::decont($start);
        $end := nqp::decont($end);
#line 425 src/Raku/ast/base.rakumod
        
        my @a := $a;
        my int $root := $start;

        while 2*$root + 1 <= $end {
            my $child := 2*$root + 1;
            my $swap := $root;

            if @a[$swap] gt @a[$child] {
                $swap := $child;
            }
            if $child + 1 <= $end && @a[$swap] ge @a[$child + 1] {
                $swap := $child + 1;
            }
            if $swap == $root {
                return;
            } else {
                my str $tmp := @a[$root];
                @a[$root] := @a[$swap];
                @a[$swap] := $tmp;
                $root := $swap;
            }
        }
    
    });
    add-method(RakuAST::Node, 'IMPL-TEMPORARIZE-TOPIC', [RakuAST::Node, '', 0, 0, Mu, '$new-topic-qast', 0, 0, Mu, '$with-topic-qast', 0, 0], anon sub IMPL-TEMPORARIZE-TOPIC ($SELF_CONT, $new-topic-qast!, $with-topic-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-topic-qast := nqp::decont($new-topic-qast);
        $with-topic-qast := nqp::decont($with-topic-qast);
#line 450 src/Raku/ast/base.rakumod
        
        my $temporary := QAST::Node.unique('save_topic');
        QAST::Stmt.new(
            :resultchild(2),
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name($temporary), :scope('local'), :decl('var') ),
                QAST::Var.new( :name('$_'), :scope('lexical') )
            ),
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name('$_'), :scope('lexical') ),
                $new-topic-qast
            ),
            $with-topic-qast,
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name('$_'), :scope('lexical') ),
                QAST::Var.new( :name($temporary), :scope('local') )
            )
        )
    
    });
    add-method(RakuAST::Node, 'IMPL-SET-NODE', [RakuAST::Node, '', 0, 0, Mu, '$qast', 0, 0, Any, '$key', 1, 1], anon sub IMPL-SET-NODE ($SELF_CONT, $qast!, :$key?) {
        my $SELF := nqp::decont($SELF_CONT);
        $qast := nqp::decont($qast);
        $key := nqp::decont($key);
#line 478 src/Raku/ast/base.rakumod
        
        my $orig := $SELF.origin;
        if nqp::isconcrete($orig) {
            if $key && !$orig.is-key {
                my $comp-unit := $*CU;
                if nqp::isconcrete($comp-unit) {
                    my $key-node := $comp-unit.locate-node($orig.from, $orig.to, :key);
                    $orig := $key-node.origin if nqp::isconcrete($key-node);
                }
            }
            $qast.node($orig.as-match);
        }
        $qast
    
    });
#line 3 src/Raku/ast/base.rakumod
    add-method(RakuAST::Node, 'origin', [], anon sub origin ($self) { nqp::getattr(nqp::decont($self), RakuAST::Node, '$!origin') });
    compose(RakuAST::Node);
    parent(RakuAST::CompileTimeValue, RakuAST::Node);
    add-method(RakuAST::CompileTimeValue, 'compile-time-value', [RakuAST::CompileTimeValue, '', 0, 0], anon sub compile-time-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 498 src/Raku/ast/base.rakumod
        
        nqp::die('compile-time-value not implemented for ' ~ $SELF.HOW.name($SELF))
    
    });
    compose(RakuAST::CompileTimeValue);
    parent(RakuAST::CheckTime, RakuAST::Node);
    add-attribute(RakuAST::CheckTime, Mu, '$!sorries');
    add-attribute(RakuAST::CheckTime, Mu, '$!worries');
    add-method(RakuAST::CheckTime, 'clear-check-time-problems', [RakuAST::CheckTime, '', 0, 0], anon sub clear-check-time-problems ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 12 src/Raku/ast/checktime.rakumod
        
        nqp::bindattr($SELF, RakuAST::CheckTime, '$!sorries', Mu);
        nqp::bindattr($SELF, RakuAST::CheckTime, '$!worries', Mu);
        Nil
    
    });
    add-method(RakuAST::CheckTime, 'has-check-time-problems', [RakuAST::CheckTime, '', 0, 0], anon sub has-check-time-problems ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 20 src/Raku/ast/checktime.rakumod
        
        nqp::getattr($SELF, RakuAST::CheckTime, '$!sorries') || nqp::getattr($SELF, RakuAST::CheckTime, '$!worries') ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::CheckTime, 'sorries', [RakuAST::CheckTime, '', 0, 0], anon sub sorries ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 25 src/Raku/ast/checktime.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::CheckTime, '$!sorries') // [])
    
    });
    add-method(RakuAST::CheckTime, 'worries', [RakuAST::CheckTime, '', 0, 0], anon sub worries ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 30 src/Raku/ast/checktime.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::CheckTime, '$!worries') // [])
    
    });
    add-method(RakuAST::CheckTime, 'add-sorry', [RakuAST::CheckTime, '', 0, 0, Any, '$exception', 0, 0], anon sub add-sorry ($SELF_CONT, $exception!) {
        my $SELF := nqp::decont($SELF_CONT);
        $exception := nqp::decont($exception);
#line 36 src/Raku/ast/checktime.rakumod
        
        nqp::push(
          nqp::getattr($SELF, RakuAST::CheckTime, '$!sorries') // nqp::bindattr($SELF,RakuAST::CheckTime,'$!sorries',[]),
          $exception
        );
        Nil
    
    });
    add-method(RakuAST::CheckTime, 'add-worry', [RakuAST::CheckTime, '', 0, 0, Any, '$exception', 0, 0], anon sub add-worry ($SELF_CONT, $exception!) {
        my $SELF := nqp::decont($SELF_CONT);
        $exception := nqp::decont($exception);
#line 46 src/Raku/ast/checktime.rakumod
        
        nqp::push(
          nqp::getattr($SELF, RakuAST::CheckTime, '$!worries') // nqp::bindattr($SELF,RakuAST::CheckTime,'$!worries',[]),
          $exception
        );
        Nil
    
    });
    add-method(RakuAST::CheckTime, 'PERFORM-CHECK', [RakuAST::CheckTime, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 56 src/Raku/ast/checktime.rakumod
        
        nqp::die('Missing PERFORM-CHECK implementation for ' ~ $SELF.HOW.name($SELF));
    
    });
    compose(RakuAST::CheckTime);
    parent(RakuAST::SinkBoundary, RakuAST::Node);
    add-attribute(RakuAST::SinkBoundary, int, '$!sink-calculated');
    add-method(RakuAST::SinkBoundary, 'calculate-sink', [RakuAST::SinkBoundary, '', 0, 0], anon sub calculate-sink ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 11 src/Raku/ast/sink.rakumod
        
        unless nqp::getattr_i($SELF, RakuAST::SinkBoundary, '$!sink-calculated') {
            $SELF.get-boundary-sink-propagator().propagate-sink($SELF.is-boundary-sunk(), :has-block-parent);
            nqp::bindattr_i($SELF, RakuAST::SinkBoundary, '$!sink-calculated', 1);
        }
        Nil
    
    });
    add-method(RakuAST::SinkBoundary, 'sink-calculated', [RakuAST::SinkBoundary, '', 0, 0], anon sub sink-calculated ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 20 src/Raku/ast/sink.rakumod
        
        nqp::getattr_i($SELF, RakuAST::SinkBoundary, '$!sink-calculated') ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::SinkBoundary, 'is-boundary-sunk', [RakuAST::SinkBoundary, '', 0, 0], anon sub is-boundary-sunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 29 src/Raku/ast/sink.rakumod
        
        nqp::die('Missing is-boundary-sunk implementation')
    
    });
    add-method(RakuAST::SinkBoundary, 'get-boundary-sink-propagator', [RakuAST::SinkBoundary, '', 0, 0], anon sub get-boundary-sink-propagator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 34 src/Raku/ast/sink.rakumod
        
        nqp::die('Missing get-boundary-sink-propagator implementation')
    
    });
    compose(RakuAST::SinkBoundary);
    parent(RakuAST::SinkPropagator, RakuAST::Node);
    add-method(RakuAST::SinkPropagator, 'propagate-sink', [RakuAST::SinkPropagator, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 45 src/Raku/ast/sink.rakumod
        
        nqp::die('Missing propagate-sink');
    
    });
    compose(RakuAST::SinkPropagator);
    parent(RakuAST::Sinkable, RakuAST::Node);
    add-attribute(RakuAST::Sinkable, int, '$!sunk');
    add-method(RakuAST::Sinkable, 'mark-sunk', [RakuAST::Sinkable, '', 0, 0], anon sub mark-sunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 57 src/Raku/ast/sink.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::Sinkable, '$!sunk', 1);
    
    });
    add-method(RakuAST::Sinkable, 'sunk', [RakuAST::Sinkable, '', 0, 0], anon sub sunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 61 src/Raku/ast/sink.rakumod
         nqp::getattr_i($SELF, RakuAST::Sinkable, '$!sunk') ?? (Bool.WHO)<True> !! (Bool.WHO)<False> 
    });
    add-method(RakuAST::Sinkable, 'needs-sink-call', [RakuAST::Sinkable, '', 0, 0], anon sub needs-sink-call ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 65 src/Raku/ast/sink.rakumod
         (Bool.WHO)<False> 
    });
    compose(RakuAST::Sinkable);
    parent(RakuAST::BlockStatementSensitive, RakuAST::Node);
    add-attribute(RakuAST::BlockStatementSensitive, int, '$!block-statement');
    add-method(RakuAST::BlockStatementSensitive, 'mark-block-statement', [RakuAST::BlockStatementSensitive, '', 0, 0], anon sub mark-block-statement ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 76 src/Raku/ast/sink.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::BlockStatementSensitive, '$!block-statement', 1);
    
    });
    add-method(RakuAST::BlockStatementSensitive, 'is-block-statement', [RakuAST::BlockStatementSensitive, '', 0, 0], anon sub is-block-statement ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 80 src/Raku/ast/sink.rakumod
         nqp::getattr_i($SELF, RakuAST::BlockStatementSensitive, '$!block-statement') ?? (Bool.WHO)<True> !! (Bool.WHO)<False> 
    });
    compose(RakuAST::BlockStatementSensitive);
    parent(RakuAST::LexicalScope, RakuAST::CheckTime);
    parent(RakuAST::LexicalScope, RakuAST::Node);
    add-attribute(RakuAST::LexicalScope, List, '$!declarations-cache');
    add-attribute(RakuAST::LexicalScope, Mu, '$!lexical-lookup-hash');
    add-attribute(RakuAST::LexicalScope, List, '$!variables-cache');
    add-attribute(RakuAST::LexicalScope, Mu, '$!generated-lexical-declarations');
    add-attribute(RakuAST::LexicalScope, Mu, '$!generated-lexical-lookup-hash');
    add-attribute(RakuAST::LexicalScope, int, '$!need-succeed-handler');
    add-attribute(RakuAST::LexicalScope, Mu, '$!catch-handlers');
    add-attribute(RakuAST::LexicalScope, Mu, '$!control-handlers');
    add-method(RakuAST::LexicalScope, 'IMPL-QAST-DECLS', [RakuAST::LexicalScope, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECLS ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 22 src/Raku/ast/scoping.rakumod
        
        my $stmts := QAST::Stmts.new();

        # Visit code objects that need to make a declaration entry. We don't
        # visit any code objects immediately under an ImmediateBlockUser (but
        # should visit their other nodes).
        my @code-todo := [$SELF];
        while @code-todo {
            my $visit := @code-todo.shift;
            $visit.visit-children: -> $node {
                if nqp::istype($node, RakuAST::Code) {
                    unless nqp::istype($visit, RakuAST::IMPL::ImmediateBlockUser) &&
                            $visit.IMPL-IMMEDIATELY-USES($node) {
                        $stmts.push($node.IMPL-QAST-DECL-CODE($context));
                    }
                }
                elsif nqp::istype($node, RakuAST::Expression) {
                    $node.IMPL-QAST-ADD-THUNK-DECL-CODE($context, $stmts);
                }
                unless nqp::istype($node, RakuAST::LexicalScope) {
                    @code-todo.push($node);
                }
            }
        }

        # Visit declarations and produce declaration QAST.
        for $SELF.IMPL-UNWRAP-LIST($SELF.generated-lexical-declarations()) {
            $stmts.unshift($_.IMPL-QAST-DECL($context)) unless $_ =:= $SELF;
        }
        for $SELF.IMPL-UNWRAP-LIST($SELF.ast-lexical-declarations()) {
            $stmts.unshift($_.IMPL-QAST-DECL($context)) unless $_ =:= $SELF;
        }

        # If there's handler block declarations, add those.
        if nqp::getattr($SELF, RakuAST::LexicalScope, '$!catch-handlers') {
            $stmts.push(QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :decl('var'), :name('__CATCH_HANDLER'), :scope('lexical') ),
                nqp::getattr($SELF, RakuAST::LexicalScope, '$!catch-handlers')[0].body.IMPL-CLOSURE-QAST($context)
            ));
        }
        if nqp::getattr($SELF, RakuAST::LexicalScope, '$!control-handlers') {
            $stmts.push(QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :decl('var'), :name('__CONTROL_HANDLER'), :scope('lexical') ),
                nqp::getattr($SELF, RakuAST::LexicalScope, '$!control-handlers')[0].body.IMPL-CLOSURE-QAST($context)
            ));
        }

        $stmts
    
    });
    add-method(RakuAST::LexicalScope, 'ast-lexical-declarations', [RakuAST::LexicalScope, '', 0, 0], anon sub ast-lexical-declarations ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 78 src/Raku/ast/scoping.rakumod
        
        unless nqp::isconcrete(nqp::getattr($SELF, RakuAST::LexicalScope, '$!declarations-cache')) {
            my @declarations;
            my @variables;
            $SELF.visit-dfs: -> $node {
                if nqp::istype($node, RakuAST::Declaration) && $node.is-simple-lexical-declaration {
                    nqp::push(@declarations, $node);
                    nqp::push(@variables, $node) unless nqp::istype($node, RakuAST::Routine);
                }
                elsif nqp::istype($node, RakuAST::Var::Lexical) || nqp::istype($node, RakuAST::Var::Dynamic) {
                    nqp::push(@variables, $node);
                }
                if $node =:= $SELF || !nqp::istype($node, RakuAST::LexicalScope) {
                    if nqp::istype($node, RakuAST::ImplicitDeclarations) {
                        for $SELF.IMPL-UNWRAP-LIST($node.get-implicit-declarations()) -> $decl {
                            if $decl.is-simple-lexical-declaration {
                                nqp::push(@declarations, $decl);
                                nqp::push(@variables, $decl);
                            }
                        }
                    }
                    1 # visit children
                }
                else {
                    0 # it's an inner scope, don't visit its children
                }
            }
            nqp::bindattr($SELF, RakuAST::LexicalScope, '$!declarations-cache', @declarations);
            nqp::bindattr($SELF, RakuAST::LexicalScope, '$!variables-cache', @variables);
        }
        nqp::getattr($SELF, RakuAST::LexicalScope, '$!declarations-cache')
    
    });
    add-method(RakuAST::LexicalScope, 'generated-lexical-declarations', [RakuAST::LexicalScope, '', 0, 0], anon sub generated-lexical-declarations ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 113 src/Raku/ast/scoping.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations') // [])
    
    });
    add-method(RakuAST::LexicalScope, 'lexical-declarations', [RakuAST::LexicalScope, '', 0, 0], anon sub lexical-declarations ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 117 src/Raku/ast/scoping.rakumod
        
        my $declarations := nqp::clone($SELF.IMPL-UNWRAP-LIST($SELF.ast-lexical-declarations));
        for (nqp::getattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations') // []) {
            nqp::push($declarations, $_);
        }
        $SELF.IMPL-WRAP-LIST($declarations)
    
    });
    add-method(RakuAST::LexicalScope, 'add-generated-lexical-declaration', [RakuAST::LexicalScope, '', 0, 0, RakuAST::Declaration, '$declaration', 0, 0], anon sub add-generated-lexical-declaration ($SELF_CONT, $declaration!) {
        my $SELF := nqp::decont($SELF_CONT);
        $declaration := nqp::decont($declaration);
#line 126 src/Raku/ast/scoping.rakumod
        
        unless nqp::getattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations') {
            nqp::bindattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations', []);
        }
        nqp::push(nqp::getattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations'), $declaration);
        nqp::bindattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-lookup-hash', Mu);
        Nil
    
    });
    add-method(RakuAST::LexicalScope, 'merge-generated-lexical-declaration', [RakuAST::LexicalScope, '', 0, 0, RakuAST::Declaration, '$declaration', 0, 0, RakuAST::Resolver, '$resolver', 1, 0], anon sub merge-generated-lexical-declaration ($SELF_CONT, $declaration!, :$resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $declaration := nqp::decont($declaration);
        $resolver := nqp::decont($resolver);
#line 135 src/Raku/ast/scoping.rakumod
        
        unless nqp::getattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations') {
            nqp::bindattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations', []);
        }
        for nqp::getattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations') {
            if ($_.lexical-name // '') eq $declaration.lexical-name {
                if $_.compile-time-value =:= $declaration.compile-time-value {
                    return Nil
                }
                else {
                    $_.merge($declaration, :$resolver);
                    return;
                }
            }
        }
        nqp::push(nqp::getattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-declarations'), $declaration);
        nqp::bindattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-lookup-hash', Mu);
        Nil
    
    });
    add-method(RakuAST::LexicalScope, 'find-ast-lexical', [RakuAST::LexicalScope, '', 0, 0, Str, '$name', 0, 0], anon sub find-ast-lexical ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 157 src/Raku/ast/scoping.rakumod
        
        my %lookup := nqp::getattr($SELF, RakuAST::LexicalScope, '$!lexical-lookup-hash');
        unless nqp::isconcrete(%lookup) {
            %lookup := {};
            for $SELF.IMPL-UNWRAP-LIST($SELF.ast-lexical-declarations) {
                %lookup{$_.lexical-name} := $_;
            }
            nqp::bindattr($SELF, RakuAST::LexicalScope, '$!lexical-lookup-hash', %lookup);
        }
        %lookup{$name} // Nil
    
    });
    add-method(RakuAST::LexicalScope, 'find-generated-lexical', [RakuAST::LexicalScope, '', 0, 0, Str, '$name', 0, 0], anon sub find-generated-lexical ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 171 src/Raku/ast/scoping.rakumod
        
        my %lookup := nqp::getattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-lookup-hash');
        unless nqp::isconcrete(%lookup) {
            %lookup := {};
            for $SELF.IMPL-UNWRAP-LIST($SELF.generated-lexical-declarations) {
                my $lexical-name := $_.lexical-name;
                %lookup{$lexical-name} := $_ if $lexical-name;
            }
            nqp::bindattr($SELF, RakuAST::LexicalScope, '$!generated-lexical-lookup-hash', %lookup);
        }
        %lookup{$name} // Nil
    
    });
    add-method(RakuAST::LexicalScope, 'find-lexical', [RakuAST::LexicalScope, '', 0, 0, Str, '$name', 0, 0], anon sub find-lexical ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 187 src/Raku/ast/scoping.rakumod
        
        $SELF.find-ast-lexical($name) // $SELF.find-generated-lexical($name)
    
    });
    add-method(RakuAST::LexicalScope, 'require-succeed-handler', [RakuAST::LexicalScope, '', 0, 0], anon sub require-succeed-handler ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 191 src/Raku/ast/scoping.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::LexicalScope, '$!need-succeed-handler', 1);
        Nil
    
    });
    add-method(RakuAST::LexicalScope, 'attach-catch-handler', [RakuAST::LexicalScope, '', 0, 0, RakuAST::Statement::Catch, '$catch', 0, 0], anon sub attach-catch-handler ($SELF_CONT, $catch!) {
        my $SELF := nqp::decont($SELF_CONT);
        $catch := nqp::decont($catch);
#line 196 src/Raku/ast/scoping.rakumod
        
        if nqp::getattr($SELF, RakuAST::LexicalScope, '$!catch-handlers') {
            nqp::push(nqp::getattr($SELF, RakuAST::LexicalScope, '$!catch-handlers'), $catch);
        }
        else {
            nqp::bindattr($SELF, RakuAST::LexicalScope, '$!catch-handlers', [$catch]);
        }
        Nil
    
    });
    add-method(RakuAST::LexicalScope, 'attach-control-handler', [RakuAST::LexicalScope, '', 0, 0, RakuAST::Statement::Control, '$control', 0, 0], anon sub attach-control-handler ($SELF_CONT, $control!) {
        my $SELF := nqp::decont($SELF_CONT);
        $control := nqp::decont($control);
#line 206 src/Raku/ast/scoping.rakumod
        
        if nqp::getattr($SELF, RakuAST::LexicalScope, '$!control-handlers') {
            nqp::push(nqp::getattr($SELF, RakuAST::LexicalScope, '$!control-handlers'), $control);
        }
        else {
            nqp::bindattr($SELF, RakuAST::LexicalScope, '$!control-handlers', [$control]);
        }
        Nil
    
    });
    add-method(RakuAST::LexicalScope, 'PERFORM-CHECK', [RakuAST::LexicalScope, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 216 src/Raku/ast/scoping.rakumod
        
        my %lookup;
        for $SELF.IMPL-UNWRAP-LIST($SELF.generated-lexical-declarations) {
            my $lexical-name := $_.lexical-name;
            if $lexical-name {
                if nqp::existskey(%lookup, $lexical-name) {
                    $SELF.add-sorry:
                      $resolver.build-exception: 'X::Redeclaration',
                        :symbol($lexical-name);
                }
                else {
                    %lookup{$lexical-name} := $_;
                }
            }
        }
        for $SELF.IMPL-UNWRAP-LIST($SELF.ast-lexical-declarations) {
            my $lexical-name := $_.lexical-name;
            if $lexical-name && ! $_ =:= $SELF {
                if nqp::existskey(%lookup, $lexical-name) {
                    $SELF.add-sorry:
                      $resolver.build-exception: 'X::Redeclaration',
                        :symbol($lexical-name);
                }
                else {
                    %lookup{$lexical-name} := $_;
                }
            }
        }
        # Check for variables that are declared after they have already been used.
        # That's possible with dynamics and with variables also declared in outer scope.
        my %declarations;
        while nqp::getattr($SELF, RakuAST::LexicalScope, '$!variables-cache') {
            my $var := nqp::pop(nqp::getattr($SELF, RakuAST::LexicalScope, '$!variables-cache'));
            if nqp::istype($var, RakuAST::Declaration) {
                %declarations{$var.lexical-name} := $var;
            }
            else {
                if $var.is-resolved && nqp::existskey(%declarations, $var.name) {
                    my $decl := %declarations{$var.name};
                    $decl.add-sorry:
                      $resolver.build-exception:
                        $var.postdeclaration-exception-name,
                        :symbol($decl.lexical-name);
                    $resolver.add-node-with-check-time-problems($decl);
                }
            }
        }
    
    });
    add-method(RakuAST::LexicalScope, 'IMPL-HAS-CATCH-HANDLER', [RakuAST::LexicalScope, '', 0, 0], anon sub IMPL-HAS-CATCH-HANDLER ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 267 src/Raku/ast/scoping.rakumod
        
        nqp::getattr($SELF, RakuAST::LexicalScope, '$!catch-handlers') ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::LexicalScope, 'clear-handler-attachments', [RakuAST::LexicalScope, '', 0, 0], anon sub clear-handler-attachments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 271 src/Raku/ast/scoping.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::LexicalScope, '$!need-succeed-handler', 0);
        nqp::bindattr($SELF, RakuAST::LexicalScope, '$!catch-handlers', Mu);
        nqp::bindattr($SELF, RakuAST::LexicalScope, '$!control-handlers', Mu);
        Nil
    
    });
    add-method(RakuAST::LexicalScope, 'IMPL-WRAP-SCOPE-HANDLER-QAST', [RakuAST::LexicalScope, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statements', 0, 0, Bool, '$is-handler', 1, 1], anon sub IMPL-WRAP-SCOPE-HANDLER-QAST ($SELF_CONT, $context!, $statements!, :$is-handler?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statements := nqp::decont($statements);
        $is-handler := nqp::decont($is-handler);
#line 279 src/Raku/ast/scoping.rakumod
        
        # If it's an exception handler, add rethrow logic.
        if $is-handler {
            $statements := QAST::Stmts.new(
                # Set up a generic exception rethrow, so that exception handlers
                # from unwanted frames will get skipped if the code in our handler
                # throws an exception.
                QAST::Op.new(
                    :op('handle'),
                    $statements,
                    'CATCH',
                    QAST::Op.new(
                        :op('rethrow'),
                        QAST::Op.new( :op('exception') )
                    )
                ),
                # Otherwise, rethrow the exception if we reach the end of the handler
                # without `succeed`ing (that handler is wrapped outside of this one,
                # just below)
                QAST::Op.new(
                    :op('rethrow'),
                    QAST::Var.new( :name('EXCEPTION'), :scope('local') )
                )
            );
        }

        # Now wrap our own handlers.
        if nqp::getattr_i($SELF, RakuAST::LexicalScope, '$!need-succeed-handler') || nqp::getattr($SELF, RakuAST::LexicalScope, '$!catch-handlers') || nqp::getattr($SELF, RakuAST::LexicalScope, '$!control-handlers') {
            my $handle := QAST::Op.new( :op('handle'), $statements );
            if nqp::getattr_i($SELF, RakuAST::LexicalScope, '$!need-succeed-handler') {
                $handle.push('SUCCEED');
                $handle.push(QAST::Op.new( :op('getpayload'), QAST::Op.new( :op('exception') ) ));
            }
            if nqp::getattr($SELF, RakuAST::LexicalScope, '$!catch-handlers') {
                $SELF.IMPL-ADD-HANDLER($handle, 'CATCH');
            }
            if nqp::getattr($SELF, RakuAST::LexicalScope, '$!control-handlers') {
                $SELF.IMPL-ADD-HANDLER($handle, 'CONTROL');
            }
            $handle
        }
        else {
            $statements
        }
    
    });
    add-method(RakuAST::LexicalScope, 'IMPL-ADD-HANDLER', [RakuAST::LexicalScope, '', 0, 0, Mu, '$handle', 0, 0, str, '$handler', 0, 0], anon sub IMPL-ADD-HANDLER ($SELF_CONT, $handle!, $handler!) {
        my $SELF := nqp::decont($SELF_CONT);
        $handle := nqp::decont($handle);
        $handler := nqp::decont($handler);
#line 325 src/Raku/ast/scoping.rakumod
        
        $handle.push($handler);
        $handle.push(QAST::Stmt.new(
            QAST::Op.new(
                :op('call'),
                QAST::Var.new( :name('__' ~ $handler ~ '_HANDLER'), :scope('lexical') ),
                QAST::Op.new( :op('exception') )
            ),
            QAST::WVal.new( :value(Nil) )
        ));
    
    });
    compose(RakuAST::LexicalScope);
    parent(RakuAST::Declaration, RakuAST::Node);
    add-attribute(RakuAST::Declaration, str, '$!scope');
    add-method(RakuAST::Declaration, 'default-scope', [RakuAST::Declaration, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 345 src/Raku/ast/scoping.rakumod
        
        nqp::die('default-scope is not implemented on ' ~ $SELF.HOW.name($SELF))
    
    });
    add-method(RakuAST::Declaration, 'allowed-scopes', [RakuAST::Declaration, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 350 src/Raku/ast/scoping.rakumod
        
        nqp::die('allowed-scopes is not implemented on ' ~ $SELF.HOW.name($SELF))
    
    });
    add-method(RakuAST::Declaration, 'scope', [RakuAST::Declaration, '', 0, 0], anon sub scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 355 src/Raku/ast/scoping.rakumod
        
        my str $scope := nqp::getattr_s($SELF, RakuAST::Declaration, '$!scope');
        nqp::isnull_s($scope) || $scope eq ''
            ?? $SELF.default-scope
            !! $scope
    
    });
    add-method(RakuAST::Declaration, 'replace-scope', [RakuAST::Declaration, '', 0, 0, str, '$scope', 0, 0], anon sub replace-scope ($SELF_CONT, $scope!) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
#line 364 src/Raku/ast/scoping.rakumod
        
        nqp::bindattr_s($SELF, RakuAST::Declaration, '$!scope',
            $scope eq '' ?? nqp::null_s !! $scope);
        Nil
    
    });
    add-method(RakuAST::Declaration, 'is-lexical', [RakuAST::Declaration, '', 0, 0], anon sub is-lexical ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 371 src/Raku/ast/scoping.rakumod
        
        my str $scope := $SELF.scope;
        $scope eq 'my' || $scope eq 'state'
    
    });
    add-method(RakuAST::Declaration, 'is-simple-lexical-declaration', [RakuAST::Declaration, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 380 src/Raku/ast/scoping.rakumod
        
        $SELF.is-lexical
    
    });
    compose(RakuAST::Declaration);
    parent(RakuAST::ImplicitDeclarations, RakuAST::Node);
    add-attribute(RakuAST::ImplicitDeclarations, List, '$!implicit-declarations-cache');
    add-method(RakuAST::ImplicitDeclarations, 'PRODUCE-IMPLICIT-DECLARATIONS', [RakuAST::ImplicitDeclarations, '', 0, 0], anon sub PRODUCE-IMPLICIT-DECLARATIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 400 src/Raku/ast/scoping.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::list())
    
    });
    add-method(RakuAST::ImplicitDeclarations, 'get-implicit-declarations', [RakuAST::ImplicitDeclarations, '', 0, 0], anon sub get-implicit-declarations ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 405 src/Raku/ast/scoping.rakumod
        
        nqp::getattr($SELF, RakuAST::ImplicitDeclarations, '$!implicit-declarations-cache') //
            nqp::bindattr($SELF, RakuAST::ImplicitDeclarations,
                '$!implicit-declarations-cache',
                $SELF.PRODUCE-IMPLICIT-DECLARATIONS())
    
    });
    compose(RakuAST::ImplicitDeclarations);
    parent(RakuAST::Declaration::External, RakuAST::Declaration);
    add-attribute(RakuAST::Declaration::External, str, '$!lexical-name');
    add-attribute(RakuAST::Declaration::External, Mu, '$!native-type');
    add-method(RakuAST::Declaration::External, 'new', [RakuAST::Declaration::External, '', 0, 0, str, '$lexical-name', 1, 1, Mu, '$native-type', 1, 1], anon sub new ($SELF_CONT, :$lexical-name?, :$native-type?) {
        my $SELF := nqp::decont($SELF_CONT);
        $lexical-name := nqp::decont($lexical-name);
        $native-type := nqp::decont($native-type);
#line 421 src/Raku/ast/scoping.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration::External, '$!lexical-name', $lexical-name);
        nqp::bindattr($obj, RakuAST::Declaration::External, '$!native-type', $native-type);
        $obj
    
    });
    add-method(RakuAST::Declaration::External, 'IMPL-LOOKUP-QAST', [RakuAST::Declaration::External, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 428 src/Raku/ast/scoping.rakumod
        
        my str $scope := 'lexical';
        unless $rvalue {
            # Potentially l-value native lookups need a lexicalref.
            if nqp::objprimspec(nqp::getattr($SELF, RakuAST::Declaration::External, '$!native-type')) {
                $scope := 'lexicalref';
            }
        }
        QAST::Var.new( :name(nqp::getattr_s($SELF, RakuAST::Declaration::External, '$!lexical-name')), :$scope, :returns(nqp::getattr($SELF, RakuAST::Declaration::External, '$!native-type')) )
    
    });
    add-method(RakuAST::Declaration::External, 'default-scope', [RakuAST::Declaration::External, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 439 src/Raku/ast/scoping.rakumod
         'my' 
    });
    add-method(RakuAST::Declaration::External, 'allowed-scopes', [RakuAST::Declaration::External, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 441 src/Raku/ast/scoping.rakumod
         $SELF.IMPL-WRAP-LIST(['my']) 
    });
    add-method(RakuAST::Declaration::External, 'generate-lookup', [RakuAST::Declaration::External, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 443 src/Raku/ast/scoping.rakumod
        
        my $lookup := RakuAST::Var::Lexical.new(nqp::getattr_s($SELF, RakuAST::Declaration::External, '$!lexical-name'));
        $lookup.set-resolution($SELF);
        $lookup
    
    });
#line 418 src/Raku/ast/scoping.rakumod
    add-method(RakuAST::Declaration::External, 'lexical-name', [], anon sub lexical-name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Declaration::External, '$!lexical-name') });
    compose(RakuAST::Declaration::External);
    parent(RakuAST::Declaration::Mergeable, Any);
    add-method(RakuAST::Declaration::Mergeable, 'is-stub', [RakuAST::Declaration::Mergeable, '', 0, 0], anon sub is-stub ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 451 src/Raku/ast/scoping.rakumod
        
        return (Bool.WHO)<True> if nqp::istype($SELF, RakuAST::Declaration::LexicalPackage) && $SELF.package-is-stub;
        my $how  := $SELF.type.HOW;
        my $name := $how.HOW.name($how);
        $name eq 'Perl6::Metamodel::PackageHOW' || $name eq 'KnowHOW'
    
    });
    add-method(RakuAST::Declaration::Mergeable, 'merge', [RakuAST::Declaration::Mergeable, '', 0, 0, RakuAST::Declaration, '$other', 0, 0, RakuAST::Resolver, '$resolver', 1, 0], anon sub merge ($SELF_CONT, $other!, :$resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $other := nqp::decont($other);
        $resolver := nqp::decont($resolver);
#line 458 src/Raku/ast/scoping.rakumod
        
        my $target := $SELF.compile-time-value;
        my $source := $other.compile-time-value;

        my $loader := nqp::gethllsym('Raku', 'ModuleLoader');
        if $other.is-stub {
            # Source is a stub. We can safely merge the symbols
            # from source into the target that's importing them.
            $loader.merge_globals($target.WHO, $source.WHO);
        }
        elsif $SELF.is-stub {
            # The tricky case: here the interesting package is the
            # one in the module. So we merge the other way around
            # and install that as the result.
            $loader.merge_globals($source.WHO, $target.WHO);
            $SELF.set-value($source);
        }
        elsif nqp::can($SELF, 'lexical-name') && nqp::eqat($SELF.lexical-name, '&', 0) {
            # There's already a symbol. However, we may be able to merge
            # if both are multis and have onlystar dispatchers.
            if nqp::can($target, 'is_dispatcher') && $target.is_dispatcher
            && nqp::can($source, 'is_dispatcher') && $source.is_dispatcher
            && $target.onlystar && $source.onlystar {
                # Replace installed one with a derived one, to avoid any
                # weird action at a distance.
                $target := $target.derive_dispatcher;
                $SELF.set-value($target);

                # Incorporate dispatchees of foreign proto, avoiding
                # duplicates.
                my %seen;
                for $target.dispatchees {
                    %seen{$_.static_id} := $_;
                }
                for $source.dispatchees {
                    unless nqp::existskey(%seen, $_.static_id) {
                        $target.add_dispatchee($_);
                    }
                }
                return;
            }

            # "Latest wins" semantics for functions
            $SELF.set-value($source);
        }
        else {
            $resolver.panic(
                $resolver.build-exception(
                    'X::Redeclaration',
                    :symbol(nqp::can($SELF, 'lexical-name') ?? $SELF.lexical-name !! '')
                )
            );
        }
    
    });
    add-method(RakuAST::Declaration::Mergeable, 'set-value', [RakuAST::Declaration::Mergeable, '', 0, 0, Mu, '$value', 0, 0], anon sub set-value ($SELF_CONT, $value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $value := nqp::decont($value);
#line 513 src/Raku/ast/scoping.rakumod
        
        nqp::die('set-value not implemented on ' ~ $SELF.HOW.name($SELF));
    
    });
    compose(RakuAST::Declaration::Mergeable);
    parent(RakuAST::Declaration::External::Constant, RakuAST::Declaration::External);
    parent(RakuAST::Declaration::External::Constant, RakuAST::CompileTimeValue);
    parent(RakuAST::Declaration::External::Constant, RakuAST::Declaration::Mergeable);
    add-attribute(RakuAST::Declaration::External::Constant, Mu, '$!compile-time-value');
    add-method(RakuAST::Declaration::External::Constant, 'new', [RakuAST::Declaration::External::Constant, '', 0, 0, str, '$lexical-name', 1, 0, Mu, '$compile-time-value', 1, 0], anon sub new ($SELF_CONT, :$lexical-name!, :$compile-time-value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $lexical-name := nqp::decont($lexical-name);
        $compile-time-value := nqp::decont($compile-time-value);
#line 527 src/Raku/ast/scoping.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration::External, '$!lexical-name', $lexical-name);
        nqp::bindattr($obj, RakuAST::Declaration::External::Constant,
            '$!compile-time-value', $compile-time-value);
        $obj
    
    });
    add-method(RakuAST::Declaration::External::Constant, 'set-value', [RakuAST::Declaration::External::Constant, '', 0, 0, Mu, '$compile-time-value', 0, 0], anon sub set-value ($SELF_CONT, $compile-time-value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $compile-time-value := nqp::decont($compile-time-value);
#line 535 src/Raku/ast/scoping.rakumod
        
        nqp::bindattr($SELF, RakuAST::Declaration::External::Constant,
            '$!compile-time-value', $compile-time-value);
    
    });
    add-method(RakuAST::Declaration::External::Constant, 'type', [RakuAST::Declaration::External::Constant, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 540 src/Raku/ast/scoping.rakumod
         nqp::getattr($SELF, RakuAST::Declaration::External::Constant, '$!compile-time-value').WHAT 
    });
    add-method(RakuAST::Declaration::External::Constant, 'IMPL-LOOKUP-QAST', [RakuAST::Declaration::External::Constant, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 542 src/Raku/ast/scoping.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::Declaration::External::Constant, '$!compile-time-value');
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
#line 525 src/Raku/ast/scoping.rakumod
    add-method(RakuAST::Declaration::External::Constant, 'compile-time-value', [], anon sub compile-time-value ($self) { nqp::getattr(nqp::decont($self), RakuAST::Declaration::External::Constant, '$!compile-time-value') });
    compose(RakuAST::Declaration::External::Constant);
    parent(RakuAST::Declaration::External::Setting, RakuAST::Declaration::External);
    parent(RakuAST::Declaration::External::Setting, RakuAST::CompileTimeValue);
    parent(RakuAST::Declaration::External::Setting, RakuAST::Declaration::Mergeable);
    add-attribute(RakuAST::Declaration::External::Setting, Mu, '$!compile-time-value');
    add-method(RakuAST::Declaration::External::Setting, 'new', [RakuAST::Declaration::External::Setting, '', 0, 0, str, '$lexical-name', 1, 0, Mu, '$compile-time-value', 1, 0], anon sub new ($SELF_CONT, :$lexical-name!, :$compile-time-value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $lexical-name := nqp::decont($lexical-name);
        $compile-time-value := nqp::decont($compile-time-value);
#line 559 src/Raku/ast/scoping.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration::External, '$!lexical-name', $lexical-name);
        nqp::bindattr($obj, RakuAST::Declaration::External::Setting,
            '$!compile-time-value', $compile-time-value);
        $obj
    
    });
    add-method(RakuAST::Declaration::External::Setting, 'set-value', [RakuAST::Declaration::External::Setting, '', 0, 0, Mu, '$compile-time-value', 0, 0], anon sub set-value ($SELF_CONT, $compile-time-value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $compile-time-value := nqp::decont($compile-time-value);
#line 567 src/Raku/ast/scoping.rakumod
        
        nqp::bindattr($SELF, RakuAST::Declaration::External::Setting,
            '$!compile-time-value', $compile-time-value);
    
    });
    add-method(RakuAST::Declaration::External::Setting, 'type', [RakuAST::Declaration::External::Setting, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 572 src/Raku/ast/scoping.rakumod
         nqp::getattr($SELF, RakuAST::Declaration::External::Setting, '$!compile-time-value').WHAT 
    });
#line 557 src/Raku/ast/scoping.rakumod
    add-method(RakuAST::Declaration::External::Setting, 'compile-time-value', [], anon sub compile-time-value ($self) { nqp::getattr(nqp::decont($self), RakuAST::Declaration::External::Setting, '$!compile-time-value') });
    compose(RakuAST::Declaration::External::Setting);
    parent(RakuAST::Declaration::Import, RakuAST::Declaration::External::Constant);
    add-method(RakuAST::Declaration::Import, 'IMPL-QAST-DECL', [RakuAST::Declaration::Import, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 580 src/Raku/ast/scoping.rakumod
        
        my $value := $SELF.compile-time-value;
        $context.ensure-sc($value);
        QAST::Var.new(
            :scope('lexical'), :decl('static'), :name($SELF.lexical-name), :$value
        )
    
    });
    compose(RakuAST::Declaration::Import);
    parent(RakuAST::Declaration::LexicalPackage, RakuAST::Declaration);
    parent(RakuAST::Declaration::LexicalPackage, RakuAST::CompileTimeValue);
    parent(RakuAST::Declaration::LexicalPackage, RakuAST::Declaration::Mergeable);
    add-attribute(RakuAST::Declaration::LexicalPackage, str, '$!lexical-name');
    add-attribute(RakuAST::Declaration::LexicalPackage, Mu, '$!compile-time-value');
    add-attribute(RakuAST::Declaration::LexicalPackage, RakuAST::Package, '$!package');
    add-method(RakuAST::Declaration::LexicalPackage, 'new', [RakuAST::Declaration::LexicalPackage, '', 0, 0, str, '$lexical-name', 1, 0, Mu, '$compile-time-value', 1, 0, RakuAST::Package, '$package', 1, 0], anon sub new ($SELF_CONT, :$lexical-name!, :$compile-time-value!, :$package!) {
        my $SELF := nqp::decont($SELF_CONT);
        $lexical-name := nqp::decont($lexical-name);
        $compile-time-value := nqp::decont($compile-time-value);
        $package := nqp::decont($package);
#line 601 src/Raku/ast/scoping.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration::LexicalPackage,
            '$!lexical-name', $lexical-name);
        nqp::bindattr($obj, RakuAST::Declaration::LexicalPackage,
            '$!compile-time-value', $compile-time-value);
        nqp::bindattr($obj, RakuAST::Declaration::LexicalPackage,
            '$!package', $package);
        $obj
    
    });
    add-method(RakuAST::Declaration::LexicalPackage, 'set-value', [RakuAST::Declaration::LexicalPackage, '', 0, 0, Mu, '$compile-time-value', 0, 0], anon sub set-value ($SELF_CONT, $compile-time-value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $compile-time-value := nqp::decont($compile-time-value);
#line 612 src/Raku/ast/scoping.rakumod
        
        nqp::bindattr($SELF, RakuAST::Declaration::LexicalPackage,
            '$!compile-time-value', $compile-time-value);
    
    });
    add-method(RakuAST::Declaration::LexicalPackage, 'package-is-stub', [RakuAST::Declaration::LexicalPackage, '', 0, 0], anon sub package-is-stub ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 617 src/Raku/ast/scoping.rakumod
        
        nqp::getattr($SELF, RakuAST::Declaration::LexicalPackage, '$!package').is-stub
    
    });
    add-method(RakuAST::Declaration::LexicalPackage, 'type', [RakuAST::Declaration::LexicalPackage, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 621 src/Raku/ast/scoping.rakumod
         nqp::getattr($SELF, RakuAST::Declaration::LexicalPackage, '$!compile-time-value').WHAT 
    });
    add-method(RakuAST::Declaration::LexicalPackage, 'IMPL-QAST-DECL', [RakuAST::Declaration::LexicalPackage, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 623 src/Raku/ast/scoping.rakumod
        
        $context.ensure-sc(nqp::getattr($SELF, RakuAST::Declaration::LexicalPackage, '$!compile-time-value'));
        QAST::Var.new(
            :scope('lexical'), :decl('static'), :name(nqp::getattr_s($SELF, RakuAST::Declaration::LexicalPackage, '$!lexical-name')),
            :value(nqp::getattr($SELF, RakuAST::Declaration::LexicalPackage, '$!compile-time-value'))
        )
    
    });
    add-method(RakuAST::Declaration::LexicalPackage, 'IMPL-LOOKUP-QAST', [RakuAST::Declaration::LexicalPackage, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 631 src/Raku/ast/scoping.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::Declaration::LexicalPackage, '$!compile-time-value');
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
#line 599 src/Raku/ast/scoping.rakumod
    add-method(RakuAST::Declaration::LexicalPackage, 'package', [], anon sub package ($self) { nqp::getattr(nqp::decont($self), RakuAST::Declaration::LexicalPackage, '$!package') });
#line 597 src/Raku/ast/scoping.rakumod
    add-method(RakuAST::Declaration::LexicalPackage, 'lexical-name', [], anon sub lexical-name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Declaration::LexicalPackage, '$!lexical-name') });
#line 598 src/Raku/ast/scoping.rakumod
    add-method(RakuAST::Declaration::LexicalPackage, 'compile-time-value', [], anon sub compile-time-value ($self) { nqp::getattr(nqp::decont($self), RakuAST::Declaration::LexicalPackage, '$!compile-time-value') });
    compose(RakuAST::Declaration::LexicalPackage);
    parent(RakuAST::Declaration::ResolvedConstant, RakuAST::Declaration);
    parent(RakuAST::Declaration::ResolvedConstant, RakuAST::CompileTimeValue);
    add-attribute(RakuAST::Declaration::ResolvedConstant, Mu, '$!compile-time-value');
    add-method(RakuAST::Declaration::ResolvedConstant, 'new', [RakuAST::Declaration::ResolvedConstant, '', 0, 0, Mu, '$compile-time-value', 1, 0], anon sub new ($SELF_CONT, :$compile-time-value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $compile-time-value := nqp::decont($compile-time-value);
#line 647 src/Raku/ast/scoping.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Declaration::ResolvedConstant,
            '$!compile-time-value', $compile-time-value);
        $obj
    
    });
    add-method(RakuAST::Declaration::ResolvedConstant, 'type', [RakuAST::Declaration::ResolvedConstant, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 654 src/Raku/ast/scoping.rakumod
         nqp::getattr($SELF, RakuAST::Declaration::ResolvedConstant, '$!compile-time-value').WHAT 
    });
    add-method(RakuAST::Declaration::ResolvedConstant, 'IMPL-TO-QAST', [RakuAST::Declaration::ResolvedConstant, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 656 src/Raku/ast/scoping.rakumod
        
        $SELF.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::Declaration::ResolvedConstant, 'IMPL-LOOKUP-QAST', [RakuAST::Declaration::ResolvedConstant, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 660 src/Raku/ast/scoping.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::Declaration::ResolvedConstant, '$!compile-time-value');
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
    add-method(RakuAST::Declaration::ResolvedConstant, 'default-scope', [RakuAST::Declaration::ResolvedConstant, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 666 src/Raku/ast/scoping.rakumod
         'package' 
    });
    add-method(RakuAST::Declaration::ResolvedConstant, 'allowed-scopes', [RakuAST::Declaration::ResolvedConstant, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 668 src/Raku/ast/scoping.rakumod
         $SELF.IMPL-WRAP-LIST(['package']) 
    });
    add-method(RakuAST::Declaration::ResolvedConstant, 'IMPL-CAN-INTERPRET', [RakuAST::Declaration::ResolvedConstant, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 670 src/Raku/ast/scoping.rakumod
        
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Declaration::ResolvedConstant, 'IMPL-INTERPRET', [RakuAST::Declaration::ResolvedConstant, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 674 src/Raku/ast/scoping.rakumod
        
        nqp::getattr($SELF, RakuAST::Declaration::ResolvedConstant, '$!compile-time-value')
    
    });
#line 645 src/Raku/ast/scoping.rakumod
    add-method(RakuAST::Declaration::ResolvedConstant, 'compile-time-value', [], anon sub compile-time-value ($self) { nqp::getattr(nqp::decont($self), RakuAST::Declaration::ResolvedConstant, '$!compile-time-value') });
    compose(RakuAST::Declaration::ResolvedConstant);
    parent(RakuAST::Lookup, RakuAST::Node);
    add-attribute(RakuAST::Lookup, RakuAST::Declaration, '$!resolution');
    add-method(RakuAST::Lookup, 'needs-resolution', [RakuAST::Lookup, '', 0, 0], anon sub needs-resolution ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 686 src/Raku/ast/scoping.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Lookup, 'is-resolved', [RakuAST::Lookup, '', 0, 0], anon sub is-resolved ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 688 src/Raku/ast/scoping.rakumod
        
        nqp::isconcrete(nqp::getattr($SELF, RakuAST::Lookup, '$!resolution')) ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Lookup, 'resolution', [RakuAST::Lookup, '', 0, 0], anon sub resolution ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 692 src/Raku/ast/scoping.rakumod
        
        nqp::isconcrete(nqp::getattr($SELF, RakuAST::Lookup, '$!resolution'))
            ?? nqp::getattr($SELF, RakuAST::Lookup, '$!resolution')
            !! nqp::die('This element has not been resolved. Type: ' ~ $SELF.HOW.name($SELF))
    
    });
    add-method(RakuAST::Lookup, 'set-resolution', [RakuAST::Lookup, '', 0, 0, RakuAST::Declaration, '$resolution', 0, 0], anon sub set-resolution ($SELF_CONT, $resolution!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolution := nqp::decont($resolution);
#line 698 src/Raku/ast/scoping.rakumod
        
        nqp::bindattr($SELF, RakuAST::Lookup, '$!resolution', $resolution)
    
    });
    add-method(RakuAST::Lookup, 'undeclared-symbol-details', [RakuAST::Lookup, '', 0, 0], anon sub undeclared-symbol-details ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 705 src/Raku/ast/scoping.rakumod
        
        Nil
    
    });
    compose(RakuAST::Lookup);
    parent(RakuAST::UndeclaredSymbolDescription, Any);
    add-attribute(RakuAST::UndeclaredSymbolDescription, str, '$!name');
    add-method(RakuAST::UndeclaredSymbolDescription, 'new', [RakuAST::UndeclaredSymbolDescription, '', 0, 0, str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 714 src/Raku/ast/scoping.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::UndeclaredSymbolDescription, '$!name', $name);
        $obj
    
    });
#line 712 src/Raku/ast/scoping.rakumod
    add-method(RakuAST::UndeclaredSymbolDescription, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::UndeclaredSymbolDescription, '$!name') });
    compose(RakuAST::UndeclaredSymbolDescription);
    parent(RakuAST::UndeclaredSymbolDescription::Routine, RakuAST::UndeclaredSymbolDescription);
    add-method(RakuAST::UndeclaredSymbolDescription::Routine, 'IMPL-REPORT', [RakuAST::UndeclaredSymbolDescription::Routine, '', 0, 0, RakuAST::Lookup, '$node', 0, 0, Mu, '$types', 0, 0, Mu, '$routines', 0, 0, Mu, '$other', 0, 0], anon sub IMPL-REPORT ($SELF_CONT, $node!, $types!, $routines!, $other!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
        $types := nqp::decont($types);
        $routines := nqp::decont($routines);
        $other := nqp::decont($other);
#line 723 src/Raku/ast/scoping.rakumod
        
        nqp::bindkey($routines, $SELF.name, [-1]);
    
    });
    compose(RakuAST::UndeclaredSymbolDescription::Routine);
    parent(RakuAST::ImplicitLookups, RakuAST::Node);
    add-attribute(RakuAST::ImplicitLookups, List, '$!implicit-lookups-cache');
    add-method(RakuAST::ImplicitLookups, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::ImplicitLookups, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 742 src/Raku/ast/scoping.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::list())
    
    });
    add-method(RakuAST::ImplicitLookups, 'get-implicit-lookups', [RakuAST::ImplicitLookups, '', 0, 0], anon sub get-implicit-lookups ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 747 src/Raku/ast/scoping.rakumod
        
        nqp::isconcrete($SELF)
            ?? nqp::getattr($SELF, RakuAST::ImplicitLookups, '$!implicit-lookups-cache') //
                nqp::bindattr($SELF, RakuAST::ImplicitLookups, '$!implicit-lookups-cache',
                    $SELF.PRODUCE-IMPLICIT-LOOKUPS())
            !! $SELF.IMPL-WRAP-LIST([])
    
    });
    add-method(RakuAST::ImplicitLookups, 'resolve-implicit-lookups-with', [RakuAST::ImplicitLookups, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-implicit-lookups-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 756 src/Raku/ast/scoping.rakumod
        
        for $SELF.IMPL-UNWRAP-LIST($SELF.get-implicit-lookups()) {
            # We use null to pad out lookup lists so that they always
            # have the same number of elements regardless of whether
            # some lookups can only be conditionally included in the list
            unless nqp::isnull($_) || $_.is-resolved {
                $_.resolve-with($resolver);
            }
        }
    
    });
    compose(RakuAST::ImplicitLookups);
    parent(RakuAST::PackageInstaller, Any);
    add-method(RakuAST::PackageInstaller, 'IMPL-INSTALL-PACKAGE', [RakuAST::PackageInstaller, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, str, '$scope', 0, 0, RakuAST::Name, '$name', 0, 0, Mu, '$type-object', 0, 0, RakuAST::Package, '$current-package', 0, 0, Bool, '$no-lexical', 1, 1], anon sub IMPL-INSTALL-PACKAGE ($SELF_CONT, $resolver!, $scope!, $name!, $type-object!, $current-package!, :$no-lexical?) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $scope := nqp::decont($scope);
        $name := nqp::decont($name);
        $type-object := nqp::decont($type-object);
        $current-package := nqp::decont($current-package);
        $no-lexical := nqp::decont($no-lexical);
#line 780 src/Raku/ast/scoping.rakumod
        
        my $target;
        my $final;
        my $lexical;
        my $pure-package-installation := nqp::istype($SELF, RakuAST::Package);

        my $illegal-pseudo-package := $name.contains-pseudo-package-illegal-for-declaration;
        $resolver.add-sorry: $resolver.build-exception:
            'X::PseudoPackage::InDeclaration',
                pseudo-package => $illegal-pseudo-package,
                action => $SELF.dba ~ ' name'
            if $illegal-pseudo-package;

        if $name.is-identifier {
            $final := $name.canonicalize;
            unless $no-lexical {
                $lexical := $resolver.resolve-lexical-constant($final);
                if $pure-package-installation || !$lexical {
                    $resolver.current-scope.merge-generated-lexical-declaration:
                        :$resolver,
                        $SELF.IMPL-GENERATE-LEXICAL-DECLARATION($final, $type-object);
                }
            }
            # If `our`-scoped, also put it into the current package.
            if $scope eq 'our' {
                $target := $current-package;

                my %stash := $resolver.IMPL-STASH-HASH($target);
                if nqp::existskey(%stash, $final) && !(%stash{$final} =:= $type-object || nqp::istype(%stash{$final}.HOW, Perl6::Metamodel::PackageHOW)) {
                    $resolver.add-sorry: $resolver.build-exception:
                        'X::Redeclaration', :symbol($final);
                }
            }
        }
        else {
            my @parts := nqp::clone($SELF.IMPL-UNWRAP-LIST($name.parts));
            $final := nqp::pop(@parts).name;
            my $first := @parts[0].name;
            my $resolved := $resolver.partially-resolve-name-constant(RakuAST::Name.new(|@parts));

            if $resolved { # first parts of the name found
                $resolved := $SELF.IMPL-UNWRAP-LIST($resolved);
                $target := $resolved[0];
                if $scope eq 'our' && nqp::elems(@parts) == 1 {
                    # Upgrade lexically imported top level package to global
                    ($resolver.get-global.WHO){$first} := $resolver.resolve-lexical($first).compile-time-value;
                }
                my $parts  := $resolved[1];
                @parts := $SELF.IMPL-UNWRAP-LIST($parts);
                $scope := 'our'; # Ensure we install the package into the parent stash
                if nqp::elems(@parts) {
                    my $longname := $target.HOW.name($target);

                    for @parts {
                        $longname := $longname ~ '::' ~ $_.name;
                        my $package := Perl6::Metamodel::PackageHOW.new_type(name => $longname);
                        $package.HOW.compose($package);
                        my %stash := $resolver.IMPL-STASH-HASH($target);
                        %stash{$_.name} := $package;
                        $target := $package;
                    }
                }
            }
            else {
                my $first := nqp::shift(@parts).name;
                $target := Perl6::Metamodel::PackageHOW.new_type(name => $first);
                $target.HOW.compose($target);
                $resolver.current-scope.merge-generated-lexical-declaration:
                    :$resolver,
                    RakuAST::Declaration::LexicalPackage.new:
                        :lexical-name($first),
                        :compile-time-value($target),
                        :package($pure-package-installation ?? $SELF !! $current-package);
                if $scope eq 'our' {
                    # TODO conflicts
                    my %stash := $resolver.IMPL-STASH-HASH($current-package);
                    %stash{$first} := $target;
                }
                $scope := 'our'; # Ensure we install the package into the generated stub

                my $longname := $first;
                for @parts {
                    $longname := $longname ~ '::' ~ $_.name;
                    my $package := Perl6::Metamodel::PackageHOW.new_type(name => $longname);
                    $package.HOW.compose($package);
                    my %stash := $resolver.IMPL-STASH-HASH($target);
                    %stash{$_.name} := $package;
                    $target := $package;
                }
            }
        }

        my %stash := $resolver.IMPL-STASH-HASH($target);
        # upgrade a lexically imported package stub to package scope if it exists
        if $lexical {
            %stash{$final} := $lexical.compile-time-value;
        }
        if $scope eq 'our' {
            if nqp::existskey(%stash, $final) && !(%stash{$final} =:= $type-object) {
                nqp::setwho($type-object, %stash{$final}.WHO);
            }
            %stash{$final} := $type-object;
        }
    
    });
    compose(RakuAST::PackageInstaller);
    parent(RakuAST::Attaching, RakuAST::Node);
    add-method(RakuAST::Attaching, 'attach', [RakuAST::Attaching, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 11 src/Raku/ast/attaching.rakumod
        
        nqp::die('attach not implemented for ' ~ $SELF.HOW.name($SELF));
    
    });
    compose(RakuAST::Attaching);
    parent(RakuAST::AttachTarget, RakuAST::Node);
    add-method(RakuAST::AttachTarget, 'attach-target-names', [RakuAST::AttachTarget, '', 0, 0], anon sub attach-target-names ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 22 src/Raku/ast/attaching.rakumod
        
        nqp::die('attach-target-names not implemented for ' ~ $SELF.HOW.name($SELF));
    
    });
    add-method(RakuAST::AttachTarget, 'clear-attachments', [RakuAST::AttachTarget, '', 0, 0], anon sub clear-attachments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 28 src/Raku/ast/attaching.rakumod
        
        nqp::die('clear-attachments not implemented for ' ~ $SELF.HOW.name($SELF));
    
    });
    compose(RakuAST::AttachTarget);
    parent(RakuAST::BeginTime, RakuAST::Node);
    add-attribute(RakuAST::BeginTime, int, '$!begin-performed');
    add-method(RakuAST::BeginTime, 'PERFORM-BEGIN', [RakuAST::BeginTime, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 10 src/Raku/ast/begintime.rakumod
        
        nqp::die('Missing PERFORM-BEGIN implementation in ' ~ $SELF.HOW.name($SELF))
    
    });
    add-method(RakuAST::BeginTime, 'is-begin-performed-before-children', [RakuAST::BeginTime, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 16 src/Raku/ast/begintime.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::BeginTime, 'is-begin-performed-after-children', [RakuAST::BeginTime, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 17 src/Raku/ast/begintime.rakumod
         !$SELF.is-begin-performed-before-children 
    });
    add-method(RakuAST::BeginTime, 'ensure-begin-performed', [RakuAST::BeginTime, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, int, '$phase', 1, 1], anon sub ensure-begin-performed ($SELF_CONT, $resolver!, $context!, :$phase?) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $phase := nqp::decont($phase);
#line 20 src/Raku/ast/begintime.rakumod
        
        if nqp::can($SELF, 'PERFORM-BEGIN-BEFORE-CHILDREN') || nqp::can($SELF, 'PERFORM-BEGIN-AFTER-CHILDREN') {
            if $phase == 0 && $SELF.is-begin-performed-before-children || $phase == 1 {
                unless nqp::getattr_i($SELF, RakuAST::BeginTime, '$!begin-performed') +& 1 {
                    $SELF.PERFORM-BEGIN-BEFORE-CHILDREN($resolver, $context);
                    nqp::bindattr_i($SELF, RakuAST::BeginTime, '$!begin-performed',  nqp::getattr_i($SELF, RakuAST::BeginTime, '$!begin-performed') +| 1);
                }
            }
            if $phase == 0 && $SELF.is-begin-performed-after-children || $phase == 2 {
                unless nqp::getattr_i($SELF, RakuAST::BeginTime, '$!begin-performed') +& 2 {
                    $SELF.PERFORM-BEGIN-AFTER-CHILDREN($resolver, $context);
                    nqp::bindattr_i($SELF, RakuAST::BeginTime, '$!begin-performed', nqp::getattr_i($SELF, RakuAST::BeginTime, '$!begin-performed') +| 2);
                }
            }
        }
        else {
            unless nqp::getattr_i($SELF, RakuAST::BeginTime, '$!begin-performed') {
                $SELF.PERFORM-BEGIN($resolver, $context);
                nqp::bindattr_i($SELF, RakuAST::BeginTime, '$!begin-performed', 3);
            }
        }
        Nil
    
    });
    add-method(RakuAST::BeginTime, 'begin-performed', [RakuAST::BeginTime, '', 0, 0], anon sub begin-performed ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 44 src/Raku/ast/begintime.rakumod
        
        nqp::getattr_i($SELF, RakuAST::BeginTime, '$!begin-performed') == 3
    
    });
    add-method(RakuAST::BeginTime, 'IMPL-BEGIN-TIME-EVALUATE', [RakuAST::BeginTime, '', 0, 0, RakuAST::Node, '$code', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-BEGIN-TIME-EVALUATE ($SELF_CONT, $code!, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $code := nqp::decont($code);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 50 src/Raku/ast/begintime.rakumod
        
        my $*IMPL-COMPILE-DYNAMICALLY := 1;
        $code.IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);
        if $code.IMPL-CAN-INTERPRET {
            $code.IMPL-INTERPRET(RakuAST::IMPL::InterpContext.new)
        }
        elsif nqp::istype($code, RakuAST::Code) {
            $code.meta-object;
        }
        elsif nqp::istype($code, RakuAST::Expression) {
            my $thunk := RakuAST::ExpressionThunk.new;
            $code.wrap-with-thunk($thunk);
            $thunk.IMPL-STUB-CODE($resolver, $context);
            $thunk.IMPL-QAST-BLOCK($context, :expression($code));
            $thunk.meta-object()()
        }
        else {
            nqp::die('BEGIN time evaluation only supported for simple constructs so far')
        }
    
    });
    add-method(RakuAST::BeginTime, 'IMPL-BEGIN-TIME-CALL', [RakuAST::BeginTime, '', 0, 0, RakuAST::Node, '$callee', 0, 0, RakuAST::ArgList, '$args', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-BEGIN-TIME-CALL ($SELF_CONT, $callee!, $args!, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $callee := nqp::decont($callee);
        $args := nqp::decont($args);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 74 src/Raku/ast/begintime.rakumod
        
        my $*IMPL-COMPILE-DYNAMICALLY := 1;
        if $callee.is-resolved && nqp::istype($callee.resolution, RakuAST::CompileTimeValue) &&
                $args.IMPL-CAN-INTERPRET {
            my $resolved := $callee.resolution.compile-time-value;
            my @args := $args.IMPL-INTERPRET(RakuAST::IMPL::InterpContext.new);
            my @pos := @args[0];
            my %named := @args[1];
            return $resolved(|@pos, |%named);
        }
        else {
            nqp::die('BEGIN time calls only supported for simple constructs so far')
        }
    
    });
    compose(RakuAST::BeginTime);
    parent(RakuAST::TraitTarget, Any);
    add-attribute(RakuAST::TraitTarget, Mu, '$!traits');
    add-method(RakuAST::TraitTarget, 'set-traits', [RakuAST::TraitTarget, '', 0, 0, List, '$traits', 0, 0], anon sub set-traits ($SELF_CONT, $traits!) {
        my $SELF := nqp::decont($SELF_CONT);
        $traits := nqp::decont($traits);
#line 6 src/Raku/ast/traits.rakumod
        
        my @traits;
        if $traits {
            for $SELF.IMPL-UNWRAP-LIST($traits) {
                unless nqp::istype($_, RakuAST::Trait) {
                    nqp::die('The traits list can only contain RakuAST::Trait objects');
                }
                nqp::push(@traits, $_);
            }
        }
        nqp::bindattr($SELF, RakuAST::TraitTarget, '$!traits', @traits);
        Nil
    
    });
    add-method(RakuAST::TraitTarget, 'add-trait', [RakuAST::TraitTarget, '', 0, 0, RakuAST::Trait, '$trait', 0, 0], anon sub add-trait ($SELF_CONT, $trait!) {
        my $SELF := nqp::decont($SELF_CONT);
        $trait := nqp::decont($trait);
#line 21 src/Raku/ast/traits.rakumod
        
        my $traits := nqp::getattr($SELF, RakuAST::TraitTarget, '$!traits');
        unless nqp::islist($traits) {
            $traits := [];
            nqp::bindattr($SELF, RakuAST::TraitTarget, '$!traits', $traits);
        }
        nqp::push($traits, $trait);
        Nil
    
    });
    add-method(RakuAST::TraitTarget, 'traits', [RakuAST::TraitTarget, '', 0, 0], anon sub traits ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 32 src/Raku/ast/traits.rakumod
        
        my $traits := nqp::getattr($SELF, RakuAST::TraitTarget, '$!traits');
        $SELF.IMPL-WRAP-LIST(nqp::islist($traits) ?? $traits !! [])
    
    });
    add-method(RakuAST::TraitTarget, 'apply-traits', [RakuAST::TraitTarget, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::TraitTarget, '$target', 0, 0, Any, '%named', 0, 0], anon sub apply-traits ($SELF_CONT, $resolver!, $context!, $target!, *%named) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $target := nqp::decont($target);
        %named := nqp::decont(%named);
#line 38 src/Raku/ast/traits.rakumod
        
        if nqp::getattr($SELF, RakuAST::TraitTarget, '$!traits') {
            for nqp::getattr($SELF, RakuAST::TraitTarget, '$!traits') {
                $_.apply($resolver, $context, $target, |%named) unless $_.applied;
            }
        }
        Nil
    
    });
    add-method(RakuAST::TraitTarget, 'visit-traits', [RakuAST::TraitTarget, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-traits ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 48 src/Raku/ast/traits.rakumod
        
        if nqp::getattr($SELF, RakuAST::TraitTarget, '$!traits') {
            for nqp::getattr($SELF, RakuAST::TraitTarget, '$!traits') {
                $visitor($_);
            }
        }
    
    });
    compose(RakuAST::TraitTarget);
    parent(RakuAST::Trait, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Trait, int, '$!applied');
    add-method(RakuAST::Trait, 'IMPL-TRAIT-NAME', [RakuAST::Trait, '', 0, 0], anon sub IMPL-TRAIT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 63 src/Raku/ast/traits.rakumod
        
        nqp::die($SELF.HOW.name($SELF) ~ ' does not implement IMPL-TRAIT-NAME')
    
    });
    add-method(RakuAST::Trait, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Trait, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 67 src/Raku/ast/traits.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical::Constant.new('&trait_mod:<' ~ $SELF.IMPL-TRAIT-NAME() ~ '>')
        ])
    
    });
    add-method(RakuAST::Trait, 'applied', [RakuAST::Trait, '', 0, 0], anon sub applied ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 74 src/Raku/ast/traits.rakumod
        
        nqp::getattr_i($SELF, RakuAST::Trait, '$!applied') ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Trait, 'mark-applied', [RakuAST::Trait, '', 0, 0], anon sub mark-applied ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 81 src/Raku/ast/traits.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::Trait, '$!applied', 1);
        Nil
    
    });
    add-method(RakuAST::Trait, 'apply', [RakuAST::Trait, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::TraitTarget, '$target', 0, 0, Any, '%named', 0, 0], anon sub apply ($SELF_CONT, $resolver!, $context!, $target!, *%named) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $target := nqp::decont($target);
        %named := nqp::decont(%named);
#line 88 src/Raku/ast/traits.rakumod
        
        unless $SELF.applied {
            $SELF.IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);
            my $decl-target := RakuAST::Declaration::ResolvedConstant.new:
                compile-time-value => $target.compile-time-value;
            my $args := $SELF.IMPL-TRAIT-ARGS($resolver, $decl-target);
            for %named {
                nqp::push(
                    $SELF.IMPL-UNWRAP-LIST($args.args),
                    RakuAST::ColonPair::Value.new(:key(nqp::iterkey_s($_)), :value(nqp::iterval($_)))
                );
            }
            $args.IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);
            $target.IMPL-BEGIN-TIME-CALL(
              $SELF.get-implicit-lookups.AT-POS(0),
              $args,
              $resolver,
              $context
            );
            $SELF.mark-applied;
        }
    
    });
    compose(RakuAST::Trait);
    parent(RakuAST::Trait::Is, RakuAST::Trait);
    parent(RakuAST::Trait::Is, RakuAST::BeginTime);
    add-attribute(RakuAST::Trait::Is, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Trait::Is, RakuAST::Circumfix, '$!argument');
    add-attribute(RakuAST::Trait::Is, RakuAST::Term::Name, '$!resolved-name');
    add-method(RakuAST::Trait::Is, 'new', [RakuAST::Trait::Is, '', 0, 0, RakuAST::Name, '$name', 1, 0, RakuAST::Circumfix, '$argument', 1, 1], anon sub new ($SELF_CONT, :$name!, :$argument?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $argument := nqp::decont($argument);
#line 121 src/Raku/ast/traits.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Trait::Is, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Trait::Is, '$!argument',
            $argument // RakuAST::Circumfix);
        $obj
    
    });
    add-method(RakuAST::Trait::Is, 'PERFORM-BEGIN', [RakuAST::Trait::Is, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 129 src/Raku/ast/traits.rakumod
        
        # See if the name resolves as a type and commit to that.
        my $resolution := $resolver.resolve-name-constant(nqp::getattr($SELF, RakuAST::Trait::Is, '$!name'));
        if nqp::istype($resolution, RakuAST::CompileTimeValue) &&
                !nqp::isconcrete($resolution.compile-time-value) {
            my $resolved-name := RakuAST::Type::Simple.new(nqp::getattr($SELF, RakuAST::Trait::Is, '$!name'));
            $resolved-name.set-resolution($resolution);
            nqp::bindattr($SELF, RakuAST::Trait::Is, '$!resolved-name',
                $resolved-name);
        }
        Nil
    
    });
    add-method(RakuAST::Trait::Is, 'IMPL-TRAIT-NAME', [RakuAST::Trait::Is, '', 0, 0], anon sub IMPL-TRAIT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 142 src/Raku/ast/traits.rakumod
         'is' 
    });
    add-method(RakuAST::Trait::Is, 'IMPL-TRAIT-ARGS', [RakuAST::Trait::Is, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::Node, '$target', 0, 0], anon sub IMPL-TRAIT-ARGS ($SELF_CONT, $resolver!, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $target := nqp::decont($target);
#line 144 src/Raku/ast/traits.rakumod
        
        my @args := [$target];
        if nqp::getattr($SELF, RakuAST::Trait::Is, '$!resolved-name') {
            @args.push(nqp::getattr($SELF, RakuAST::Trait::Is, '$!resolved-name'));
        }
        else {
            my $key := nqp::getattr($SELF, RakuAST::Trait::Is, '$!name').canonicalize;
            @args.push(
                nqp::getattr($SELF, RakuAST::Trait::Is, '$!argument')
                ?? RakuAST::ColonPair::Value.new(:$key, :value(nqp::getattr($SELF, RakuAST::Trait::Is, '$!argument')))
                !! RakuAST::ColonPair::True.new($key)
            );
        }
        RakuAST::ArgList.new(|@args)
    
    });
    add-method(RakuAST::Trait::Is, 'visit-children', [RakuAST::Trait::Is, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 160 src/Raku/ast/traits.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Trait::Is, '$!name'));
        $visitor(nqp::getattr($SELF, RakuAST::Trait::Is, '$!argument')) if nqp::getattr($SELF, RakuAST::Trait::Is, '$!argument');
    
    });
#line 119 src/Raku/ast/traits.rakumod
    add-method(RakuAST::Trait::Is, 'resolved-name', [], anon sub resolved-name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Trait::Is, '$!resolved-name') });
#line 117 src/Raku/ast/traits.rakumod
    add-method(RakuAST::Trait::Is, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Trait::Is, '$!name') });
#line 118 src/Raku/ast/traits.rakumod
    add-method(RakuAST::Trait::Is, 'argument', [], anon sub argument ($self) { nqp::getattr(nqp::decont($self), RakuAST::Trait::Is, '$!argument') });
    compose(RakuAST::Trait::Is);
    parent(RakuAST::Trait::Type, RakuAST::Trait);
    add-attribute(RakuAST::Trait::Type, RakuAST::Type, '$!type');
    add-method(RakuAST::Trait::Type, 'new', [RakuAST::Trait::Type, '', 0, 0, RakuAST::Type, '$type', 0, 0], anon sub new ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 171 src/Raku/ast/traits.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Trait::Type, '$!type', $type);
        $obj
    
    });
    add-method(RakuAST::Trait::Type, 'IMPL-TRAIT-ARGS', [RakuAST::Trait::Type, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::Node, '$target', 0, 0], anon sub IMPL-TRAIT-ARGS ($SELF_CONT, $resolver!, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $target := nqp::decont($target);
#line 177 src/Raku/ast/traits.rakumod
        
        RakuAST::ArgList.new($target, nqp::getattr($SELF, RakuAST::Trait::Type, '$!type'))
    
    });
    add-method(RakuAST::Trait::Type, 'visit-children', [RakuAST::Trait::Type, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 181 src/Raku/ast/traits.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Trait::Type, '$!type'));
    
    });
#line 169 src/Raku/ast/traits.rakumod
    add-method(RakuAST::Trait::Type, 'type', [], anon sub type ($self) { nqp::getattr(nqp::decont($self), RakuAST::Trait::Type, '$!type') });
    compose(RakuAST::Trait::Type);
    parent(RakuAST::Trait::Hides, RakuAST::Trait::Type);
    add-method(RakuAST::Trait::Hides, 'IMPL-TRAIT-NAME', [RakuAST::Trait::Hides, '', 0, 0], anon sub IMPL-TRAIT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 190 src/Raku/ast/traits.rakumod
         'hides' 
    });
    compose(RakuAST::Trait::Hides);
    parent(RakuAST::Trait::Does, RakuAST::Trait::Type);
    add-method(RakuAST::Trait::Does, 'IMPL-TRAIT-NAME', [RakuAST::Trait::Does, '', 0, 0], anon sub IMPL-TRAIT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 197 src/Raku/ast/traits.rakumod
         'does' 
    });
    compose(RakuAST::Trait::Does);
    parent(RakuAST::Trait::Of, RakuAST::Trait::Type);
    add-method(RakuAST::Trait::Of, 'IMPL-TRAIT-NAME', [RakuAST::Trait::Of, '', 0, 0], anon sub IMPL-TRAIT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 204 src/Raku/ast/traits.rakumod
         'of' 
    });
    compose(RakuAST::Trait::Of);
    parent(RakuAST::Trait::Returns, RakuAST::Trait::Type);
    add-method(RakuAST::Trait::Returns, 'IMPL-TRAIT-NAME', [RakuAST::Trait::Returns, '', 0, 0], anon sub IMPL-TRAIT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 211 src/Raku/ast/traits.rakumod
         'returns' 
    });
    compose(RakuAST::Trait::Returns);
    parent(RakuAST::Trait::Will, RakuAST::Trait);
    add-attribute(RakuAST::Trait::Will, str, '$!type');
    add-attribute(RakuAST::Trait::Will, RakuAST::Expression, '$!expr');
    add-method(RakuAST::Trait::Will, 'new', [RakuAST::Trait::Will, '', 0, 0, str, '$type', 0, 0, RakuAST::Expression, '$expr', 0, 0], anon sub new ($SELF_CONT, $type!, $expr!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
        $expr := nqp::decont($expr);
#line 221 src/Raku/ast/traits.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Trait::Will, '$!type', $type);
        nqp::bindattr($obj, RakuAST::Trait::Will, '$!expr', $expr);
        $obj
    
    });
    add-method(RakuAST::Trait::Will, 'IMPL-TRAIT-NAME', [RakuAST::Trait::Will, '', 0, 0], anon sub IMPL-TRAIT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 228 src/Raku/ast/traits.rakumod
         'will' 
    });
    add-method(RakuAST::Trait::Will, 'IMPL-TRAIT-ARGS', [RakuAST::Trait::Will, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::Node, '$target', 0, 0], anon sub IMPL-TRAIT-ARGS ($SELF_CONT, $resolver!, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $target := nqp::decont($target);
#line 230 src/Raku/ast/traits.rakumod
        
        RakuAST::ArgList.new($target, RakuAST::ColonPair::Value.new(:key(nqp::getattr_s($SELF, RakuAST::Trait::Will, '$!type')), :value(nqp::getattr($SELF, RakuAST::Trait::Will, '$!expr'))))
    
    });
    add-method(RakuAST::Trait::Will, 'visit-children', [RakuAST::Trait::Will, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 234 src/Raku/ast/traits.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Trait::Will, '$!expr'));
    
    });
#line 218 src/Raku/ast/traits.rakumod
    add-method(RakuAST::Trait::Will, 'type', [], anon sub type ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Trait::Will, '$!type') });
#line 219 src/Raku/ast/traits.rakumod
    add-method(RakuAST::Trait::Will, 'expr', [], anon sub expr ($self) { nqp::getattr(nqp::decont($self), RakuAST::Trait::Will, '$!expr') });
    compose(RakuAST::Trait::Will);
    parent(RakuAST::Trait::Handles, RakuAST::Trait);
    add-attribute(RakuAST::Trait::Handles, RakuAST::Term, '$!term');
    add-method(RakuAST::Trait::Handles, 'new', [RakuAST::Trait::Handles, '', 0, 0, RakuAST::Term, '$term', 0, 0], anon sub new ($SELF_CONT, $term!) {
        my $SELF := nqp::decont($SELF_CONT);
        $term := nqp::decont($term);
#line 244 src/Raku/ast/traits.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Trait::Handles, '$!term', $term);
        $obj
    
    });
    add-method(RakuAST::Trait::Handles, 'IMPL-TRAIT-NAME', [RakuAST::Trait::Handles, '', 0, 0], anon sub IMPL-TRAIT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 250 src/Raku/ast/traits.rakumod
         'handles' 
    });
    add-method(RakuAST::Trait::Handles, 'IMPL-TRAIT-ARGS', [RakuAST::Trait::Handles, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::Node, '$target', 0, 0], anon sub IMPL-TRAIT-ARGS ($SELF_CONT, $resolver!, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $target := nqp::decont($target);
#line 252 src/Raku/ast/traits.rakumod
        
        my $block := RakuAST::Block.new:
                        body => RakuAST::Blockoid.new:
                            RakuAST::StatementList.new:
                                RakuAST::Statement::Expression.new:
                                    expression => nqp::getattr($SELF, RakuAST::Trait::Handles, '$!term');
        RakuAST::ArgList.new($target, $block);
    
    });
    add-method(RakuAST::Trait::Handles, 'visit-children', [RakuAST::Trait::Handles, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 261 src/Raku/ast/traits.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Trait::Handles, '$!term'));
    
    });
#line 242 src/Raku/ast/traits.rakumod
    add-method(RakuAST::Trait::Handles, 'term', [], anon sub term ($self) { nqp::getattr(nqp::decont($self), RakuAST::Trait::Handles, '$!term') });
    compose(RakuAST::Trait::Handles);
    parent(RakuAST::Meta, RakuAST::CompileTimeValue);
    add-attribute(RakuAST::Meta, Mu, '$!cached-meta-object');
    add-attribute(RakuAST::Meta, Bool, '$!meta-object-produced');
    add-method(RakuAST::Meta, 'meta-object', [RakuAST::Meta, '', 0, 0], anon sub meta-object ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 11 src/Raku/ast/meta.rakumod
        
        unless nqp::getattr($SELF, RakuAST::Meta, '$!meta-object-produced') {
            nqp::bindattr($SELF, RakuAST::Meta, '$!cached-meta-object',
                $SELF.PRODUCE-META-OBJECT());
            nqp::bindattr($SELF, RakuAST::Meta, '$!meta-object-produced', (Bool.WHO)<True>);
        }
        nqp::getattr($SELF, RakuAST::Meta, '$!cached-meta-object')
    
    });
    add-method(RakuAST::Meta, 'has-meta-object', [RakuAST::Meta, '', 0, 0], anon sub has-meta-object ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 20 src/Raku/ast/meta.rakumod
        
        nqp::getattr($SELF, RakuAST::Meta, '$!meta-object-produced') || (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Meta, 'compile-time-value', [RakuAST::Meta, '', 0, 0], anon sub compile-time-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 24 src/Raku/ast/meta.rakumod
        
        $SELF.meta-object
    
    });
    compose(RakuAST::Meta);
    parent(RakuAST::StubbyMeta, RakuAST::Meta);
    add-attribute(RakuAST::StubbyMeta, Mu, '$!cached-stubbed-meta-object');
    add-attribute(RakuAST::StubbyMeta, Bool, '$!stubbed-meta-object-produced');
    add-method(RakuAST::StubbyMeta, 'stubbed-meta-object', [RakuAST::StubbyMeta, '', 0, 0], anon sub stubbed-meta-object ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 41 src/Raku/ast/meta.rakumod
        
        unless nqp::getattr($SELF, RakuAST::StubbyMeta, '$!stubbed-meta-object-produced') {
            nqp::bindattr($SELF, RakuAST::StubbyMeta, '$!cached-stubbed-meta-object',
                $SELF.PRODUCE-STUBBED-META-OBJECT());
            nqp::bindattr($SELF, RakuAST::StubbyMeta, '$!stubbed-meta-object-produced', (Bool.WHO)<True>);
        }
        nqp::getattr($SELF, RakuAST::StubbyMeta, '$!cached-stubbed-meta-object')
    
    });
    add-method(RakuAST::StubbyMeta, 'has-stubbed-meta-object', [RakuAST::StubbyMeta, '', 0, 0], anon sub has-stubbed-meta-object ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 50 src/Raku/ast/meta.rakumod
        
        nqp::getattr($SELF, RakuAST::StubbyMeta, '$!cached-stubbed-meta-object') || (Bool.WHO)<False>
    
    });
    add-method(RakuAST::StubbyMeta, 'meta-object', [RakuAST::StubbyMeta, '', 0, 0], anon sub meta-object ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 54 src/Raku/ast/meta.rakumod
        
        # Ensure we have the stubbed meta-object first, then delegate to our
        # parent to produce the full meta-object.
        $SELF.stubbed-meta-object();
        nqp::findmethod(RakuAST::Meta, 'meta-object')($SELF)
    
    });
    add-method(RakuAST::StubbyMeta, 'compile-time-value', [RakuAST::StubbyMeta, '', 0, 0], anon sub compile-time-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 61 src/Raku/ast/meta.rakumod
        
        $SELF.stubbed-meta-object
    
    });
    compose(RakuAST::StubbyMeta);
    parent(RakuAST::Doc, RakuAST::Node);
    add-method(RakuAST::Doc, 'must-define', [RakuAST::Doc, '', 0, 0, str, '$method', 0, 0], anon sub must-define ($SELF_CONT, $method!) {
        my $SELF := nqp::decont($SELF_CONT);
        $method := nqp::decont($method);
#line 5 src/Raku/ast/doc-block.rakumod
        
        nqp::die($SELF.HOW.name($SELF) ~ " must define a '$method' method");
    
    });
    add-method(RakuAST::Doc, 'cannot-be-instantiated', [RakuAST::Doc, '', 0, 0], anon sub cannot-be-instantiated ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 8 src/Raku/ast/doc-block.rakumod
        
        nqp::die($SELF.HOW.name($SELF) ~ " cannot be instantiated");
    
    });
    add-method(RakuAST::Doc, 'new', [RakuAST::Doc, '', 0, 0, Any, '@_', 0, 0, Any, '%_', 0, 0], anon sub new ($SELF_CONT, *@_, *%_) {
        my $SELF := nqp::decont($SELF_CONT);
        @_ := nqp::decont(@_);
        %_ := nqp::decont(%_);
#line 12 src/Raku/ast/doc-block.rakumod
         $SELF.cannot-be-instantiated 
    });
    add-method(RakuAST::Doc, 'visit-children', [RakuAST::Doc, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 13 src/Raku/ast/doc-block.rakumod
         $SELF.must-define("visit-children") 
    });
    compose(RakuAST::Doc);
    parent(RakuAST::Doc::Paragraph, RakuAST::Doc);
    add-attribute(RakuAST::Doc::Paragraph, List, '$!atoms');
    add-method(RakuAST::Doc::Paragraph, 'new', [RakuAST::Doc::Paragraph, '', 0, 0, Any, '@atoms', 0, 0], anon sub new ($SELF_CONT, *@atoms) {
        my $SELF := nqp::decont($SELF_CONT);
        @atoms := nqp::decont(@atoms);
#line 22 src/Raku/ast/doc-block.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Doc::Paragraph, '$!atoms', @atoms);
        $obj
    
    });
    add-method(RakuAST::Doc::Paragraph, 'visit-children', [RakuAST::Doc::Paragraph, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 28 src/Raku/ast/doc-block.rakumod
        
        for nqp::getattr($SELF, RakuAST::Doc::Paragraph, '$!atoms') {
            if nqp::istype($_,RakuAST::Node) {
                $visitor($_);
            }
        }
    
    });
    add-method(RakuAST::Doc::Paragraph, 'add-atom', [RakuAST::Doc::Paragraph, '', 0, 0, Any, '$atom', 0, 0], anon sub add-atom ($SELF_CONT, $atom!) {
        my $SELF := nqp::decont($SELF_CONT);
        $atom := nqp::decont($atom);
#line 36 src/Raku/ast/doc-block.rakumod
         nqp::push(nqp::getattr($SELF, RakuAST::Doc::Paragraph, '$!atoms'), $atom) 
    });
    add-method(RakuAST::Doc::Paragraph, 'atoms', [RakuAST::Doc::Paragraph, '', 0, 0], anon sub atoms ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 37 src/Raku/ast/doc-block.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Doc::Paragraph, '$!atoms')) 
    });
    compose(RakuAST::Doc::Paragraph);
    parent(RakuAST::Doc::Block, RakuAST::Doc);
    parent(RakuAST::Doc::Block, RakuAST::CheckTime);
    add-attribute(RakuAST::Doc::Block, str, '$!margin');
    add-attribute(RakuAST::Doc::Block, str, '$!type');
    add-attribute(RakuAST::Doc::Block, int, '$!level');
    add-attribute(RakuAST::Doc::Block, Hash, '$!config');
    add-attribute(RakuAST::Doc::Block, List, '$!paragraphs');
    add-attribute(RakuAST::Doc::Block, int, '$!status');
    add-attribute(RakuAST::Doc::Block, int, '$!pod-index');
    add-attribute(RakuAST::Doc::Block, Mu, '$!resolved-config');
    add-method(RakuAST::Doc::Block, 'new', [RakuAST::Doc::Block, '', 0, 0, Str, '$margin', 1, 1, Str, '$type', 1, 0, Int, '$level', 1, 1, Hash, '$config', 1, 1, List, '$paragraphs', 1, 1, Bool, '$directive', 1, 1, Bool, '$for', 1, 1, Bool, '$abbreviated', 1, 1], anon sub new ($SELF_CONT, :$margin?, :$type!, :$level?, :$config?, :$paragraphs?, :$directive?, :$for?, :$abbreviated?) {
        my $SELF := nqp::decont($SELF_CONT);
        $margin := nqp::decont($margin);
        $type := nqp::decont($type);
        $level := nqp::decont($level);
        $config := nqp::decont($config);
        $paragraphs := nqp::decont($paragraphs);
        $directive := nqp::decont($directive);
        $for := nqp::decont($for);
        $abbreviated := nqp::decont($abbreviated);
#line 62 src/Raku/ast/doc-block.rakumod
        
        my $obj := nqp::create($SELF);
        $obj.set-margin($margin);
        $obj.set-type($type);
        $obj.set-level($level);
        $obj.set-config($config);
        $obj.set-paragraphs($paragraphs);

        my int $status :=
          $directive ?? 3 !! $abbreviated ?? 2 !! $for ?? 1 !! 0;
        nqp::bindattr_i($obj,RakuAST::Doc::Block,'$!status',$status);

        if nqp::isconcrete($*LEGACY-POD-INDEX) {
            nqp::bindattr_i($obj,RakuAST::Doc::Block,
              '$!pod-index', $*LEGACY-POD-INDEX++);
        }
        else {
            nqp::bindattr_i($obj,RakuAST::Doc::Block,'$!pod-index',-1);
        }
        $obj
    
    });
    add-method(RakuAST::Doc::Block, 'set-margin', [RakuAST::Doc::Block, '', 0, 0, Str, '$margin', 0, 0], anon sub set-margin ($SELF_CONT, $margin!) {
        my $SELF := nqp::decont($SELF_CONT);
        $margin := nqp::decont($margin);
#line 84 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr_s($SELF, RakuAST::Doc::Block, '$!margin', $margin // "");
        Nil
    
    });
    add-method(RakuAST::Doc::Block, 'set-type', [RakuAST::Doc::Block, '', 0, 0, Str, '$type', 0, 0], anon sub set-type ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 89 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr_s($SELF, RakuAST::Doc::Block, '$!type',
          $type // nqp::die("Must specify a type"));
        Nil
    
    });
    add-method(RakuAST::Doc::Block, 'set-level', [RakuAST::Doc::Block, '', 0, 0, Int, '$level', 0, 0], anon sub set-level ($SELF_CONT, $level!) {
        my $SELF := nqp::decont($SELF_CONT);
        $level := nqp::decont($level);
#line 95 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::Doc::Block, '$!level', $level // 0);
        Nil
    
    });
    add-method(RakuAST::Doc::Block, 'level', [RakuAST::Doc::Block, '', 0, 0], anon sub level ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 99 src/Raku/ast/doc-block.rakumod
         nqp::getattr_i($SELF, RakuAST::Doc::Block, '$!level') ?? ~nqp::getattr_i($SELF, RakuAST::Doc::Block, '$!level') !! "" 
    });
    add-method(RakuAST::Doc::Block, 'set-config', [RakuAST::Doc::Block, '', 0, 0, Any, '$config', 0, 0], anon sub set-config ($SELF_CONT, $config!) {
        my $SELF := nqp::decont($SELF_CONT);
        $config := nqp::decont($config);
#line 101 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr($SELF, RakuAST::Doc::Block, '$!config',
          $config ?? $SELF.IMPL-UNWRAP-MAP($config) !! nqp::hash);
        Nil
    
    });
    add-method(RakuAST::Doc::Block, 'add-config', [RakuAST::Doc::Block, '', 0, 0, Str, '$key', 0, 0, Any, '$value', 0, 0], anon sub add-config ($SELF_CONT, $key!, $value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
        $value := nqp::decont($value);
#line 106 src/Raku/ast/doc-block.rakumod
        
        nqp::bindkey(nqp::getattr($SELF, RakuAST::Doc::Block, '$!config'), $key, $value)
    
    });
    add-method(RakuAST::Doc::Block, 'config', [RakuAST::Doc::Block, '', 0, 0], anon sub config ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 109 src/Raku/ast/doc-block.rakumod
         $SELF.IMPL-WRAP-MAP(nqp::getattr($SELF, RakuAST::Doc::Block, '$!config')) 
    });
    add-method(RakuAST::Doc::Block, 'set-paragraphs', [RakuAST::Doc::Block, '', 0, 0, Any, '$paragraphs', 0, 0], anon sub set-paragraphs ($SELF_CONT, $paragraphs!) {
        my $SELF := nqp::decont($SELF_CONT);
        $paragraphs := nqp::decont($paragraphs);
#line 111 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr($SELF, RakuAST::Doc::Block, '$!paragraphs',
          $paragraphs
            ?? $SELF.IMPL-UNWRAP-LIST($paragraphs)
            !! nqp::list);
        Nil
    
    });
    add-method(RakuAST::Doc::Block, 'add-paragraph', [RakuAST::Doc::Block, '', 0, 0, Any, '$paragraph', 0, 0, Any, '$at-start', 1, 1], anon sub add-paragraph ($SELF_CONT, $paragraph!, :$at-start?) {
        my $SELF := nqp::decont($SELF_CONT);
        $paragraph := nqp::decont($paragraph);
        $at-start := nqp::decont($at-start);
#line 118 src/Raku/ast/doc-block.rakumod
        
        $at-start
          ?? nqp::unshift(nqp::getattr($SELF, RakuAST::Doc::Block, '$!paragraphs'), $paragraph)
          !! nqp::push(   nqp::getattr($SELF, RakuAST::Doc::Block, '$!paragraphs'), $paragraph)
    
    });
    add-method(RakuAST::Doc::Block, 'paragraphs', [RakuAST::Doc::Block, '', 0, 0], anon sub paragraphs ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 123 src/Raku/ast/doc-block.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Doc::Block, '$!paragraphs')) 
    });
    add-method(RakuAST::Doc::Block, 'delimited', [RakuAST::Doc::Block, '', 0, 0], anon sub delimited ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 125 src/Raku/ast/doc-block.rakumod
         nqp::getattr_i($SELF, RakuAST::Doc::Block, '$!status') == 0 
    });
    add-method(RakuAST::Doc::Block, 'for', [RakuAST::Doc::Block, '', 0, 0], anon sub for ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 126 src/Raku/ast/doc-block.rakumod
         nqp::getattr_i($SELF, RakuAST::Doc::Block, '$!status') == 1 
    });
    add-method(RakuAST::Doc::Block, 'abbreviated', [RakuAST::Doc::Block, '', 0, 0], anon sub abbreviated ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 127 src/Raku/ast/doc-block.rakumod
         nqp::getattr_i($SELF, RakuAST::Doc::Block, '$!status') >= 2 
    });
    add-method(RakuAST::Doc::Block, 'directive', [RakuAST::Doc::Block, '', 0, 0], anon sub directive ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 128 src/Raku/ast/doc-block.rakumod
         nqp::getattr_i($SELF, RakuAST::Doc::Block, '$!status') == 3 
    });
    add-method(RakuAST::Doc::Block, 'visit-children', [RakuAST::Doc::Block, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 130 src/Raku/ast/doc-block.rakumod
        
        for nqp::getattr($SELF, RakuAST::Doc::Block, '$!paragraphs') {
            if nqp::istype($_,RakuAST::Doc::Block) {
                my $*INNER-BLOCK := (Bool.WHO)<True>;
                $visitor($_);
            }
            elsif nqp::istype($_,RakuAST::Node) {
                $visitor($_);
            }
        }
    
    });
    add-method(RakuAST::Doc::Block, 'PERFORM-CHECK', [RakuAST::Doc::Block, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 145 src/Raku/ast/doc-block.rakumod
        
        my $failed := $SELF.literalize-config;
        if nqp::eqaddr($failed,RakuAST::Node::CannotLiteralize) {
            $SELF.add-sorry:
              $resolver.build-exception: 'X::AdHoc',
                payload => "'$failed' is not constant in configuration";
        }

        # in an outermost block
        unless $*INNER-BLOCK {
            my $cu := $resolver.find-attach-target('compunit');
            if nqp::getattr_s($SELF, RakuAST::Doc::Block, '$!type') eq 'data' {
                my $store := $cu.data-content;
                my $data  := $SELF.Str.trim-trailing;

                (my $key := nqp::getattr($SELF, RakuAST::Doc::Block, '$!config')<key>)
                  ?? $store.ASSIGN-KEY($key, $data)
                  !! $store.push($data);
            }
            $cu.set-pod-content(nqp::getattr_i($SELF, RakuAST::Doc::Block, '$!pod-index'), $SELF.podify);
        }

        (Bool.WHO)<True>
    
    });
#line 46 src/Raku/ast/doc-block.rakumod
    add-method(RakuAST::Doc::Block, 'type', [], anon sub type ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Doc::Block, '$!type') });
#line 45 src/Raku/ast/doc-block.rakumod
    add-method(RakuAST::Doc::Block, 'margin', [], anon sub margin ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Doc::Block, '$!margin') });
    compose(RakuAST::Doc::Block);
    parent(RakuAST::Doc::Markup, RakuAST::Doc);
    add-attribute(RakuAST::Doc::Markup, str, '$!letter');
    add-attribute(RakuAST::Doc::Markup, str, '$!opener');
    add-attribute(RakuAST::Doc::Markup, str, '$!closer');
    add-attribute(RakuAST::Doc::Markup, List, '$!atoms');
    add-attribute(RakuAST::Doc::Markup, List, '$!meta');
    add-method(RakuAST::Doc::Markup, 'new', [RakuAST::Doc::Markup, '', 0, 0, Any, '$letter', 1, 0, Any, '$opener', 1, 1, Any, '$closer', 1, 1, Any, '$atoms', 1, 1, Any, '$meta', 1, 1], anon sub new ($SELF_CONT, :$letter!, :$opener?, :$closer?, :$atoms?, :$meta?) {
        my $SELF := nqp::decont($SELF_CONT);
        $letter := nqp::decont($letter);
        $opener := nqp::decont($opener);
        $closer := nqp::decont($closer);
        $atoms := nqp::decont($atoms);
        $meta := nqp::decont($meta);
#line 181 src/Raku/ast/doc-block.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Doc::Markup, '$!letter',
          $letter // nqp::die("Must specify a letter"));

        $obj.set-opener($opener // '<');
        $obj.set-closer($closer // '>');
        $obj.set-atoms($atoms);
        $obj.set-meta($meta);
        $obj
    
    });
    add-method(RakuAST::Doc::Markup, 'visit-children', [RakuAST::Doc::Markup, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 193 src/Raku/ast/doc-block.rakumod
        
        for nqp::getattr($SELF, RakuAST::Doc::Markup, '$!atoms') {
            if nqp::istype($_,RakuAST::Node) {
                $visitor($_);
            }
        }
        for nqp::getattr($SELF, RakuAST::Doc::Markup, '$!meta') {
            if nqp::istype($_,RakuAST::Node) {
                $visitor($_);
            }
        }
    
    });
    add-method(RakuAST::Doc::Markup, 'set-opener', [RakuAST::Doc::Markup, '', 0, 0, str, '$opener', 0, 0], anon sub set-opener ($SELF_CONT, $opener!) {
        my $SELF := nqp::decont($SELF_CONT);
        $opener := nqp::decont($opener);
#line 206 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr_s($SELF,RakuAST::Doc::Markup,'$!opener',$opener);
        Nil
    
    });
    add-method(RakuAST::Doc::Markup, 'set-closer', [RakuAST::Doc::Markup, '', 0, 0, str, '$closer', 0, 0], anon sub set-closer ($SELF_CONT, $closer!) {
        my $SELF := nqp::decont($SELF_CONT);
        $closer := nqp::decont($closer);
#line 211 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr_s($SELF,RakuAST::Doc::Markup,'$!closer',$closer);
        Nil
    
    });
    add-method(RakuAST::Doc::Markup, 'set-atoms', [RakuAST::Doc::Markup, '', 0, 0, Any, '$atoms', 0, 1], anon sub set-atoms ($SELF_CONT, $atoms?) {
        my $SELF := nqp::decont($SELF_CONT);
        $atoms := nqp::decont($atoms);
#line 216 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr($SELF, RakuAST::Doc::Markup, '$!atoms',
          $atoms ?? $SELF.IMPL-UNWRAP-LIST($atoms) !! []);
        Nil
    
    });
    add-method(RakuAST::Doc::Markup, 'add-atom', [RakuAST::Doc::Markup, '', 0, 0, Any, '$atom', 0, 0], anon sub add-atom ($SELF_CONT, $atom!) {
        my $SELF := nqp::decont($SELF_CONT);
        $atom := nqp::decont($atom);
#line 221 src/Raku/ast/doc-block.rakumod
         nqp::push(nqp::getattr($SELF, RakuAST::Doc::Markup, '$!atoms'), $atom) 
    });
    add-method(RakuAST::Doc::Markup, 'atoms', [RakuAST::Doc::Markup, '', 0, 0], anon sub atoms ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 222 src/Raku/ast/doc-block.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Doc::Markup, '$!atoms')) 
    });
    add-method(RakuAST::Doc::Markup, 'set-meta', [RakuAST::Doc::Markup, '', 0, 0, Any, '$meta', 0, 1], anon sub set-meta ($SELF_CONT, $meta?) {
        my $SELF := nqp::decont($SELF_CONT);
        $meta := nqp::decont($meta);
#line 224 src/Raku/ast/doc-block.rakumod
        
        nqp::bindattr($SELF, RakuAST::Doc::Markup, '$!meta',
          $meta ?? $SELF.IMPL-UNWRAP-LIST($meta) !! []);
        Nil
    
    });
    add-method(RakuAST::Doc::Markup, 'add-meta', [RakuAST::Doc::Markup, '', 0, 0, Any, '$meta', 0, 0], anon sub add-meta ($SELF_CONT, $meta!) {
        my $SELF := nqp::decont($SELF_CONT);
        $meta := nqp::decont($meta);
#line 229 src/Raku/ast/doc-block.rakumod
         nqp::push(nqp::getattr($SELF, RakuAST::Doc::Markup, '$!meta'), $meta) 
    });
    add-method(RakuAST::Doc::Markup, 'meta', [RakuAST::Doc::Markup, '', 0, 0], anon sub meta ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 230 src/Raku/ast/doc-block.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Doc::Markup, '$!meta')) 
    });
#line 176 src/Raku/ast/doc-block.rakumod
    add-method(RakuAST::Doc::Markup, 'opener', [], anon sub opener ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Doc::Markup, '$!opener') });
#line 175 src/Raku/ast/doc-block.rakumod
    add-method(RakuAST::Doc::Markup, 'letter', [], anon sub letter ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Doc::Markup, '$!letter') });
#line 177 src/Raku/ast/doc-block.rakumod
    add-method(RakuAST::Doc::Markup, 'closer', [], anon sub closer ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Doc::Markup, '$!closer') });
    compose(RakuAST::Doc::Markup);
    parent(RakuAST::Doc::Declarator, RakuAST::Doc);
    parent(RakuAST::Doc::Declarator, RakuAST::CheckTime);
    add-attribute(RakuAST::Doc::Declarator, RakuAST::Doc::DeclaratorTarget, '$!WHEREFORE');
    add-attribute(RakuAST::Doc::Declarator, List, '$!leading');
    add-attribute(RakuAST::Doc::Declarator, List, '$!trailing');
    add-attribute(RakuAST::Doc::Declarator, int, '$!pod-index');
    add-attribute(RakuAST::Doc::Declarator, List, '$!paragraphs');
    add-method(RakuAST::Doc::Declarator, 'new', [RakuAST::Doc::Declarator, '', 0, 0, Any, '$WHEREFORE', 1, 1, Any, '$leading', 1, 1, Any, '$trailing', 1, 1], anon sub new ($SELF_CONT, :$WHEREFORE?, :$leading?, :$trailing?) {
        my $SELF := nqp::decont($SELF_CONT);
        $WHEREFORE := nqp::decont($WHEREFORE);
        $leading := nqp::decont($leading);
        $trailing := nqp::decont($trailing);
#line 12 src/Raku/ast/doc-declarator.rakumod
        
        my $obj := nqp::create($SELF);
        $obj.set-WHEREFORE($WHEREFORE);
        $obj.set-leading($leading);
        $obj.set-trailing($trailing);

        if nqp::isconcrete($*LEGACY-POD-INDEX) {
            nqp::bindattr_i($obj,RakuAST::Doc::Declarator, 
              '$!pod-index', $*LEGACY-POD-INDEX++);
        }
        else {
            nqp::bindattr_i($obj,RakuAST::Doc::Declarator,'$!pod-index',-1);
        }

        $obj
    
    });
    add-method(RakuAST::Doc::Declarator, 'visit-children', [RakuAST::Doc::Declarator, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 28 src/Raku/ast/doc-declarator.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Doc::Declarator, '$!WHEREFORE')) unless nqp::eqaddr(nqp::getattr($SELF, RakuAST::Doc::Declarator, '$!WHEREFORE').WHY,$SELF);
    
    });
    add-method(RakuAST::Doc::Declarator, 'set-WHEREFORE', [RakuAST::Doc::Declarator, '', 0, 0, Mu, '$WHEREFORE', 0, 0], anon sub set-WHEREFORE ($SELF_CONT, $WHEREFORE!) {
        my $SELF := nqp::decont($SELF_CONT);
        $WHEREFORE := nqp::decont($WHEREFORE);
#line 32 src/Raku/ast/doc-declarator.rakumod
        
        nqp::bindattr($SELF, RakuAST::Doc::Declarator, '$!WHEREFORE',
          $WHEREFORE);
        Nil
    
    });
    add-method(RakuAST::Doc::Declarator, 'set-leading', [RakuAST::Doc::Declarator, '', 0, 0, Any, '$leading', 0, 0], anon sub set-leading ($SELF_CONT, $leading!) {
        my $SELF := nqp::decont($SELF_CONT);
        $leading := nqp::decont($leading);
#line 38 src/Raku/ast/doc-declarator.rakumod
        
        nqp::bindattr($SELF, RakuAST::Doc::Declarator, '$!leading',
          $leading ?? $SELF.IMPL-UNWRAP-LIST($leading) !! []);
        Nil
    
    });
    add-method(RakuAST::Doc::Declarator, 'add-leading', [RakuAST::Doc::Declarator, '', 0, 0, Any, '$doc', 0, 0], anon sub add-leading ($SELF_CONT, $doc!) {
        my $SELF := nqp::decont($SELF_CONT);
        $doc := nqp::decont($doc);
#line 43 src/Raku/ast/doc-declarator.rakumod
         nqp::push(nqp::getattr($SELF, RakuAST::Doc::Declarator, '$!leading'), $doc) 
    });
    add-method(RakuAST::Doc::Declarator, 'leading', [RakuAST::Doc::Declarator, '', 0, 0], anon sub leading ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 44 src/Raku/ast/doc-declarator.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Doc::Declarator, '$!leading'))  
    });
    add-method(RakuAST::Doc::Declarator, 'set-trailing', [RakuAST::Doc::Declarator, '', 0, 0, Any, '$trailing', 0, 0], anon sub set-trailing ($SELF_CONT, $trailing!) {
        my $SELF := nqp::decont($SELF_CONT);
        $trailing := nqp::decont($trailing);
#line 46 src/Raku/ast/doc-declarator.rakumod
        
        nqp::bindattr($SELF, RakuAST::Doc::Declarator, '$!trailing',
          $trailing ?? $SELF.IMPL-UNWRAP-LIST($trailing) !! []);
        Nil
    
    });
    add-method(RakuAST::Doc::Declarator, 'add-trailing', [RakuAST::Doc::Declarator, '', 0, 0, Any, '$doc', 0, 0], anon sub add-trailing ($SELF_CONT, $doc!) {
        my $SELF := nqp::decont($SELF_CONT);
        $doc := nqp::decont($doc);
#line 51 src/Raku/ast/doc-declarator.rakumod
         nqp::push(nqp::getattr($SELF, RakuAST::Doc::Declarator, '$!trailing'), $doc) 
    });
    add-method(RakuAST::Doc::Declarator, 'trailing', [RakuAST::Doc::Declarator, '', 0, 0], anon sub trailing ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 52 src/Raku/ast/doc-declarator.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Doc::Declarator, '$!trailing')) 
    });
    add-method(RakuAST::Doc::Declarator, 'PERFORM-CHECK', [RakuAST::Doc::Declarator, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 55 src/Raku/ast/doc-declarator.rakumod
        
        if nqp::getattr($SELF, RakuAST::Doc::Declarator, '$!WHEREFORE') {
            my $meta := nqp::getattr($SELF, RakuAST::Doc::Declarator, '$!WHEREFORE').meta-object;
            if $meta.HOW.name($meta) ne 'Any' {
                $resolver.find-attach-target('compunit').set-pod-content(
                  nqp::getattr_i($SELF, RakuAST::Doc::Declarator, '$!pod-index'), $SELF.podify($meta)
                );
            }
        }
        else {
            $SELF.add-worry: $resolver.build-exception:
              'X::Syntax::Doc::Declarator::MissingDeclarand';
        }
        (Bool.WHO)<True>
    
    });
#line 6 src/Raku/ast/doc-declarator.rakumod
    add-method(RakuAST::Doc::Declarator, 'WHEREFORE', [], anon sub WHEREFORE ($self) { nqp::getattr(nqp::decont($self), RakuAST::Doc::Declarator, '$!WHEREFORE') });
    compose(RakuAST::Doc::Declarator);
    parent(RakuAST::Doc::DeclaratorTarget, Any);
    add-attribute(RakuAST::Doc::DeclaratorTarget, RakuAST::Doc::Declarator, '$!WHY');
    add-method(RakuAST::Doc::DeclaratorTarget, 'declarator-docs', [RakuAST::Doc::DeclaratorTarget, '', 0, 0, Any, '$leading', 1, 1, Any, '$trailing', 1, 1], anon sub declarator-docs ($SELF_CONT, :$leading?, :$trailing?) {
        my $SELF := nqp::decont($SELF_CONT);
        $leading := nqp::decont($leading);
        $trailing := nqp::decont($trailing);
#line 78 src/Raku/ast/doc-declarator.rakumod
        
        nqp::bindattr($SELF, RakuAST::Doc::DeclaratorTarget, '$!WHY',
          RakuAST::Doc::Declarator.new(:WHEREFORE($SELF), :$leading, :$trailing)
        );
        $SELF
    
    });
    add-method(RakuAST::Doc::DeclaratorTarget, 'set-WHY', [RakuAST::Doc::DeclaratorTarget, '', 0, 0, RakuAST::Doc::Declarator, '$WHY', 0, 0], anon sub set-WHY ($SELF_CONT, $WHY!) {
        my $SELF := nqp::decont($SELF_CONT);
        $WHY := nqp::decont($WHY);
#line 85 src/Raku/ast/doc-declarator.rakumod
        
        if $WHY {
            nqp::bindattr($SELF, RakuAST::Doc::DeclaratorTarget, '$!WHY', $WHY);
            $WHY.set-WHEREFORE($SELF);
        }
        Nil
    
    });
    add-method(RakuAST::Doc::DeclaratorTarget, 'cut-WHY', [RakuAST::Doc::DeclaratorTarget, '', 0, 0], anon sub cut-WHY ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 93 src/Raku/ast/doc-declarator.rakumod
        
        my $WHY := nqp::getattr($SELF,RakuAST::Doc::DeclaratorTarget,'$!WHY');
        nqp::bindattr($SELF,RakuAST::Doc::DeclaratorTarget,'$!WHY',
          RakuAST::Doc::Declarator);
        $WHY
    
    });
    add-method(RakuAST::Doc::DeclaratorTarget, 'set-leading', [RakuAST::Doc::DeclaratorTarget, '', 0, 0, Any, '$doc', 0, 0], anon sub set-leading ($SELF_CONT, $doc!) {
        my $SELF := nqp::decont($SELF_CONT);
        $doc := nqp::decont($doc);
#line 100 src/Raku/ast/doc-declarator.rakumod
        
        (my $WHY := $SELF.WHY)
          ?? $WHY.set-leading($doc)
          !! $SELF.set-WHY(RakuAST::Doc::Declarator.new(
               WHEREFORE => $SELF, leading => $doc
             ));
        Nil
    
    });
    add-method(RakuAST::Doc::DeclaratorTarget, 'add-leading', [RakuAST::Doc::DeclaratorTarget, '', 0, 0, Any, '$doc', 0, 0], anon sub add-leading ($SELF_CONT, $doc!) {
        my $SELF := nqp::decont($SELF_CONT);
        $doc := nqp::decont($doc);
#line 109 src/Raku/ast/doc-declarator.rakumod
        
        (my $WHY := $SELF.WHY)
          ?? $WHY.add-leading($doc)
          !! $SELF.set-WHY(RakuAST::Doc::Declarator.new(
               WHEREFORE => $SELF, leading => $doc
             ));
        Nil
    
    });
    add-method(RakuAST::Doc::DeclaratorTarget, 'set-trailing', [RakuAST::Doc::DeclaratorTarget, '', 0, 0, Any, '$doc', 0, 0], anon sub set-trailing ($SELF_CONT, $doc!) {
        my $SELF := nqp::decont($SELF_CONT);
        $doc := nqp::decont($doc);
#line 118 src/Raku/ast/doc-declarator.rakumod
        
        (my $WHY := $SELF.WHY)
          ?? $WHY.set-trailing($doc)
          !! $SELF.set-WHY(RakuAST::Doc::Declarator.new(
               WHEREFORE => $SELF, trailing => $doc
             ));
        Nil
    
    });
    add-method(RakuAST::Doc::DeclaratorTarget, 'add-trailing', [RakuAST::Doc::DeclaratorTarget, '', 0, 0, Any, '$doc', 0, 0], anon sub add-trailing ($SELF_CONT, $doc!) {
        my $SELF := nqp::decont($SELF_CONT);
        $doc := nqp::decont($doc);
#line 127 src/Raku/ast/doc-declarator.rakumod
        
        (my $WHY := $SELF.WHY)
          ?? $WHY.add-trailing($doc)
          !! $SELF.set-WHY(RakuAST::Doc::Declarator.new(
               WHEREFORE => $SELF, trailing => $doc
             ));
        Nil
    
    });
#line 74 src/Raku/ast/doc-declarator.rakumod
    add-method(RakuAST::Doc::DeclaratorTarget, 'WHY', [], anon sub WHY ($self) { nqp::getattr(nqp::decont($self), RakuAST::Doc::DeclaratorTarget, '$!WHY') });
    compose(RakuAST::Doc::DeclaratorTarget);
    parent(RakuAST::Blorst, RakuAST::Node);
    add-method(RakuAST::Blorst, 'as-block', [RakuAST::Blorst, '', 0, 0], anon sub as-block ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 6 src/Raku/ast/statements.rakumod
        
        nqp::die("RakuAST::Blorst classes must define 'as-block'. " ~ $SELF.HOW.name($SELF) ~ " does not.")
    
    });
    compose(RakuAST::Blorst);
    parent(RakuAST::Contextualizable, RakuAST::Node);
    compose(RakuAST::Contextualizable);
    parent(RakuAST::Label, RakuAST::Declaration);
    parent(RakuAST::Label, RakuAST::ImplicitLookups);
    parent(RakuAST::Label, RakuAST::Meta);
    add-attribute(RakuAST::Label, str, '$!name');
    add-method(RakuAST::Label, 'new', [RakuAST::Label, '', 0, 0, str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 24 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Label, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Label, 'default-scope', [RakuAST::Label, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 30 src/Raku/ast/statements.rakumod
         'my' 
    });
    add-method(RakuAST::Label, 'allowed-scopes', [RakuAST::Label, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 32 src/Raku/ast/statements.rakumod
         ['my'] 
    });
    add-method(RakuAST::Label, 'lexical-name', [RakuAST::Label, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 34 src/Raku/ast/statements.rakumod
         nqp::getattr_s($SELF, RakuAST::Label, '$!name') 
    });
    add-method(RakuAST::Label, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Label, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 36 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Label')),
        ])
    
    });
    add-method(RakuAST::Label, 'PRODUCE-META-OBJECT', [RakuAST::Label, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 42 src/Raku/ast/statements.rakumod
        
        my $label-type :=
          $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
        # TODO line, prematch, postmatch
        $label-type.new(:name(nqp::getattr_s($SELF, RakuAST::Label, '$!name')), :line(0), :prematch(''), :postmatch(''))
    
    });
    add-method(RakuAST::Label, 'IMPL-QAST-DECL', [RakuAST::Label, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 49 src/Raku/ast/statements.rakumod
        
        QAST::Var.new(
            :scope('lexical'), :decl('static'), :name(nqp::getattr_s($SELF, RakuAST::Label, '$!name')),
            :value($SELF.meta-object)
        )
    
    });
    add-method(RakuAST::Label, 'IMPL-LOOKUP-QAST', [RakuAST::Label, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 56 src/Raku/ast/statements.rakumod
        
        my $label := $SELF.meta-object;
        $context.ensure-sc($label);
        QAST::WVal.new( :value($label) )
    
    });
#line 22 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Label, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Label, '$!name') });
    compose(RakuAST::Label);
    parent(RakuAST::Statement, RakuAST::Blorst);
    add-attribute(RakuAST::Statement, Mu, '$!labels');
    add-attribute(RakuAST::Statement, int, '$!trace');
    add-attribute(RakuAST::Statement, int, '$!statement-id');
    add-attribute(RakuAST::Statement, Mu, '$!doc-blocks');
    add-method(RakuAST::Statement, 'set-labels', [RakuAST::Statement, '', 0, 0, List, '$labels', 0, 0], anon sub set-labels ($SELF_CONT, $labels!) {
        my $SELF := nqp::decont($SELF_CONT);
        $labels := nqp::decont($labels);
#line 76 src/Raku/ast/statements.rakumod
        
        nqp::bindattr($SELF, RakuAST::Statement, '$!labels',
          $labels ?? $SELF.IMPL-UNWRAP-LIST($labels) !! []);
        Nil
    
    });
    add-method(RakuAST::Statement, 'add-label', [RakuAST::Statement, '', 0, 0, RakuAST::Label, '$label', 0, 0], anon sub add-label ($SELF_CONT, $label!) {
        my $SELF := nqp::decont($SELF_CONT);
        $label := nqp::decont($label);
#line 81 src/Raku/ast/statements.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Statement, '$!labels'), $label);
        Nil
    
    });
    add-method(RakuAST::Statement, 'labels', [RakuAST::Statement, '', 0, 0], anon sub labels ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 85 src/Raku/ast/statements.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Statement, '$!labels')) 
    });
    add-method(RakuAST::Statement, 'attach-doc-blocks', [RakuAST::Statement, '', 0, 0], anon sub attach-doc-blocks ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 88 src/Raku/ast/statements.rakumod
        
        my @collected := $*DOC-BLOCKS-COLLECTED;
        if nqp::elems(@collected) {
            nqp::bindattr($SELF, RakuAST::Statement, '$!doc-blocks', @collected);
            $*DOC-BLOCKS-COLLECTED := [];
        }
    
    });
    add-method(RakuAST::Statement, 'add-to-statements', [RakuAST::Statement, '', 0, 0, Any, '$statements', 0, 0], anon sub add-to-statements ($SELF_CONT, $statements!) {
        my $SELF := nqp::decont($SELF_CONT);
        $statements := nqp::decont($statements);
#line 98 src/Raku/ast/statements.rakumod
        
        if nqp::getattr($SELF, RakuAST::Statement, '$!doc-blocks') {
            for nqp::getattr($SELF, RakuAST::Statement, '$!doc-blocks') {
                $statements.add-doc-block($_);
            }
        }
        $statements.add-statement($SELF);
        Nil
    
    });
    add-method(RakuAST::Statement, 'set-statement-id', [RakuAST::Statement, '', 0, 0, int, '$statement-id', 0, 0], anon sub set-statement-id ($SELF_CONT, $statement-id!) {
        my $SELF := nqp::decont($SELF_CONT);
        $statement-id := nqp::decont($statement-id);
#line 108 src/Raku/ast/statements.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::Statement, '$!statement-id', $statement-id);
    
    });
    add-method(RakuAST::Statement, 'set-trace', [RakuAST::Statement, '', 0, 0, Bool, '$trace', 0, 0], anon sub set-trace ($SELF_CONT, $trace!) {
        my $SELF := nqp::decont($SELF_CONT);
        $trace := nqp::decont($trace);
#line 112 src/Raku/ast/statements.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::Statement, '$!trace', $trace ?? 1 !! 0);
    
    });
    add-method(RakuAST::Statement, 'visit-labels', [RakuAST::Statement, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-labels ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 116 src/Raku/ast/statements.rakumod
        
        for nqp::getattr($SELF, RakuAST::Statement, '$!labels') {
            $visitor($_);
        }
        Nil
    
    });
    add-method(RakuAST::Statement, 'IMPL-DISCARD-RESULT', [RakuAST::Statement, '', 0, 0], anon sub IMPL-DISCARD-RESULT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 123 src/Raku/ast/statements.rakumod
        
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Statement, 'IMPL-WRAP-WHEN-OR-DEFAULT', [RakuAST::Statement, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$qast', 0, 0], anon sub IMPL-WRAP-WHEN-OR-DEFAULT ($SELF_CONT, $context!, $qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $qast := nqp::decont($qast);
#line 127 src/Raku/ast/statements.rakumod
        
        my $succeed-qast := QAST::Op.new( :op('call'), :name('&succeed'), $qast );
        QAST::Op.new(
            :op('handle'),
            $succeed-qast,
            'PROCEED',
            QAST::Op.new(
                :op('getpayload'),
                QAST::Op.new( :op('exception') )
            )
        )
    
    });
    add-method(RakuAST::Statement, 'as-block', [RakuAST::Statement, '', 0, 0], anon sub as-block ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 140 src/Raku/ast/statements.rakumod
        
        RakuAST::Block.new:
            :body(RakuAST::Blockoid.new:
                RakuAST::StatementList.new: $SELF)
    
    });
#line 68 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement, 'trace', [], anon sub trace ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Statement, '$!trace') });
#line 69 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement, 'statement-id', [], anon sub statement-id ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Statement, '$!statement-id') });
    compose(RakuAST::Statement);
    parent(RakuAST::ImplicitBlockSemanticsProvider, RakuAST::Node);
    add-method(RakuAST::ImplicitBlockSemanticsProvider, 'apply-implicit-block-semantics', [RakuAST::ImplicitBlockSemanticsProvider, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 152 src/Raku/ast/statements.rakumod
        
        nqp::die('apply-implicit-block-semantics not implemented by ' ~ $SELF.HOW.name($SELF));
    
    });
    compose(RakuAST::ImplicitBlockSemanticsProvider);
    parent(RakuAST::ForLoopImplementation, RakuAST::Node);
    add-method(RakuAST::ForLoopImplementation, 'IMPL-FOR-QAST', [RakuAST::ForLoopImplementation, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$mode', 0, 0, str, '$after-mode', 0, 0, Mu, '$source-qast', 0, 0, Mu, '$body-qast', 0, 0, RakuAST::Label, '$label', 0, 1], anon sub IMPL-FOR-QAST ($SELF_CONT, $context!, $mode!, $after-mode!, $source-qast!, $body-qast!, $label?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $mode := nqp::decont($mode);
        $after-mode := nqp::decont($after-mode);
        $source-qast := nqp::decont($source-qast);
        $body-qast := nqp::decont($body-qast);
        $label := nqp::decont($label);
#line 161 src/Raku/ast/statements.rakumod
        
        # TODO various optimized forms are possible here
        $SELF.IMPL-TO-QAST-GENERAL($context, $mode, $after-mode, $source-qast,
            $body-qast, $label // RakuAST::Label)
    
    });
    add-method(RakuAST::ForLoopImplementation, 'IMPL-TO-QAST-GENERAL', [RakuAST::ForLoopImplementation, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$mode', 0, 0, str, '$after-mode', 0, 0, Mu, '$source-qast', 0, 0, Mu, '$body-qast', 0, 0, RakuAST::Label, '$label', 0, 0], anon sub IMPL-TO-QAST-GENERAL ($SELF_CONT, $context!, $mode!, $after-mode!, $source-qast!, $body-qast!, $label!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $mode := nqp::decont($mode);
        $after-mode := nqp::decont($after-mode);
        $source-qast := nqp::decont($source-qast);
        $body-qast := nqp::decont($body-qast);
        $label := nqp::decont($label);
#line 170 src/Raku/ast/statements.rakumod
        
        # Bind the source into a temporary.
        my $for-list-name := QAST::Node.unique('for-list');
        my $bind-source := QAST::Op.new(
            :op('bind'),
            QAST::Var.new( :name($for-list-name), :scope('local'), :decl('var') ),
            $source-qast
        );

        # Produce the map call.
        my $map-call := QAST::Op.new(
            :op('if'),
            QAST::Op.new( :op('iscont'), QAST::Var.new( :name($for-list-name), :scope('local') ) ),
            QAST::Op.new(
                :op<callmethod>, :name<map>,
                QAST::Var.new( :name($for-list-name), :scope('local') ),
                $body-qast,
                QAST::IVal.new( :value(1), :named('item') )
            ),
            QAST::Op.new(
                :op<callmethod>, :name<map>,
                QAST::Op.new(
                    :op<callmethod>, :name($mode),
                    QAST::Var.new( :name($for-list-name), :scope('local') )
                ),
                $body-qast
            )
        );
        if $label {
            my $label-qast := $label.IMPL-LOOKUP-QAST($context);
            $label-qast.named('label');
            $map-call[1].push($label-qast);
            $map-call[2].push($label-qast);
        }

        # Apply after mode to the map result, and we're done.
        $SELF.IMPL-SET-NODE(
            QAST::Stmts.new(
                $bind-source,
                QAST::Op.new( :op<callmethod>, :name($after-mode), $map-call )), :key)
    
    });
    compose(RakuAST::ForLoopImplementation);
    parent(RakuAST::StatementList, RakuAST::SinkPropagator);
    parent(RakuAST::StatementList, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::StatementList, List, '$!statements');
    add-attribute(RakuAST::StatementList, int, '$!is-sunk');
    add-attribute(RakuAST::StatementList, Mu, '$!code-statements');
    add-method(RakuAST::StatementList, 'new', [RakuAST::StatementList, '', 0, 0, Any, '@statements', 0, 0, Bool, '$trace', 1, 1], anon sub new ($SELF_CONT, *@statements, :$trace?) {
        my $SELF := nqp::decont($SELF_CONT);
        @statements := nqp::decont(@statements);
        $trace := nqp::decont($trace);
#line 222 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::StatementList, '$!statements',@statements);
        nqp::bindattr_i($obj, RakuAST::StatementList, '$!is-sunk', 0);

        # make sure any code statements are known in the internal code-only list
        my @code;
        nqp::bindattr($obj, RakuAST::StatementList, '$!code-statements', @code);
        for @statements {
            unless nqp::istype($_,RakuAST::Doc::Block) {
                nqp::push(@code,$_);
            }
        }

        $obj
    
    });
    add-method(RakuAST::StatementList, 'add-doc-block', [RakuAST::StatementList, '', 0, 0, RakuAST::Statement, '$doc-block', 0, 0], anon sub add-doc-block ($SELF_CONT, $doc-block!) {
        my $SELF := nqp::decont($SELF_CONT);
        $doc-block := nqp::decont($doc-block);
#line 239 src/Raku/ast/statements.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::StatementList, '$!statements'), $doc-block);
    
    });
    add-method(RakuAST::StatementList, 'add-statement', [RakuAST::StatementList, '', 0, 0, RakuAST::Statement, '$statement', 0, 0], anon sub add-statement ($SELF_CONT, $statement!) {
        my $SELF := nqp::decont($SELF_CONT);
        $statement := nqp::decont($statement);
#line 242 src/Raku/ast/statements.rakumod
        
        nqp::push(     nqp::getattr($SELF, RakuAST::StatementList, '$!statements'), $statement);
        nqp::push(nqp::getattr($SELF, RakuAST::StatementList, '$!code-statements'), $statement);
    
    });
    add-method(RakuAST::StatementList, 'statements', [RakuAST::StatementList, '', 0, 0], anon sub statements ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 246 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::StatementList, '$!statements'))
    
    });
    add-method(RakuAST::StatementList, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::StatementList, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 250 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Blob')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Nil')),
        ])
    
    });
    add-method(RakuAST::StatementList, 'IMPL-TO-QAST', [RakuAST::StatementList, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '$immediate', 1, 1], anon sub IMPL-TO-QAST ($SELF_CONT, $context!, :$immediate?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $immediate := nqp::decont($immediate);
#line 257 src/Raku/ast/statements.rakumod
        
        my $stmts := $SELF.IMPL-SET-NODE(QAST::Stmts.new, :key);
        my @statements := $SELF.code-statements;
        my $Nil := $SELF.get-implicit-lookups.AT-POS(1);
        for @statements {
            my $qast := $_.IMPL-TO-QAST($context);
            my $stmt-orig := $_.origin;
            if nqp::isconcrete($stmt-orig) && $stmt-orig.is-key {
                $qast := QAST::Stmt.new(
                    :node($stmt-orig.as-match),
                    $qast
                );
            }
            if $_.trace && nqp::isconcrete($stmt-orig) && !$*CU.precompilation-mode {
                my $Blob :=
                  $SELF.get-implicit-lookups.AT-POS(0).compile-time-value;
                $context.ensure-sc($Blob);
                my $line := $stmt-orig.source.original-line($stmt-orig.from);
                my $file := $stmt-orig.source.original-file;
                my $code := nqp::substr($stmt-orig.source.orig, $stmt-orig.from, $stmt-orig.to - $stmt-orig.from);
                if $code ne 'use trace' {
                    my $id := $_.statement-id;
                    $stmts.push(QAST::Op.new(
                        :op<writefh>,
                        QAST::Op.new(:op<getstderr>),
                        QAST::Op.new(
                            :op('encode'),
                            QAST::SVal.new(:value("$id ($file line $line)\n$code\n")),
                            QAST::SVal.new(:value('utf8')),
                            QAST::Op.new(
                                :op('callmethod'), :name('new'),
                                QAST::WVal.new( :value($Blob) )
                            )
                        )
                    ));
                }
            }
            $stmts.push($qast);
        }
        if !nqp::elems(@statements) {
            $stmts.push($Nil.IMPL-TO-QAST($context));
        }
        else {
            my $last-stmt := @statements[nqp::elems(@statements) - 1];
            if nqp::getattr_i($SELF, RakuAST::StatementList, '$!is-sunk') || $last-stmt.IMPL-DISCARD-RESULT {
                $stmts.push($Nil.IMPL-TO-QAST($context));
            }
            else {
                my $last := $stmts[nqp::elems($stmts) - 1];
                $last.final(1);
                $stmts.returns($last.returns);
            }
        }
        $stmts
    
    });
    add-method(RakuAST::StatementList, 'propagate-sink', [RakuAST::StatementList, '', 0, 0, Bool, '$is-sunk', 0, 0, Bool, '$has-block-parent', 1, 1], anon sub propagate-sink ($SELF_CONT, $is-sunk!, :$has-block-parent?) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
        $has-block-parent := nqp::decont($has-block-parent);
#line 313 src/Raku/ast/statements.rakumod
        
        # Sink all statements, with the possible exception of the last one (only if
        # we are not sunk).
        my @statements := $SELF.code-statements;
        my int $i := 0;
        my int $n := nqp::elems(@statements);
        my int $wanted-statement := $is-sunk ?? -1 !! $n - 1;
        while $i < $n {
            my $cur-statement := @statements[$i];
            $cur-statement.apply-sink($i == $wanted-statement ?? (Bool.WHO)<False> !! (Bool.WHO)<True>);
            if $has-block-parent && nqp::istype($cur-statement, RakuAST::BlockStatementSensitive) {
                $cur-statement.mark-block-statement();
            }
            $i++;
        }
        nqp::bindattr_i($SELF, RakuAST::StatementList, '$!is-sunk', $is-sunk ?? 1 !! 0);
        Nil
    
    });
    add-method(RakuAST::StatementList, 'visit-children', [RakuAST::StatementList, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 332 src/Raku/ast/statements.rakumod
        
        for nqp::getattr($SELF, RakuAST::StatementList, '$!statements') {
            $visitor($_);
        }
    
    });
    add-method(RakuAST::StatementList, 'is-empty', [RakuAST::StatementList, '', 0, 0], anon sub is-empty ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 338 src/Raku/ast/statements.rakumod
        
        nqp::elems($SELF.code-statements) == 0 ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::StatementList, 'IMPL-IS-SINGLE-EXPRESSION', [RakuAST::StatementList, '', 0, 0], anon sub IMPL-IS-SINGLE-EXPRESSION ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 342 src/Raku/ast/statements.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::StatementList, '$!statements')) == 1
        && nqp::istype(nqp::getattr($SELF, RakuAST::StatementList, '$!statements')[0], RakuAST::Statement::Expression)
    
    });
    add-method(RakuAST::StatementList, 'IMPL-CAN-INTERPRET', [RakuAST::StatementList, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 347 src/Raku/ast/statements.rakumod
        
        for $SELF.code-statements {
            return (Bool.WHO)<False> unless $_.IMPL-CAN-INTERPRET;
        }
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::StatementList, 'IMPL-INTERPRET', [RakuAST::StatementList, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 354 src/Raku/ast/statements.rakumod
        
        my $result;
        my @statements := $SELF.code-statements;
        for @statements {
            $result := $_.IMPL-INTERPRET($ctx);
        }
        nqp::getattr_i($SELF, RakuAST::StatementList, '$!is-sunk')
          || !@statements
          || @statements[nqp::elems(@statements) - 1].IMPL-DISCARD-RESULT
            ?? $SELF.get-implicit-lookups.AT-POS(1).compile-time-value
            !! $result
    
    });
#line 220 src/Raku/ast/statements.rakumod
    add-method(RakuAST::StatementList, 'code-statements', [], anon sub code-statements ($self) { nqp::getattr(nqp::decont($self), RakuAST::StatementList, '$!code-statements') });
    compose(RakuAST::StatementList);
    parent(RakuAST::SemiList, RakuAST::StatementList);
    parent(RakuAST::SemiList, RakuAST::ImplicitLookups);
    add-method(RakuAST::SemiList, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::SemiList, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 374 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('&infix:<,>'),
        ])
    
    });
    add-method(RakuAST::SemiList, 'IMPL-TO-QAST', [RakuAST::SemiList, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 380 src/Raku/ast/statements.rakumod
        
        my @statements := $SELF.code-statements;
        my int $n := nqp::elems(@statements);
        if $n == 1 {
            nqp::atpos(@statements, 0).IMPL-TO-QAST($context)
        }
        else {
            my $name :=
              $SELF.get-implicit-lookups.AT-POS(0).resolution.lexical-name;
            my $list := QAST::Op.new(:op('call'), :$name);
            for @statements {
                $list.push($_.IMPL-TO-QAST($context));
            }
            $list
        }
    
    });
    add-method(RakuAST::SemiList, 'IMPL-INTERPRET', [RakuAST::SemiList, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 397 src/Raku/ast/statements.rakumod
        
        my @statements := $SELF.code-statements;
        my int $n := nqp::elems(@statements);
        if $n == 1 {
            nqp::atpos(@statements, 0).IMPL-INTERPRET($ctx)
        }
        else {
            my @list;
            for @statements {
                nqp::push(@list, $_.IMPL-INTERPRET($ctx));
            }
            $SELF.IMPL-WRAP-LIST(@list)
        }
    
    });
    compose(RakuAST::SemiList);
    parent(RakuAST::StatementSequence, RakuAST::StatementList);
    parent(RakuAST::StatementSequence, RakuAST::ImplicitLookups);
    parent(RakuAST::StatementSequence, RakuAST::Contextualizable);
    add-method(RakuAST::StatementSequence, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::StatementSequence, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 422 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('&infix:<,>'),
        ])
    
    });
    add-method(RakuAST::StatementSequence, 'IMPL-TO-QAST', [RakuAST::StatementSequence, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 428 src/Raku/ast/statements.rakumod
        
        my @statements;
        for $SELF.code-statements {
            @statements.push($_)
              unless nqp::istype($_,RakuAST::Statement::Empty);
        }

        my int $n := nqp::elems(@statements);
        if $n == 1 {
            nqp::atpos(@statements, 0).IMPL-TO-QAST($context)
        }
        elsif $n == 0 {
            my $name :=
              $SELF.get-implicit-lookups.AT-POS(0).resolution.lexical-name;
            QAST::Op.new(:op('call'), :$name);
        }
        else {
            my $stmts := $SELF.IMPL-SET-NODE(QAST::Stmts.new, :key);
            for @statements {
                $stmts.push($_.IMPL-TO-QAST($context));
            }
            $stmts
        }
    
    });
    compose(RakuAST::StatementSequence);
    parent(RakuAST::ProducesNil, RakuAST::ImplicitLookups);
    add-method(RakuAST::ProducesNil, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::ProducesNil, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 458 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Nil')),
        ])
    
    });
    add-method(RakuAST::ProducesNil, 'IMPL-TO-QAST', [RakuAST::ProducesNil, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 464 src/Raku/ast/statements.rakumod
        
        $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context)
    
    });
    compose(RakuAST::ProducesNil);
    parent(RakuAST::Statement::Empty, RakuAST::Statement);
    parent(RakuAST::Statement::Empty, RakuAST::ProducesNil);
    add-method(RakuAST::Statement::Empty, 'new', [RakuAST::Statement::Empty, '', 0, 0, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $labels := nqp::decont($labels);
#line 475 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Empty, 'visit-children', [RakuAST::Statement::Empty, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 481 src/Raku/ast/statements.rakumod
        
        $SELF.visit-labels($visitor);
    
    });
    compose(RakuAST::Statement::Empty);
    parent(RakuAST::Statement::Expression, RakuAST::Statement);
    parent(RakuAST::Statement::Expression, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::Expression, RakuAST::Sinkable);
    parent(RakuAST::Statement::Expression, RakuAST::BlockStatementSensitive);
    parent(RakuAST::Statement::Expression, RakuAST::BeginTime);
    add-attribute(RakuAST::Statement::Expression, RakuAST::Expression, '$!expression');
    add-attribute(RakuAST::Statement::Expression, RakuAST::StatementModifier::Condition, '$!condition-modifier');
    add-attribute(RakuAST::Statement::Expression, RakuAST::StatementModifier::Loop, '$!loop-modifier');
    add-method(RakuAST::Statement::Expression, 'new', [RakuAST::Statement::Expression, '', 0, 0, RakuAST::Expression, '$expression', 1, 0, List, '$labels', 1, 1, RakuAST::StatementModifier::Condition, '$condition-modifier', 1, 1, RakuAST::StatementModifier::Loop, '$loop-modifier', 1, 1], anon sub new ($SELF_CONT, :$expression!, :$labels?, :$condition-modifier?, :$loop-modifier?) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
        $labels := nqp::decont($labels);
        $condition-modifier := nqp::decont($condition-modifier);
        $loop-modifier := nqp::decont($loop-modifier);
#line 502 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        $obj.set-expression($expression);
        $obj.set-labels($labels);
        nqp::bindattr($obj, RakuAST::Statement::Expression, '$!condition-modifier',
            $condition-modifier // RakuAST::StatementModifier::Condition);
        nqp::bindattr($obj, RakuAST::Statement::Expression, '$!loop-modifier',
            $loop-modifier // RakuAST::StatementModifier::Loop);
        $obj
    
    });
    add-method(RakuAST::Statement::Expression, 'set-expression', [RakuAST::Statement::Expression, '', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub set-expression ($SELF_CONT, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 513 src/Raku/ast/statements.rakumod
        
        nqp::bindattr($SELF, RakuAST::Statement::Expression, '$!expression',
          $expression // RakuAST::Expression);
        Nil
    
    });
    add-method(RakuAST::Statement::Expression, 'replace-condition-modifier', [RakuAST::Statement::Expression, '', 0, 0, RakuAST::StatementModifier::Condition, '$condition-modifier', 0, 0], anon sub replace-condition-modifier ($SELF_CONT, $condition-modifier!) {
        my $SELF := nqp::decont($SELF_CONT);
        $condition-modifier := nqp::decont($condition-modifier);
#line 519 src/Raku/ast/statements.rakumod
        
        nqp::bindattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier',
            $condition-modifier);
        Nil
    
    });
    add-method(RakuAST::Statement::Expression, 'replace-loop-modifier', [RakuAST::Statement::Expression, '', 0, 0, RakuAST::StatementModifier::Loop, '$loop-modifier', 0, 0], anon sub replace-loop-modifier ($SELF_CONT, $loop-modifier!) {
        my $SELF := nqp::decont($SELF_CONT);
        $loop-modifier := nqp::decont($loop-modifier);
#line 525 src/Raku/ast/statements.rakumod
        
        nqp::bindattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier',
            $loop-modifier);
        Nil
    
    });
    add-method(RakuAST::Statement::Expression, 'IMPL-TO-QAST', [RakuAST::Statement::Expression, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 531 src/Raku/ast/statements.rakumod
        
        # If there is a condition modifier, and the expression is a block
        # with either an explicit signature or a placeholder signature,
        # we should compile it immediate in order that the arity is set
        # right and things like `{ say $^x } if $y` work. Blocks with no
        # signature aren't handled this way, since the $_ should not be
        # counted.
        my $qast;
        if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier') && nqp::istype(nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression'), RakuAST::Block) &&
                (nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').signature || nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').placeholder-signature) {
            $qast := nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier').IMPL-WRAP-QAST($context,
                nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').IMPL-TO-QAST($context, :immediate));
        }
        else {
            $qast := nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').IMPL-TO-QAST($context);
            if $SELF.sunk && nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').needs-sink-call {
                $qast := QAST::Op.new( :op('p6sink'), $qast );
            }
            $qast := nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier').IMPL-WRAP-QAST($context, $qast) if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier') && !nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier');
        }
        if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier') {
            my $sink := $SELF.IMPL-DISCARD-RESULT;
            $qast := nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier').IMPL-WRAP-QAST($context, $qast, :$sink);
        }
        $qast
    
    });
    add-method(RakuAST::Statement::Expression, 'IMPL-DISCARD-RESULT', [RakuAST::Statement::Expression, '', 0, 0], anon sub IMPL-DISCARD-RESULT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 558 src/Raku/ast/statements.rakumod
        
        (
            $SELF.is-block-statement
                && nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier')
                && !nqp::istype(nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier'), RakuAST::StatementModifier::Given)
            || $SELF.sunk
        ) ?? 1 !! 0
    
    });
    add-method(RakuAST::Statement::Expression, 'propagate-sink', [RakuAST::Statement::Expression, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 567 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').apply-sink($is-sunk);
        nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier').apply-sink((Bool.WHO)<False>) if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier');
        nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier').apply-sink((Bool.WHO)<False>) if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier');
    
    });
    add-method(RakuAST::Statement::Expression, 'mark-block-statement', [RakuAST::Statement::Expression, '', 0, 0], anon sub mark-block-statement ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 573 src/Raku/ast/statements.rakumod
        
        nqp::findmethod(RakuAST::BlockStatementSensitive, 'mark-block-statement')($SELF);
        if nqp::istype(nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression'), RakuAST::BlockStatementSensitive) {
            nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').mark-block-statement();
        }
    
    });
    add-method(RakuAST::Statement::Expression, 'PERFORM-BEGIN', [RakuAST::Statement::Expression, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 580 src/Raku/ast/statements.rakumod
        
        if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier') {
            my $thunk := nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier').expression-thunk;
            if $thunk {
                # only need to thunk the condition if we also have a loop thunk
                if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier') {
                    #nqp::die('have loop and condition modifier ' ~ self.dump);
                    my $thunk := nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier').expression-thunk;
                    nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').wrap-with-thunk($thunk);
                    $thunk.ensure-begin-performed($resolver, $context);
                }
                nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').wrap-with-thunk($thunk);
                $thunk.ensure-begin-performed($resolver, $context);
            }
        }
    
    });
    add-method(RakuAST::Statement::Expression, 'visit-children', [RakuAST::Statement::Expression, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 597 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier')) if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier');
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier')) if nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier');
        $SELF.visit-labels($visitor);
    
    });
    add-method(RakuAST::Statement::Expression, 'IMPL-CAN-INTERPRET', [RakuAST::Statement::Expression, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 604 src/Raku/ast/statements.rakumod
        
        !nqp::getattr($SELF, RakuAST::Statement::Expression, '$!condition-modifier') && !nqp::getattr($SELF, RakuAST::Statement::Expression, '$!loop-modifier') && nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').IMPL-CAN-INTERPRET
    
    });
    add-method(RakuAST::Statement::Expression, 'IMPL-INTERPRET', [RakuAST::Statement::Expression, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 608 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Expression, '$!expression').IMPL-INTERPRET($ctx)
    
    });
#line 498 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Expression, 'loop-modifier', [], anon sub loop-modifier ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Expression, '$!loop-modifier') });
#line 496 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Expression, 'expression', [], anon sub expression ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Expression, '$!expression') });
#line 497 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Expression, 'condition-modifier', [], anon sub condition-modifier ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Expression, '$!condition-modifier') });
    compose(RakuAST::Statement::Expression);
    parent(RakuAST::IMPL::ImmediateBlockUser, RakuAST::Node);
    add-method(RakuAST::IMPL::ImmediateBlockUser, 'IMPL-IMMEDIATELY-USES', [RakuAST::IMPL::ImmediateBlockUser, '', 0, 0, RakuAST::Node, '$node', 0, 0], anon sub IMPL-IMMEDIATELY-USES ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 618 src/Raku/ast/statements.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::IMPL::ImmediateBlockUser);
    parent(RakuAST::Statement::IfWith, RakuAST::Statement);
    parent(RakuAST::Statement::IfWith, RakuAST::ImplicitLookups);
    parent(RakuAST::Statement::IfWith, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::IfWith, RakuAST::IMPL::ImmediateBlockUser);
    parent(RakuAST::Statement::IfWith, RakuAST::ImplicitBlockSemanticsProvider);
    add-attribute(RakuAST::Statement::IfWith, RakuAST::Expression, '$!condition');
    add-attribute(RakuAST::Statement::IfWith, RakuAST::Expression, '$!then');
    add-attribute(RakuAST::Statement::IfWith, List, '$!elsifs');
    add-attribute(RakuAST::Statement::IfWith, RakuAST::Block, '$!else');
    add-method(RakuAST::Statement::IfWith, 'new', [RakuAST::Statement::IfWith, '', 0, 0, RakuAST::Expression, '$condition', 1, 0, RakuAST::Expression, '$then', 1, 0, List, '$elsifs', 1, 1, RakuAST::Block, '$else', 1, 1, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$condition!, :$then!, :$elsifs?, :$else?, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $condition := nqp::decont($condition);
        $then := nqp::decont($then);
        $elsifs := nqp::decont($elsifs);
        $else := nqp::decont($else);
        $labels := nqp::decont($labels);
#line 640 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj,RakuAST::Statement::IfWith,'$!condition',$condition);
        nqp::bindattr($obj,RakuAST::Statement::IfWith,'$!then',$then);
        $obj.set-elsifs($elsifs);
        $obj.set-else($else);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::IfWith, 'set-elsifs', [RakuAST::Statement::IfWith, '', 0, 0, Any, '$elsifs', 0, 0], anon sub set-elsifs ($SELF_CONT, $elsifs!) {
        my $SELF := nqp::decont($SELF_CONT);
        $elsifs := nqp::decont($elsifs);
#line 650 src/Raku/ast/statements.rakumod
        
        nqp::bindattr($SELF,RakuAST::Statement::IfWith,'$!elsifs',
          $elsifs ?? $SELF.IMPL-UNWRAP-LIST($elsifs) !! []
        );
        Nil
    
    });
    add-method(RakuAST::Statement::IfWith, 'elsifs', [RakuAST::Statement::IfWith, '', 0, 0], anon sub elsifs ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 656 src/Raku/ast/statements.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!elsifs')) 
    });
    add-method(RakuAST::Statement::IfWith, 'set-else', [RakuAST::Statement::IfWith, '', 0, 0, Any, '$else', 0, 0], anon sub set-else ($SELF_CONT, $else!) {
        my $SELF := nqp::decont($SELF_CONT);
        $else := nqp::decont($else);
#line 658 src/Raku/ast/statements.rakumod
        
        nqp::bindattr($SELF,RakuAST::Statement::IfWith,'$!else',
          $else // RakuAST::Block);
    
    });
    add-method(RakuAST::Statement::IfWith, 'apply-implicit-block-semantics', [RakuAST::Statement::IfWith, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 663 src/Raku/ast/statements.rakumod
        
        my int $last-was-with;
        if $SELF.IMPL-QAST-TYPE eq 'with' {
            $last-was-with := 1;
            nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!then').set-implicit-topic((Bool.WHO)<True>, :required);
        }
        else {
            nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!then').set-implicit-topic((Bool.WHO)<False>, :local);
        }
        for nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!elsifs') {
            $_.apply-implicit-block-semantics();
            $last-was-with := $_.IMPL-QAST-TYPE eq 'with';
        }
        if nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else') {
            if $last-was-with {
                nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else').set-implicit-topic((Bool.WHO)<True>, :required);
            }
            else {
                nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else').set-implicit-topic((Bool.WHO)<False>, :local);
            }
        }
    
    });
    add-method(RakuAST::Statement::IfWith, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Statement::IfWith, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 686 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST: nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else')
            ?? []
            !! [RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Empty'))]
    
    });
    add-method(RakuAST::Statement::IfWith, 'IMPL-TO-QAST', [RakuAST::Statement::IfWith, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 692 src/Raku/ast/statements.rakumod
        
        # Start with the else (or Empty).
        my $cur-end;
        if nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else') {
            $cur-end := nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else').IMPL-TO-QAST($context, :immediate);
        }
        else {
            $cur-end :=
              $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context);
        }

        # Add the branches.
        my int $i := nqp::elems(nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!elsifs'));
        while $i-- > 0 {
            my $branch := nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!elsifs')[$i];
            $cur-end := QAST::Op.new(
                :op($branch.IMPL-QAST-TYPE),
                $branch.condition.IMPL-TO-QAST($context),
                $branch.then.IMPL-TO-QAST($context, :immediate),
                $cur-end
            );
        }

        # Finally, the initial condition.
        QAST::Op.new(
            :op($SELF.IMPL-QAST-TYPE),
            nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!condition').IMPL-TO-QAST($context),
            nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!then').IMPL-TO-QAST($context, :immediate),
            $cur-end
        )
    
    });
    add-method(RakuAST::Statement::IfWith, 'propagate-sink', [RakuAST::Statement::IfWith, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 724 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!condition').apply-sink((Bool.WHO)<False>);
        nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!then').body.apply-sink($is-sunk);
        for nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!elsifs') {
            $_.condition.apply-sink((Bool.WHO)<False>);
            $_.then.body.apply-sink($is-sunk);
        }
        if nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else') {
            nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else').body.apply-sink($is-sunk);
        }
    
    });
    add-method(RakuAST::Statement::IfWith, 'visit-children', [RakuAST::Statement::IfWith, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 736 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!condition'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!then'));
        for nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!elsifs') {
            $visitor($_.condition);
            $visitor($_.then);
        }
        if nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else') {
            $visitor(nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!else'));
        }
        $SELF.visit-labels($visitor);
    
    });
    add-method(RakuAST::Statement::IfWith, 'IMPL-IMMEDIATELY-USES', [RakuAST::Statement::IfWith, '', 0, 0, RakuAST::Node, '$node', 0, 0], anon sub IMPL-IMMEDIATELY-USES ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 749 src/Raku/ast/statements.rakumod
        
        return (Bool.WHO)<False> if $node =:= nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!condition');
        for nqp::getattr($SELF, RakuAST::Statement::IfWith, '$!elsifs') {
            return (Bool.WHO)<False> if $node =:= $_.condition;
        }
        (Bool.WHO)<True>
    
    });
#line 630 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::IfWith, 'then', [], anon sub then ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::IfWith, '$!then') });
#line 632 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::IfWith, 'else', [], anon sub else ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::IfWith, '$!else') });
#line 629 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::IfWith, 'condition', [], anon sub condition ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::IfWith, '$!condition') });
    compose(RakuAST::Statement::IfWith);
    parent(RakuAST::Statement::If, RakuAST::Statement::IfWith);
    add-method(RakuAST::Statement::If, 'IMPL-QAST-TYPE', [RakuAST::Statement::If, '', 0, 0], anon sub IMPL-QAST-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 762 src/Raku/ast/statements.rakumod
         'if' 
    });
    compose(RakuAST::Statement::If);
    parent(RakuAST::Statement::With, RakuAST::Statement::IfWith);
    add-method(RakuAST::Statement::With, 'IMPL-QAST-TYPE', [RakuAST::Statement::With, '', 0, 0], anon sub IMPL-QAST-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 769 src/Raku/ast/statements.rakumod
         'with' 
    });
    compose(RakuAST::Statement::With);
    parent(RakuAST::Statement::Elsif, Any);
    add-attribute(RakuAST::Statement::Elsif, RakuAST::Expression, '$!condition');
    add-attribute(RakuAST::Statement::Elsif, RakuAST::Expression, '$!then');
    add-method(RakuAST::Statement::Elsif, 'new', [RakuAST::Statement::Elsif, '', 0, 0, RakuAST::Expression, '$condition', 1, 0, RakuAST::Expression, '$then', 1, 0], anon sub new ($SELF_CONT, :$condition!, :$then!) {
        my $SELF := nqp::decont($SELF_CONT);
        $condition := nqp::decont($condition);
        $then := nqp::decont($then);
#line 778 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Elsif, '$!condition', $condition);
        nqp::bindattr($obj, RakuAST::Statement::Elsif, '$!then', $then);
        $obj
    
    });
    add-method(RakuAST::Statement::Elsif, 'apply-implicit-block-semantics', [RakuAST::Statement::Elsif, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 785 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Elsif, '$!then').set-implicit-topic((Bool.WHO)<False>, :local);
    
    });
    add-method(RakuAST::Statement::Elsif, 'IMPL-QAST-TYPE', [RakuAST::Statement::Elsif, '', 0, 0], anon sub IMPL-QAST-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 789 src/Raku/ast/statements.rakumod
         'if' 
    });
#line 776 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Elsif, 'then', [], anon sub then ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Elsif, '$!then') });
#line 775 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Elsif, 'condition', [], anon sub condition ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Elsif, '$!condition') });
    compose(RakuAST::Statement::Elsif);
    parent(RakuAST::Statement::Orwith, RakuAST::Statement::Elsif);
    add-method(RakuAST::Statement::Orwith, 'IMPL-QAST-TYPE', [RakuAST::Statement::Orwith, '', 0, 0], anon sub IMPL-QAST-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 797 src/Raku/ast/statements.rakumod
         'with' 
    });
    add-method(RakuAST::Statement::Orwith, 'apply-implicit-block-semantics', [RakuAST::Statement::Orwith, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 799 src/Raku/ast/statements.rakumod
        
        $SELF.then.set-implicit-topic((Bool.WHO)<True>, :required);
    
    });
    compose(RakuAST::Statement::Orwith);
    parent(RakuAST::Statement::Unless, RakuAST::Statement);
    parent(RakuAST::Statement::Unless, RakuAST::ImplicitLookups);
    parent(RakuAST::Statement::Unless, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::Unless, RakuAST::IMPL::ImmediateBlockUser);
    parent(RakuAST::Statement::Unless, RakuAST::ImplicitBlockSemanticsProvider);
    add-attribute(RakuAST::Statement::Unless, RakuAST::Expression, '$!condition');
    add-attribute(RakuAST::Statement::Unless, RakuAST::Block, '$!body');
    add-method(RakuAST::Statement::Unless, 'new', [RakuAST::Statement::Unless, '', 0, 0, RakuAST::Expression, '$condition', 1, 0, RakuAST::Block, '$body', 1, 0, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$condition!, :$body!, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $condition := nqp::decont($condition);
        $body := nqp::decont($body);
        $labels := nqp::decont($labels);
#line 815 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Unless, '$!condition', $condition);
        nqp::bindattr($obj, RakuAST::Statement::Unless, '$!body', $body);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Unless, 'apply-implicit-block-semantics', [RakuAST::Statement::Unless, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 823 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Unless, '$!body').set-implicit-topic((Bool.WHO)<False>, :local);
    
    });
    add-method(RakuAST::Statement::Unless, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Statement::Unless, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 827 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Empty')),
        ])
    
    });
    add-method(RakuAST::Statement::Unless, 'IMPL-TO-QAST', [RakuAST::Statement::Unless, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 833 src/Raku/ast/statements.rakumod
        
        QAST::Op.new(
            :op('unless'),
            nqp::getattr($SELF, RakuAST::Statement::Unless, '$!condition').IMPL-TO-QAST($context),
            nqp::getattr($SELF, RakuAST::Statement::Unless, '$!body').IMPL-TO-QAST($context, :immediate),
            $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context)
        )
    
    });
    add-method(RakuAST::Statement::Unless, 'propagate-sink', [RakuAST::Statement::Unless, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 842 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Unless, '$!condition').apply-sink((Bool.WHO)<False>);
        nqp::getattr($SELF, RakuAST::Statement::Unless, '$!body').body.apply-sink($is-sunk);
    
    });
    add-method(RakuAST::Statement::Unless, 'visit-children', [RakuAST::Statement::Unless, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 847 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Unless, '$!condition'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Unless, '$!body'));
        $SELF.visit-labels($visitor);
    
    });
    add-method(RakuAST::Statement::Unless, 'IMPL-IMMEDIATELY-USES', [RakuAST::Statement::Unless, '', 0, 0, RakuAST::Node, '$node', 0, 0], anon sub IMPL-IMMEDIATELY-USES ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 853 src/Raku/ast/statements.rakumod
        
        $node =:= nqp::getattr($SELF, RakuAST::Statement::Unless, '$!body')
    
    });
#line 812 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Unless, 'condition', [], anon sub condition ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Unless, '$!condition') });
#line 813 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Unless, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Unless, '$!body') });
    compose(RakuAST::Statement::Unless);
    parent(RakuAST::Statement::Without, RakuAST::Statement);
    parent(RakuAST::Statement::Without, RakuAST::ImplicitLookups);
    parent(RakuAST::Statement::Without, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::Without, RakuAST::IMPL::ImmediateBlockUser);
    parent(RakuAST::Statement::Without, RakuAST::ImplicitBlockSemanticsProvider);
    add-attribute(RakuAST::Statement::Without, RakuAST::Expression, '$!condition');
    add-attribute(RakuAST::Statement::Without, RakuAST::Block, '$!body');
    add-method(RakuAST::Statement::Without, 'new', [RakuAST::Statement::Without, '', 0, 0, RakuAST::Expression, '$condition', 1, 0, RakuAST::Block, '$body', 1, 0, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$condition!, :$body!, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $condition := nqp::decont($condition);
        $body := nqp::decont($body);
        $labels := nqp::decont($labels);
#line 869 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Without, '$!condition', $condition);
        nqp::bindattr($obj, RakuAST::Statement::Without, '$!body', $body);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Without, 'apply-implicit-block-semantics', [RakuAST::Statement::Without, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 877 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Without, '$!body').set-implicit-topic((Bool.WHO)<True>, :required);
    
    });
    add-method(RakuAST::Statement::Without, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Statement::Without, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 881 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Empty')),
        ])
    
    });
    add-method(RakuAST::Statement::Without, 'IMPL-TO-QAST', [RakuAST::Statement::Without, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 887 src/Raku/ast/statements.rakumod
        
        QAST::Op.new(
            :op('without'),
            nqp::getattr($SELF, RakuAST::Statement::Without, '$!condition').IMPL-TO-QAST($context),
            nqp::getattr($SELF, RakuAST::Statement::Without, '$!body').IMPL-TO-QAST($context, :immediate),
            $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context)
        )
    
    });
    add-method(RakuAST::Statement::Without, 'propagate-sink', [RakuAST::Statement::Without, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 896 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Without, '$!condition').apply-sink((Bool.WHO)<False>);
        nqp::getattr($SELF, RakuAST::Statement::Without, '$!body').body.apply-sink($is-sunk);
    
    });
    add-method(RakuAST::Statement::Without, 'visit-children', [RakuAST::Statement::Without, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 901 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Without, '$!condition'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Without, '$!body'));
        $SELF.visit-labels($visitor);
    
    });
    add-method(RakuAST::Statement::Without, 'IMPL-IMMEDIATELY-USES', [RakuAST::Statement::Without, '', 0, 0, RakuAST::Node, '$node', 0, 0], anon sub IMPL-IMMEDIATELY-USES ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 907 src/Raku/ast/statements.rakumod
        
        $node =:= nqp::getattr($SELF, RakuAST::Statement::Without, '$!body')
    
    });
#line 866 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Without, 'condition', [], anon sub condition ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Without, '$!condition') });
#line 867 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Without, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Without, '$!body') });
    compose(RakuAST::Statement::Without);
    parent(RakuAST::Statement::Loop, RakuAST::Statement);
    parent(RakuAST::Statement::Loop, RakuAST::ImplicitLookups);
    parent(RakuAST::Statement::Loop, RakuAST::Sinkable);
    parent(RakuAST::Statement::Loop, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::Loop, RakuAST::BlockStatementSensitive);
    parent(RakuAST::Statement::Loop, RakuAST::IMPL::ImmediateBlockUser);
    parent(RakuAST::Statement::Loop, RakuAST::ImplicitBlockSemanticsProvider);
    add-attribute(RakuAST::Statement::Loop, RakuAST::Expression, '$!setup');
    add-attribute(RakuAST::Statement::Loop, RakuAST::Expression, '$!condition');
    add-attribute(RakuAST::Statement::Loop, RakuAST::Block, '$!body');
    add-attribute(RakuAST::Statement::Loop, RakuAST::Expression, '$!increment');
    add-method(RakuAST::Statement::Loop, 'new', [RakuAST::Statement::Loop, '', 0, 0, RakuAST::Block, '$body', 1, 0, RakuAST::Expression, '$condition', 1, 1, RakuAST::Expression, '$setup', 1, 1, RakuAST::Expression, '$increment', 1, 1, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$body!, :$condition?, :$setup?, :$increment?, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $body := nqp::decont($body);
        $condition := nqp::decont($condition);
        $setup := nqp::decont($setup);
        $increment := nqp::decont($increment);
        $labels := nqp::decont($labels);
#line 937 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Loop, '$!body', $body);
        nqp::bindattr($obj, RakuAST::Statement::Loop, '$!condition', $condition);
        nqp::bindattr($obj, RakuAST::Statement::Loop, '$!setup', $setup);
        nqp::bindattr($obj, RakuAST::Statement::Loop, '$!increment', $increment);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Loop, 'negate', [RakuAST::Statement::Loop, '', 0, 0], anon sub negate ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 948 src/Raku/ast/statements.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Statement::Loop, 'repeat', [RakuAST::Statement::Loop, '', 0, 0], anon sub repeat ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 951 src/Raku/ast/statements.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Statement::Loop, 'apply-implicit-block-semantics', [RakuAST::Statement::Loop, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 953 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Loop, '$!body').set-implicit-topic((Bool.WHO)<False>, :local);
    
    });
    add-method(RakuAST::Statement::Loop, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Statement::Loop, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 957 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Nil'))
        ])
    
    });
    add-method(RakuAST::Statement::Loop, 'IMPL-DISCARD-RESULT', [RakuAST::Statement::Loop, '', 0, 0], anon sub IMPL-DISCARD-RESULT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 963 src/Raku/ast/statements.rakumod
        
        $SELF.is-block-statement || $SELF.sunk
    
    });
    add-method(RakuAST::Statement::Loop, 'IMPL-TO-QAST', [RakuAST::Statement::Loop, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 967 src/Raku/ast/statements.rakumod
        
        if $SELF.IMPL-DISCARD-RESULT {
            # Select correct node type for the loop and produce it.
            my str $op := $SELF.repeat
                ?? ($SELF.negate ?? 'repeat_until' !! 'repeat_while')
                !! ($SELF.negate ?? 'until' !! 'while');
            my $loop-qast := QAST::Op.new(
                :$op,
                nqp::getattr($SELF, RakuAST::Statement::Loop, '$!condition') ?? nqp::getattr($SELF, RakuAST::Statement::Loop, '$!condition').IMPL-TO-QAST($context) !! QAST::IVal.new( :value(1) ),
                nqp::getattr($SELF, RakuAST::Statement::Loop, '$!body').IMPL-TO-QAST($context, :immediate),
            );
            if nqp::getattr($SELF, RakuAST::Statement::Loop, '$!increment') {
                $loop-qast.push(nqp::getattr($SELF, RakuAST::Statement::Loop, '$!increment').IMPL-TO-QAST($context));
            }

            # Add a label if there is one.
            my @labels := $SELF.IMPL-UNWRAP-LIST($SELF.labels);
            if @labels {
                my $label-qast := @labels[0].IMPL-LOOKUP-QAST($context);
                $label-qast.named('label');
                $loop-qast.push($label-qast);
            }

            # Prepend setup code and evaluate to Nil if not sunk.
            my $wrapper := $SELF.IMPL-SET-NODE(QAST::Stmt.new(), :key);
            if nqp::getattr($SELF, RakuAST::Statement::Loop, '$!setup') {
                $wrapper.push(nqp::getattr($SELF, RakuAST::Statement::Loop, '$!setup').IMPL-TO-QAST($context));
            }
            $wrapper.push($loop-qast);
            unless $SELF.sunk {
                $wrapper.push(
                  $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context)
                );
            }

            $wrapper
        }
        else {
            nqp::die('Compilation of lazy loops NYI')
        }
    
    });
    add-method(RakuAST::Statement::Loop, 'propagate-sink', [RakuAST::Statement::Loop, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 1009 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Loop, '$!condition').apply-sink((Bool.WHO)<False>) if nqp::getattr($SELF, RakuAST::Statement::Loop, '$!condition');
        nqp::getattr($SELF, RakuAST::Statement::Loop, '$!body').body.apply-sink($SELF.IMPL-DISCARD-RESULT ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::getattr($SELF, RakuAST::Statement::Loop, '$!setup').apply-sink((Bool.WHO)<True>) if nqp::getattr($SELF, RakuAST::Statement::Loop, '$!setup');
        nqp::getattr($SELF, RakuAST::Statement::Loop, '$!increment').apply-sink((Bool.WHO)<True>) if nqp::getattr($SELF, RakuAST::Statement::Loop, '$!increment');
    
    });
    add-method(RakuAST::Statement::Loop, 'visit-children', [RakuAST::Statement::Loop, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1016 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Loop, '$!setup')) if nqp::getattr($SELF, RakuAST::Statement::Loop, '$!setup');
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Loop, '$!condition')) if nqp::getattr($SELF, RakuAST::Statement::Loop, '$!condition');
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Loop, '$!increment')) if nqp::getattr($SELF, RakuAST::Statement::Loop, '$!increment');
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Loop, '$!body'));
        $SELF.visit-labels($visitor);
    
    });
    add-method(RakuAST::Statement::Loop, 'IMPL-IMMEDIATELY-USES', [RakuAST::Statement::Loop, '', 0, 0, RakuAST::Node, '$node', 0, 0], anon sub IMPL-IMMEDIATELY-USES ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 1024 src/Raku/ast/statements.rakumod
        
        $node =:= nqp::getattr($SELF, RakuAST::Statement::Loop, '$!body')
    
    });
#line 924 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Loop, 'setup', [], anon sub setup ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Loop, '$!setup') });
#line 933 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Loop, 'increment', [], anon sub increment ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Loop, '$!increment') });
#line 927 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Loop, 'condition', [], anon sub condition ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Loop, '$!condition') });
#line 930 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Loop, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Loop, '$!body') });
    compose(RakuAST::Statement::Loop);
    parent(RakuAST::Statement::Loop::While, RakuAST::Statement::Loop);
    compose(RakuAST::Statement::Loop::While);
    parent(RakuAST::Statement::Loop::Until, RakuAST::Statement::Loop);
    add-method(RakuAST::Statement::Loop::Until, 'negate', [RakuAST::Statement::Loop::Until, '', 0, 0], anon sub negate ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1038 src/Raku/ast/statements.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::Statement::Loop::Until);
    parent(RakuAST::Statement::Loop::RepeatWhile, RakuAST::Statement::Loop);
    add-method(RakuAST::Statement::Loop::RepeatWhile, 'repeat', [RakuAST::Statement::Loop::RepeatWhile, '', 0, 0], anon sub repeat ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1045 src/Raku/ast/statements.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::Statement::Loop::RepeatWhile);
    parent(RakuAST::Statement::Loop::RepeatUntil, RakuAST::Statement::Loop);
    add-method(RakuAST::Statement::Loop::RepeatUntil, 'negate', [RakuAST::Statement::Loop::RepeatUntil, '', 0, 0], anon sub negate ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1052 src/Raku/ast/statements.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Statement::Loop::RepeatUntil, 'repeat', [RakuAST::Statement::Loop::RepeatUntil, '', 0, 0], anon sub repeat ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1053 src/Raku/ast/statements.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::Statement::Loop::RepeatUntil);
    parent(RakuAST::Statement::For, RakuAST::Statement);
    parent(RakuAST::Statement::For, RakuAST::ForLoopImplementation);
    parent(RakuAST::Statement::For, RakuAST::Sinkable);
    parent(RakuAST::Statement::For, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::For, RakuAST::BlockStatementSensitive);
    parent(RakuAST::Statement::For, RakuAST::ImplicitBlockSemanticsProvider);
    add-attribute(RakuAST::Statement::For, RakuAST::Expression, '$!source');
    add-attribute(RakuAST::Statement::For, RakuAST::Block, '$!body');
    add-attribute(RakuAST::Statement::For, RakuAST::Block, '$!otherwise');
    add-attribute(RakuAST::Statement::For, str, '$!mode');
    add-method(RakuAST::Statement::For, 'new', [RakuAST::Statement::For, '', 0, 0, RakuAST::Expression, '$source', 1, 0, RakuAST::Block, '$body', 1, 0, RakuAST::Block, '$otherwise', 1, 1, str, '$mode', 1, 1, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$source!, :$body!, :$otherwise?, :$mode?, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $source := nqp::decont($source);
        $body := nqp::decont($body);
        $otherwise := nqp::decont($otherwise);
        $mode := nqp::decont($mode);
        $labels := nqp::decont($labels);
#line 1083 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::For, '$!source', $source);
        nqp::bindattr($obj, RakuAST::Statement::For, '$!body', $body);
        nqp::bindattr($obj, RakuAST::Statement::For, '$!otherwise', $otherwise);
        nqp::bindattr_s($obj, RakuAST::Statement::For, '$!mode', $mode || 'serial');
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::For, 'replace-mode', [RakuAST::Statement::For, '', 0, 0, str, '$mode', 0, 0], anon sub replace-mode ($SELF_CONT, $mode!) {
        my $SELF := nqp::decont($SELF_CONT);
        $mode := nqp::decont($mode);
#line 1093 src/Raku/ast/statements.rakumod
        
        nqp::bindattr_s($SELF, RakuAST::Statement::For, '$!mode', $mode);
        Nil
    
    });
    add-method(RakuAST::Statement::For, 'replace-otherwise', [RakuAST::Statement::For, '', 0, 0, RakuAST::Block, '$otherwise', 0, 0], anon sub replace-otherwise ($SELF_CONT, $otherwise!) {
        my $SELF := nqp::decont($SELF_CONT);
        $otherwise := nqp::decont($otherwise);
#line 1098 src/Raku/ast/statements.rakumod
        
        nqp::bindattr($SELF, RakuAST::Statement::For, '$!otherwise', $otherwise);
        Nil
    
    });
    add-method(RakuAST::Statement::For, 'IMPL-DISCARD-RESULT', [RakuAST::Statement::For, '', 0, 0], anon sub IMPL-DISCARD-RESULT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1103 src/Raku/ast/statements.rakumod
        
        $SELF.is-block-statement || $SELF.sunk
    
    });
    add-method(RakuAST::Statement::For, 'propagate-sink', [RakuAST::Statement::For, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 1107 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::For, '$!source').apply-sink((Bool.WHO)<False>);
        nqp::getattr($SELF, RakuAST::Statement::For, '$!body').body.apply-sink($SELF.IMPL-DISCARD-RESULT ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
    
    });
    add-method(RakuAST::Statement::For, 'apply-implicit-block-semantics', [RakuAST::Statement::For, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1112 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::For, '$!body').set-implicit-topic((Bool.WHO)<True>, :required);
    
    });
    add-method(RakuAST::Statement::For, 'IMPL-TO-QAST', [RakuAST::Statement::For, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1116 src/Raku/ast/statements.rakumod
        
        # Figure out the execution mode modifiers to apply.
        my str $mode := nqp::getattr_s($SELF, RakuAST::Statement::For, '$!mode');
        my str $after-mode := '';
        if nqp::getattr($SELF, RakuAST::Statement::For, '$!otherwise') {
            $mode := 'serial';
            $after-mode := 'eager';
        }
        elsif $mode eq 'lazy' {
            $mode := 'serial';
            $after-mode := 'lazy';
        }
        else {
            $after-mode := $SELF.IMPL-DISCARD-RESULT ?? 'sink' !! 'eager';
        }

        # Delegate to the for loop compilation helper (which we pass various
        # attributes to in order to make it callable for the statement modifier
        # form also).
        my @labels := $SELF.IMPL-UNWRAP-LIST($SELF.labels);
        my $qast := $SELF.IMPL-FOR-QAST(
          $context,
          $mode,
          $after-mode,
          nqp::getattr($SELF, RakuAST::Statement::For, '$!source').IMPL-TO-QAST($context),
          nqp::getattr($SELF, RakuAST::Statement::For, '$!body').IMPL-TO-QAST($context),
          @labels ?? @labels[0] !! RakuAST::Label
        );

        nqp::getattr($SELF, RakuAST::Statement::For, '$!otherwise')
          ?? QAST::Op.new(:op<unless>,
               $qast,
               QAST::Op.new(:op<call>,
                 nqp::getattr($SELF, RakuAST::Statement::For, '$!otherwise').IMPL-TO-QAST($context)
               )
             )
          !! $qast
    
    });
    add-method(RakuAST::Statement::For, 'visit-children', [RakuAST::Statement::For, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1156 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::For, '$!source'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::For, '$!body'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::For, '$!otherwise')) if nqp::getattr($SELF, RakuAST::Statement::For, '$!otherwise');
        $SELF.visit-labels($visitor);
    
    });
#line 1066 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::For, 'source', [], anon sub source ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::For, '$!source') });
#line 1072 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::For, 'otherwise', [], anon sub otherwise ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::For, '$!otherwise') });
#line 1075 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::For, 'mode', [], anon sub mode ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Statement::For, '$!mode') });
#line 1069 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::For, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::For, '$!body') });
    compose(RakuAST::Statement::For);
    parent(RakuAST::Statement::Given, RakuAST::Statement);
    parent(RakuAST::Statement::Given, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::Given, RakuAST::ImplicitBlockSemanticsProvider);
    add-attribute(RakuAST::Statement::Given, RakuAST::Expression, '$!source');
    add-attribute(RakuAST::Statement::Given, RakuAST::Block, '$!body');
    add-method(RakuAST::Statement::Given, 'new', [RakuAST::Statement::Given, '', 0, 0, RakuAST::Expression, '$source', 1, 0, RakuAST::Block, '$body', 1, 0, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$source!, :$body!, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $source := nqp::decont($source);
        $body := nqp::decont($body);
        $labels := nqp::decont($labels);
#line 1176 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Given, '$!source', $source);
        nqp::bindattr($obj, RakuAST::Statement::Given, '$!body', $body);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Given, 'propagate-sink', [RakuAST::Statement::Given, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 1184 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Given, '$!source').apply-sink((Bool.WHO)<False>);
        nqp::getattr($SELF, RakuAST::Statement::Given, '$!body').body.apply-sink($is-sunk);
    
    });
    add-method(RakuAST::Statement::Given, 'apply-implicit-block-semantics', [RakuAST::Statement::Given, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1189 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Given, '$!body').set-implicit-topic((Bool.WHO)<True>, :required);
    
    });
    add-method(RakuAST::Statement::Given, 'IMPL-TO-QAST', [RakuAST::Statement::Given, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1193 src/Raku/ast/statements.rakumod
        
        QAST::Op.new(
            :op('call'),
            nqp::getattr($SELF, RakuAST::Statement::Given, '$!body').IMPL-TO-QAST($context),
            nqp::getattr($SELF, RakuAST::Statement::Given, '$!source').IMPL-TO-QAST($context)
        )
    
    });
    add-method(RakuAST::Statement::Given, 'visit-children', [RakuAST::Statement::Given, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1201 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Given, '$!source'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Given, '$!body'));
        $SELF.visit-labels($visitor);
    
    });
#line 1171 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Given, 'source', [], anon sub source ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Given, '$!source') });
#line 1174 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Given, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Given, '$!body') });
    compose(RakuAST::Statement::Given);
    parent(RakuAST::Statement::When, RakuAST::Statement);
    parent(RakuAST::Statement::When, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::When, RakuAST::ImplicitBlockSemanticsProvider);
    parent(RakuAST::Statement::When, RakuAST::ImplicitLookups);
    parent(RakuAST::Statement::When, RakuAST::Attaching);
    add-attribute(RakuAST::Statement::When, RakuAST::Expression, '$!condition');
    add-attribute(RakuAST::Statement::When, RakuAST::Block, '$!body');
    add-method(RakuAST::Statement::When, 'new', [RakuAST::Statement::When, '', 0, 0, RakuAST::Expression, '$condition', 1, 0, RakuAST::Block, '$body', 1, 0, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$condition!, :$body!, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $condition := nqp::decont($condition);
        $body := nqp::decont($body);
        $labels := nqp::decont($labels);
#line 1220 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::When, '$!condition', $condition);
        nqp::bindattr($obj, RakuAST::Statement::When, '$!body', $body);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::When, 'apply-implicit-block-semantics', [RakuAST::Statement::When, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1228 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::When, '$!body').set-implicit-topic((Bool.WHO)<False>);
    
    });
    add-method(RakuAST::Statement::When, 'propagate-sink', [RakuAST::Statement::When, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 1232 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::When, '$!condition').apply-sink((Bool.WHO)<False>);
        nqp::getattr($SELF, RakuAST::Statement::When, '$!body').body.apply-sink((Bool.WHO)<False>); # Used as enclosing block outcome
    
    });
    add-method(RakuAST::Statement::When, 'attach', [RakuAST::Statement::When, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1237 src/Raku/ast/statements.rakumod
        
        my $block := $resolver.find-attach-target('block') //
            $resolver.find-attach-target('compunit');
        if $block {
            $block.require-succeed-handler();
        }
        else {
            nqp::die('when found no enclosing block to attach to');
        }
    
    });
    add-method(RakuAST::Statement::When, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Statement::When, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1248 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('$_'),
        ])
    
    });
    add-method(RakuAST::Statement::When, 'IMPL-TO-QAST', [RakuAST::Statement::When, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1254 src/Raku/ast/statements.rakumod
        
        my $sm-qast := QAST::Op.new(
            :op('callmethod'), :name('ACCEPTS'),
            nqp::getattr($SELF, RakuAST::Statement::When, '$!condition').IMPL-TO-QAST($context),
            $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context)
        );
        QAST::Op.new(
            :op('if'),
            $sm-qast,
            $SELF.IMPL-WRAP-WHEN-OR-DEFAULT($context,
                QAST::Op.new( :op('call'), nqp::getattr($SELF, RakuAST::Statement::When, '$!body').IMPL-TO-QAST($context) )
            ))
    
    });
    add-method(RakuAST::Statement::When, 'visit-children', [RakuAST::Statement::When, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1268 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::When, '$!condition'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::When, '$!body'));
        $SELF.visit-labels($visitor);
    
    });
#line 1217 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::When, 'condition', [], anon sub condition ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::When, '$!condition') });
#line 1218 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::When, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::When, '$!body') });
    compose(RakuAST::Statement::When);
    parent(RakuAST::Statement::Whenever, RakuAST::Statement);
    parent(RakuAST::Statement::Whenever, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::Whenever, RakuAST::ImplicitBlockSemanticsProvider);
    add-attribute(RakuAST::Statement::Whenever, RakuAST::Expression, '$!trigger');
    add-attribute(RakuAST::Statement::Whenever, RakuAST::Block, '$!body');
    add-method(RakuAST::Statement::Whenever, 'new', [RakuAST::Statement::Whenever, '', 0, 0, RakuAST::Expression, '$trigger', 1, 0, RakuAST::Block, '$body', 1, 0, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$trigger!, :$body!, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $trigger := nqp::decont($trigger);
        $body := nqp::decont($body);
        $labels := nqp::decont($labels);
#line 1288 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj,RakuAST::Statement::Whenever,'$!trigger',$trigger);
        nqp::bindattr($obj,RakuAST::Statement::Whenever,'$!body',$body);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Whenever, 'propagate-sink', [RakuAST::Statement::Whenever, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 1296 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Whenever, '$!trigger').apply-sink((Bool.WHO)<False>);
        nqp::getattr($SELF, RakuAST::Statement::Whenever, '$!body').body.apply-sink($is-sunk);
    
    });
    add-method(RakuAST::Statement::Whenever, 'apply-implicit-block-semantics', [RakuAST::Statement::Whenever, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1301 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Whenever, '$!body').set-implicit-topic((Bool.WHO)<True>, :required);
    
    });
    add-method(RakuAST::Statement::Whenever, 'IMPL-TO-QAST', [RakuAST::Statement::Whenever, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1305 src/Raku/ast/statements.rakumod
        
        QAST::Op.new(:op<call>, :name<&WHENEVER>,
          QAST::Op.new(:op<hllize>,
            nqp::getattr($SELF, RakuAST::Statement::Whenever, '$!trigger').IMPL-TO-QAST($context)
          ),
          nqp::getattr($SELF, RakuAST::Statement::Whenever, '$!body').IMPL-TO-QAST($context)
        )
    
    });
    add-method(RakuAST::Statement::Whenever, 'visit-children', [RakuAST::Statement::Whenever, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1314 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Whenever, '$!trigger'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Whenever, '$!body'));
        $SELF.visit-labels($visitor);
    
    });
#line 1281 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Whenever, 'trigger', [], anon sub trigger ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Whenever, '$!trigger') });
#line 1282 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Whenever, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Whenever, '$!body') });
    compose(RakuAST::Statement::Whenever);
    parent(RakuAST::Statement::Default, RakuAST::Statement);
    parent(RakuAST::Statement::Default, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::Default, RakuAST::ImplicitBlockSemanticsProvider);
    parent(RakuAST::Statement::Default, RakuAST::Attaching);
    add-attribute(RakuAST::Statement::Default, RakuAST::Block, '$!body');
    add-method(RakuAST::Statement::Default, 'new', [RakuAST::Statement::Default, '', 0, 0, RakuAST::Block, '$body', 1, 0, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$body!, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $body := nqp::decont($body);
        $labels := nqp::decont($labels);
#line 1330 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Default, '$!body', $body);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Default, 'apply-implicit-block-semantics', [RakuAST::Statement::Default, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1337 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Default, '$!body').set-implicit-topic(1);
    
    });
    add-method(RakuAST::Statement::Default, 'propagate-sink', [RakuAST::Statement::Default, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 1341 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::Default, '$!body').body.apply-sink((Bool.WHO)<False>); # Used as enclosing block outcome
    
    });
    add-method(RakuAST::Statement::Default, 'attach', [RakuAST::Statement::Default, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1345 src/Raku/ast/statements.rakumod
        
        my $block := $resolver.find-attach-target('block') //
            $resolver.find-attach-target('compunit');
        if $block {
            $block.require-succeed-handler();
        }
        else {
            nqp::die('default found no enclosing block to attach to');
        }
    
    });
    add-method(RakuAST::Statement::Default, 'IMPL-TO-QAST', [RakuAST::Statement::Default, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1356 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-WHEN-OR-DEFAULT($context,
            QAST::Op.new( :op('call'), nqp::getattr($SELF, RakuAST::Statement::Default, '$!body').IMPL-TO-QAST($context) )
        )
    
    });
    add-method(RakuAST::Statement::Default, 'visit-children', [RakuAST::Statement::Default, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1362 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Default, '$!body'));
        $SELF.visit-labels($visitor);
    
    });
#line 1328 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Default, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Default, '$!body') });
    compose(RakuAST::Statement::Default);
    parent(RakuAST::Statement::ExceptionHandler, RakuAST::Statement);
    parent(RakuAST::Statement::ExceptionHandler, RakuAST::SinkPropagator);
    parent(RakuAST::Statement::ExceptionHandler, RakuAST::ImplicitBlockSemanticsProvider);
    parent(RakuAST::Statement::ExceptionHandler, RakuAST::ProducesNil);
    add-attribute(RakuAST::Statement::ExceptionHandler, RakuAST::Block, '$!body');
    add-method(RakuAST::Statement::ExceptionHandler, 'new', [RakuAST::Statement::ExceptionHandler, '', 0, 0, RakuAST::Block, '$body', 1, 0], anon sub new ($SELF_CONT, :$body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $body := nqp::decont($body);
#line 1377 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::ExceptionHandler, '$!body', $body);
        $obj.set-labels(Mu);
        $obj
    
    });
    add-method(RakuAST::Statement::ExceptionHandler, 'apply-implicit-block-semantics', [RakuAST::Statement::ExceptionHandler, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1384 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::ExceptionHandler, '$!body').set-implicit-topic((Bool.WHO)<True>, :exception);
        nqp::getattr($SELF, RakuAST::Statement::ExceptionHandler, '$!body').set-fresh-variables(:match, :exception);
    
    });
    add-method(RakuAST::Statement::ExceptionHandler, 'propagate-sink', [RakuAST::Statement::ExceptionHandler, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 1389 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Statement::ExceptionHandler, '$!body').body.apply-sink((Bool.WHO)<True>);
    
    });
    add-method(RakuAST::Statement::ExceptionHandler, 'visit-children', [RakuAST::Statement::ExceptionHandler, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1393 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::ExceptionHandler, '$!body'));
        $SELF.visit-labels($visitor);
    
    });
#line 1375 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::ExceptionHandler, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::ExceptionHandler, '$!body') });
    compose(RakuAST::Statement::ExceptionHandler);
    parent(RakuAST::Statement::Catch, RakuAST::Statement::ExceptionHandler);
    parent(RakuAST::Statement::Catch, RakuAST::Attaching);
    add-method(RakuAST::Statement::Catch, 'attach', [RakuAST::Statement::Catch, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1404 src/Raku/ast/statements.rakumod
        
        my $block := $resolver.find-attach-target('block') //
            $resolver.find-attach-target('compunit');
        if $block {
            $block.attach-catch-handler($SELF);
        }
        else {
            nqp::die('CATCH found no enclosing block to attach to');
        }
    
    });
    compose(RakuAST::Statement::Catch);
    parent(RakuAST::Statement::Control, RakuAST::Statement::ExceptionHandler);
    parent(RakuAST::Statement::Control, RakuAST::Attaching);
    add-method(RakuAST::Statement::Control, 'attach', [RakuAST::Statement::Control, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1421 src/Raku/ast/statements.rakumod
        
        my $block := $resolver.find-attach-target('block') //
            $resolver.find-attach-target('compunit');
        if $block {
            $block.attach-control-handler($SELF);
        }
        else {
            nqp::die('CONTROL found no enclosing block to attach to');
        }
    
    });
    compose(RakuAST::Statement::Control);
    parent(RakuAST::Categorical, Any);
    add-attribute(RakuAST::Categorical, Str, '$!category');
    add-attribute(RakuAST::Categorical, Str, '$!opname');
    add-attribute(RakuAST::Categorical, Str, '$!subname');
    add-attribute(RakuAST::Categorical, RakuAST::Declaration, '$!declarand');
    add-method(RakuAST::Categorical, 'new', [RakuAST::Categorical, '', 0, 0, Str, '$category', 1, 0, Str, '$opname', 1, 0, Str, '$subname', 1, 0, RakuAST::Declaration, '$declarand', 1, 0], anon sub new ($SELF_CONT, :$category!, :$opname!, :$subname!, :$declarand!) {
        my $SELF := nqp::decont($SELF_CONT);
        $category := nqp::decont($category);
        $opname := nqp::decont($opname);
        $subname := nqp::decont($subname);
        $declarand := nqp::decont($declarand);
#line 1439 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Categorical, '$!category', $category);
        nqp::bindattr($obj, RakuAST::Categorical, '$!opname', $opname);
        nqp::bindattr($obj, RakuAST::Categorical, '$!subname', $subname);
        nqp::bindattr($obj, RakuAST::Categorical, '$!declarand', $declarand);
        $obj
    
    });
    add-method(RakuAST::Categorical, 'canname', [RakuAST::Categorical, '', 0, 0], anon sub canname ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1448 src/Raku/ast/statements.rakumod
        
        nqp::getattr($SELF, RakuAST::Categorical, '$!category') ~ ':sym' ~ RakuAST::ColonPairish.IMPL-QUOTE-VALUE(nqp::getattr($SELF, RakuAST::Categorical, '$!opname'));
    
    });
#line 1436 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Categorical, 'subname', [], anon sub subname ($self) { nqp::getattr(nqp::decont($self), RakuAST::Categorical, '$!subname') });
#line 1435 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Categorical, 'opname', [], anon sub opname ($self) { nqp::getattr(nqp::decont($self), RakuAST::Categorical, '$!opname') });
#line 1437 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Categorical, 'declarand', [], anon sub declarand ($self) { nqp::getattr(nqp::decont($self), RakuAST::Categorical, '$!declarand') });
#line 1434 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Categorical, 'category', [], anon sub category ($self) { nqp::getattr(nqp::decont($self), RakuAST::Categorical, '$!category') });
    compose(RakuAST::Categorical);
    parent(RakuAST::ModuleLoading, Any);
    add-attribute(RakuAST::ModuleLoading, List, '$!categoricals');
    add-method(RakuAST::ModuleLoading, 'categoricals', [RakuAST::ModuleLoading, '', 0, 0], anon sub categoricals ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1456 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::ModuleLoading, '$!categoricals'))
    
    });
    add-method(RakuAST::ModuleLoading, 'IMPL-LOAD-MODULE', [RakuAST::ModuleLoading, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::Name, '$module-name', 0, 0], anon sub IMPL-LOAD-MODULE ($SELF_CONT, $resolver!, $module-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $module-name := nqp::decont($module-name);
#line 1460 src/Raku/ast/statements.rakumod
        
        # Build dependency specification for the module.
        my $dependency-specification := $resolver.resolve-name-constant(
            RakuAST::Name.from-identifier-parts('CompUnit', 'DependencySpecification')
        ).compile-time-value;
        my $opts := nqp::hash();
        for $module-name.colonpairs {
            $opts{$_.key} := $_.simple-compile-time-quote-value;
        }
        my $spec := $dependency-specification.new(
            :short-name($module-name.canonicalize(:colonpairs((Bool.WHO)<False>))),
            :from($opts<from> // 'Perl6'),
            :auth-matcher($opts<auth> // (Bool.WHO)<True>),
            :api-matcher($opts<api> // (Bool.WHO)<True>),
            :version-matcher($opts<ver> // (Bool.WHO)<True>),
        );

        # Load it using the registry.
        my $registry := $resolver.resolve-name-constant(
            RakuAST::Name.from-identifier-parts('CompUnit', 'RepositoryRegistry')
        ).compile-time-value;
        my $comp-unit := $registry.head.need($spec);
        my $globalish := $comp-unit.handle.globalish-package;
        $SELF.IMPL-IMPORT-ONE($resolver, $SELF.IMPL-STASH-HASH($globalish));
        $comp-unit
    
    });
    add-method(RakuAST::ModuleLoading, 'IMPL-IMPORT', [RakuAST::ModuleLoading, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, Mu, '$handle', 0, 0, Mu, '$arglist', 0, 0], anon sub IMPL-IMPORT ($SELF_CONT, $resolver!, $handle!, $arglist!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $handle := nqp::decont($handle);
        $arglist := nqp::decont($arglist);
#line 1487 src/Raku/ast/statements.rakumod
        
        my $EXPORT := $handle.export-package;
        if nqp::isconcrete($EXPORT) {
            $EXPORT := $EXPORT.FLATTENABLE_HASH();
            # TODO deal with non-default imports due to tags
            my @to-import := ['MANDATORY'];
            my @positional-imports;
            if nqp::isconcrete($arglist) {
                my $Pair := $resolver.setting-constant('Pair');
                for $arglist -> $tag {
                    if nqp::istype($tag, $Pair) {
                        my str $tag-name := nqp::unbox_s($tag.key);
                        unless nqp::existskey($EXPORT, $tag-name) {
                            # TODO X::Import::NoSuchTag
                            nqp::die('No such tag')
                        }
                        nqp::push(@to-import, $tag-name);
                    }
                    else {
                        nqp::push(@positional-imports, $tag);
                    }
                }
            }
            else {
                nqp::push(@to-import, 'DEFAULT');
            }
            for @to-import -> str $tag {
                if nqp::existskey($EXPORT, $tag) {
                    $SELF.IMPL-IMPORT-ONE($resolver, $SELF.IMPL-STASH-HASH($EXPORT{$tag}.WHO));
                }
            }

            my &EXPORT := $handle.export-sub;
            if nqp::isconcrete(&EXPORT) {
                my $result := &EXPORT(|@positional-imports);
                if nqp::istype($result, Map) {
                    my $storage := $result.hash.FLATTENABLE_HASH();
                    $SELF.IMPL-IMPORT-ONE(
                        $resolver,
                        $storage,
                        :need-decont(!(nqp::what($result) =:= Map)),
                    );
                }
                else {
                    nqp::die("&EXPORT sub did not return a Map");
                }
            }
        }
    
    });
    add-method(RakuAST::ModuleLoading, 'IMPL-IMPORT-ONE', [RakuAST::ModuleLoading, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, Mu, '$stash', 0, 0, Bool, '$need-decont', 1, 1], anon sub IMPL-IMPORT-ONE ($SELF_CONT, $resolver!, $stash!, :$need-decont?) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $stash := nqp::decont($stash);
        $need-decont := nqp::decont($need-decont);
#line 1537 src/Raku/ast/statements.rakumod
        
        my $target-scope := $resolver.current-scope;
        for $SELF.IMPL-SORTED-KEYS($stash) -> $key {
            next if $key eq 'EXPORT';
            my $value := $stash{$key};
            if $need-decont && nqp::islt_i(nqp::index('$&', nqp::substr($key,0,1)),0) {
                $value := nqp::decont($value);
            }
            my $declarand := RakuAST::Declaration::Import.new:
                    :lexical-name($key), :compile-time-value($value);
            $target-scope.merge-generated-lexical-declaration: $declarand, :$resolver;

            my $categorical := $key ~~ /^ '&' (\w+) [ ':<' (.+) '>' | ':«' (.+) '»' ] $/;
            if $categorical {
                nqp::push(nqp::getattr($SELF, RakuAST::ModuleLoading, '$!categoricals'), RakuAST::Categorical.new(
                    :category($categorical[0]),
                    :opname($categorical[1]),
                    :subname(nqp::substr($key, 1)),
                    :$declarand
                ));
            }
        }
    
    });
    add-method(RakuAST::ModuleLoading, 'IMPL-STASH-HASH', [RakuAST::ModuleLoading, '', 0, 0, Mu, '$pkg', 0, 0], anon sub IMPL-STASH-HASH ($SELF_CONT, $pkg!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pkg := nqp::decont($pkg);
#line 1561 src/Raku/ast/statements.rakumod
        
        my $hash := $pkg;
        unless nqp::ishash($hash) {
            $hash := $hash.FLATTENABLE_HASH();
        }
        $hash
    
    });
    compose(RakuAST::ModuleLoading);
    parent(RakuAST::Statement::Use, RakuAST::Statement);
    parent(RakuAST::Statement::Use, RakuAST::BeginTime);
    parent(RakuAST::Statement::Use, RakuAST::ProducesNil);
    parent(RakuAST::Statement::Use, RakuAST::ModuleLoading);
    add-attribute(RakuAST::Statement::Use, RakuAST::Name, '$!module-name');
    add-attribute(RakuAST::Statement::Use, RakuAST::Expression, '$!argument');
    add-method(RakuAST::Statement::Use, 'new', [RakuAST::Statement::Use, '', 0, 0, RakuAST::Name, '$module-name', 1, 0, RakuAST::Expression, '$argument', 1, 1, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$module-name!, :$argument?, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $module-name := nqp::decont($module-name);
        $argument := nqp::decont($argument);
        $labels := nqp::decont($labels);
#line 1580 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Use, '$!module-name', $module-name);
        nqp::bindattr($obj, RakuAST::ModuleLoading, '$!categoricals', []);
        nqp::bindattr($obj, RakuAST::Statement::Use, '$!argument',
            $argument // RakuAST::Expression);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Use, 'PERFORM-BEGIN', [RakuAST::Statement::Use, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1590 src/Raku/ast/statements.rakumod
        
        # Evaluate the argument to the module load, if any.
        my $arglist := nqp::getattr($SELF, RakuAST::Statement::Use, '$!argument')
            ?? $SELF.IMPL-BEGIN-TIME-EVALUATE(nqp::getattr($SELF, RakuAST::Statement::Use, '$!argument'), $resolver, $context).List.FLATTENABLE_LIST
            !! Nil;

        my $comp-unit := $SELF.IMPL-LOAD-MODULE($resolver, nqp::getattr($SELF, RakuAST::Statement::Use, '$!module-name'));
        $SELF.IMPL-IMPORT($resolver, $comp-unit.handle, $arglist);
    
    });
    add-method(RakuAST::Statement::Use, 'visit-children', [RakuAST::Statement::Use, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1600 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Use, '$!module-name'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Use, '$!argument')) if nqp::getattr($SELF, RakuAST::Statement::Use, '$!argument');
        $SELF.visit-labels($visitor);
    
    });
#line 1577 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Use, 'module-name', [], anon sub module-name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Use, '$!module-name') });
#line 1578 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Use, 'argument', [], anon sub argument ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Use, '$!argument') });
    compose(RakuAST::Statement::Use);
    parent(RakuAST::Statement::Need, RakuAST::Statement);
    parent(RakuAST::Statement::Need, RakuAST::BeginTime);
    parent(RakuAST::Statement::Need, RakuAST::ProducesNil);
    parent(RakuAST::Statement::Need, RakuAST::ModuleLoading);
    add-attribute(RakuAST::Statement::Need, List, '$!module-names');
    add-method(RakuAST::Statement::Need, 'new', [RakuAST::Statement::Need, '', 0, 0, List, '$module-names', 1, 0, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$module-names!, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $module-names := nqp::decont($module-names);
        $labels := nqp::decont($labels);
#line 1616 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Need, '$!module-names',
          $SELF.IMPL-UNWRAP-LIST($module-names));
        nqp::bindattr($obj, RakuAST::ModuleLoading, '$!categoricals', []);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Need, 'PERFORM-BEGIN', [RakuAST::Statement::Need, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1625 src/Raku/ast/statements.rakumod
        
        for nqp::getattr($SELF, RakuAST::Statement::Need, '$!module-names') {
            $SELF.IMPL-LOAD-MODULE($resolver, $_);
        }
    
    });
    add-method(RakuAST::Statement::Need, 'module-names', [RakuAST::Statement::Need, '', 0, 0], anon sub module-names ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1631 src/Raku/ast/statements.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Statement::Need, '$!module-names')) 
    });
    add-method(RakuAST::Statement::Need, 'visit-children', [RakuAST::Statement::Need, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1633 src/Raku/ast/statements.rakumod
        
        for nqp::getattr($SELF, RakuAST::Statement::Need, '$!module-names') {
            $visitor($_);
        }
        $SELF.visit-labels($visitor);
    
    });
    compose(RakuAST::Statement::Need);
    parent(RakuAST::Statement::Import, RakuAST::Statement);
    parent(RakuAST::Statement::Import, RakuAST::BeginTime);
    parent(RakuAST::Statement::Import, RakuAST::ProducesNil);
    parent(RakuAST::Statement::Import, RakuAST::ModuleLoading);
    parent(RakuAST::Statement::Import, RakuAST::Lookup);
    parent(RakuAST::Statement::Import, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Statement::Import, RakuAST::Name, '$!module-name');
    add-attribute(RakuAST::Statement::Import, RakuAST::Expression, '$!argument');
    add-method(RakuAST::Statement::Import, 'new', [RakuAST::Statement::Import, '', 0, 0, RakuAST::Name, '$module-name', 1, 0, RakuAST::Expression, '$argument', 1, 1, List, '$labels', 1, 1], anon sub new ($SELF_CONT, :$module-name!, :$argument?, :$labels?) {
        my $SELF := nqp::decont($SELF_CONT);
        $module-name := nqp::decont($module-name);
        $argument := nqp::decont($argument);
        $labels := nqp::decont($labels);
#line 1653 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Import, '$!module-name', $module-name);
        nqp::bindattr($obj, RakuAST::ModuleLoading, '$!categoricals', []);
        nqp::bindattr($obj, RakuAST::Statement::Import, '$!argument',
            $argument // RakuAST::Expression);
        $obj.set-labels($labels);
        $obj
    
    });
    add-method(RakuAST::Statement::Import, 'resolve-with', [RakuAST::Statement::Import, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1663 src/Raku/ast/statements.rakumod
        
        my $resolved := $resolver.resolve-name-constant(nqp::getattr($SELF, RakuAST::Statement::Import, '$!module-name'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Statement::Import, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Statement::Import, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1671 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier-parts('CompUnit', 'Handle')),
        ])
    
    });
    add-method(RakuAST::Statement::Import, 'PERFORM-BEGIN', [RakuAST::Statement::Import, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1677 src/Raku/ast/statements.rakumod
        
        # Evaluate the argument to the import, if any.
        my $arglist := nqp::getattr($SELF, RakuAST::Statement::Import, '$!argument')
            ?? $SELF.IMPL-BEGIN-TIME-EVALUATE(nqp::getattr($SELF, RakuAST::Statement::Import, '$!argument'), $resolver, $context).List.FLATTENABLE_LIST
            !! Nil;

        my $module := $SELF.resolution.compile-time-value;
        my $CompUnitHandle := $SELF.get-implicit-lookups().AT-POS(0).compile-time-value;
        my $handle := $CompUnitHandle.from-unit($module.WHO);
        $SELF.IMPL-IMPORT($resolver, $handle, $arglist);
    
    });
    add-method(RakuAST::Statement::Import, 'visit-children', [RakuAST::Statement::Import, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1689 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Import, '$!module-name'));
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Import, '$!argument')) if nqp::getattr($SELF, RakuAST::Statement::Import, '$!argument');
        $SELF.visit-labels($visitor);
    
    });
#line 1650 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Import, 'module-name', [], anon sub module-name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Import, '$!module-name') });
#line 1651 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Import, 'argument', [], anon sub argument ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Import, '$!argument') });
    compose(RakuAST::Statement::Import);
    parent(RakuAST::Statement::Require, RakuAST::Statement);
    parent(RakuAST::Statement::Require, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Statement::Require, RakuAST::Name, '$!module-name');
    add-method(RakuAST::Statement::Require, 'new', [RakuAST::Statement::Require, '', 0, 0, RakuAST::Name, '$module-name', 1, 0], anon sub new ($SELF_CONT, :$module-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $module-name := nqp::decont($module-name);
#line 1703 src/Raku/ast/statements.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Statement::Require, '$!module-name', $module-name);
        $obj
    
    });
    add-method(RakuAST::Statement::Require, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Statement::Require, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1709 src/Raku/ast/statements.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier-parts('CompUnit', 'DependencySpecification')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier-parts('CompUnit', 'RepositoryRegistry')),
        ])
    
    });
    add-method(RakuAST::Statement::Require, 'IMPL-TO-QAST', [RakuAST::Statement::Require, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1716 src/Raku/ast/statements.rakumod
        
        my $lookups := $SELF.get-implicit-lookups;
        my $depspec  := $lookups.AT-POS(0).compile-time-value;
        my $registry := $lookups.AT-POS(1).compile-time-value;
        my $short-name := QAST::SVal.new(:value(nqp::getattr($SELF, RakuAST::Statement::Require, '$!module-name').canonicalize));
        $short-name.named('short-name');

        my $spec := QAST::Op.new(
            :op('callmethod'), :name('new'),
            QAST::WVal.new(:value($depspec)),
            $short-name,
        );
        my $compunit_past := QAST::Op.new(
            :op('callmethod'), :name('need'),
            QAST::Op.new(
                :op('callmethod'), :name('head'),
                QAST::WVal.new(:value($registry)),
            ),
            $spec,
        );
    
    });
    add-method(RakuAST::Statement::Require, 'visit-children', [RakuAST::Statement::Require, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1738 src/Raku/ast/statements.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Statement::Require, '$!module-name'));
    
    });
#line 1701 src/Raku/ast/statements.rakumod
    add-method(RakuAST::Statement::Require, 'module-name', [], anon sub module-name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Statement::Require, '$!module-name') });
    compose(RakuAST::Statement::Require);
    parent(OperatorProperties, Any);
    add-attribute(OperatorProperties, str, '$!precedence');
    add-attribute(OperatorProperties, str, '$!sub-precedence');
    add-attribute(OperatorProperties, str, '$!associative');
    add-attribute(OperatorProperties, str, '$!thunky');
    add-attribute(OperatorProperties, str, '$!dba');
    add-attribute(OperatorProperties, str, '$!next-term');
    add-attribute(OperatorProperties, int, '$!iffy');
    add-attribute(OperatorProperties, int, '$!diffy');
    add-attribute(OperatorProperties, int, '$!fiddly');
    add-attribute(OperatorProperties, int, '$!adverb');
    add-attribute(OperatorProperties, int, '$!ternary');
    add-method(OperatorProperties, 'new', [OperatorProperties, '', 0, 0, str, '$precedence', 1, 1, str, '$sub-precedence', 1, 1, str, '$associative', 1, 1, str, '$thunky', 1, 1, str, '$dba', 1, 1, str, '$next-term', 1, 1, int, '$iffy', 1, 1, int, '$diffy', 1, 1, int, '$fiddly', 1, 1, int, '$adverb', 1, 1, int, '$ternary', 1, 1], anon sub new ($SELF_CONT, :$precedence?, :$sub-precedence?, :$associative?, :$thunky?, :$dba?, :$next-term?, :$iffy?, :$diffy?, :$fiddly?, :$adverb?, :$ternary?) {
        my $SELF := nqp::decont($SELF_CONT);
        $precedence := nqp::decont($precedence);
        $sub-precedence := nqp::decont($sub-precedence);
        $associative := nqp::decont($associative);
        $thunky := nqp::decont($thunky);
        $dba := nqp::decont($dba);
        $next-term := nqp::decont($next-term);
        $iffy := nqp::decont($iffy);
        $diffy := nqp::decont($diffy);
        $fiddly := nqp::decont($fiddly);
        $adverb := nqp::decont($adverb);
        $ternary := nqp::decont($ternary);
#line 43 src/Raku/ast/operator-properties.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj,OperatorProperties,'$!precedence',
          $precedence // (nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!precedence') !! ""));
        nqp::bindattr_s($obj,OperatorProperties,'$!sub-precedence',
          $sub-precedence // (nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!sub-precedence') !! ""));
        nqp::bindattr_s($obj,OperatorProperties,'$!associative',
          $associative // (nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!associative') !! ""));
        nqp::bindattr_s($obj,OperatorProperties,'$!thunky',
          $thunky // (nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!thunky') !! ""));
        nqp::bindattr_s($obj,OperatorProperties,'$!dba',
          $dba // (nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!dba') !! ""));
        nqp::bindattr_s($obj,OperatorProperties,'$!next-term',
          $next-term // (nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!next-term') !! ""));

        nqp::bindattr_i($obj,OperatorProperties,'$!iffy',
          $iffy // (nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!iffy') !! 0));
        nqp::bindattr_i($obj,OperatorProperties,'$!diffy',
          $diffy // (nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!diffy') !! 0));
        nqp::bindattr_i($obj,OperatorProperties,'$!fiddly',
          $fiddly // (nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!fiddly') !! 0));
        nqp::bindattr_i($obj,OperatorProperties,'$!adverb',
          $adverb // (nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!adverb') !! 0));
        nqp::bindattr_i($obj,OperatorProperties,'$!ternary',
          $ternary // (nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!ternary') !! 0));

        $obj
    
    });
    add-method(OperatorProperties, 'new-compat', [OperatorProperties, '', 0, 0, str, '$prec', 1, 1, str, '$sub', 1, 1, str, '$assoc', 1, 1, str, '$thunky', 1, 1, str, '$dba', 1, 1, str, '$nextterm', 1, 1, int, '$iffy', 1, 1, int, '$diffy', 1, 1, int, '$fiddly', 1, 1, int, '$adverb', 1, 1, int, '$ternary', 1, 1, Any, '%_', 0, 0], anon sub new-compat ($SELF_CONT, :$prec?, :$sub?, :$assoc?, :$thunky?, :$dba?, :$nextterm?, :$iffy?, :$diffy?, :$fiddly?, :$adverb?, :$ternary?, *%_) {
        my $SELF := nqp::decont($SELF_CONT);
        $prec := nqp::decont($prec);
        $sub := nqp::decont($sub);
        $assoc := nqp::decont($assoc);
        $thunky := nqp::decont($thunky);
        $dba := nqp::decont($dba);
        $nextterm := nqp::decont($nextterm);
        $iffy := nqp::decont($iffy);
        $diffy := nqp::decont($diffy);
        $fiddly := nqp::decont($fiddly);
        $adverb := nqp::decont($adverb);
        $ternary := nqp::decont($ternary);
        %_ := nqp::decont(%_);
#line 86 src/Raku/ast/operator-properties.rakumod
        
        $SELF.new(
          :precedence($prec),
          :sub-precedence($sub),
          :associative($assoc),
          :$thunky,
          :$dba,
          :next-term($nextterm),
          :$iffy,
          :$diffy,
          :$fiddly,
          :$adverb,
          :$ternary
        )
    
    });
    add-method(OperatorProperties, 'associative-reversed', [OperatorProperties, '', 0, 0], anon sub associative-reversed ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 103 src/Raku/ast/operator-properties.rakumod
        
        nqp::isconcrete($SELF)
          ?? nqp::getattr_s($SELF, OperatorProperties, '$!associative') eq 'left'
            ?? $SELF.new(:associative<right>, :dba("reversed " ~ nqp::getattr_s($SELF, OperatorProperties, '$!dba')))
            !! nqp::getattr_s($SELF, OperatorProperties, '$!associative') eq 'right'
              ?? $SELF.new(:associative<left>, :dba("reversed " ~ nqp::getattr_s($SELF, OperatorProperties, '$!dba')))
              !! $SELF
          !! $SELF
    
    });
    add-method(OperatorProperties, 'raku', [OperatorProperties, '', 0, 0], anon sub raku ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 114 src/Raku/ast/operator-properties.rakumod
        
        my str $name := $SELF.HOW.name($SELF);
        return $name unless nqp::isconcrete($SELF);

        my $parts := nqp::list_s;

        nqp::push_s($parts,':precedence("' ~ nqp::getattr_s($SELF, OperatorProperties, '$!precedence') ~ '")')
          if nqp::getattr_s($SELF, OperatorProperties, '$!precedence');
        nqp::push_s($parts,':sub-precedence("' ~ nqp::getattr_s($SELF, OperatorProperties, '$!sub-precedence') ~ '")')
          if nqp::getattr_s($SELF, OperatorProperties, '$!sub-precedence');
        nqp::push_s($parts,':associative("' ~ nqp::getattr_s($SELF, OperatorProperties, '$!associative') ~ '")')
          if nqp::getattr_s($SELF, OperatorProperties, '$!associative');
        nqp::push_s($parts,':thunky("' ~ nqp::getattr_s($SELF, OperatorProperties, '$!thunky') ~ '")')
          if nqp::getattr_s($SELF, OperatorProperties, '$!thunky');
        nqp::push_s($parts,':dba("' ~ nqp::getattr_s($SELF, OperatorProperties, '$!dba') ~ '")')
          if nqp::getattr_s($SELF, OperatorProperties, '$!dba');
        nqp::push_s($parts,':next-term("' ~ nqp::getattr_s($SELF, OperatorProperties, '$!next-term') ~ '")')
          if nqp::getattr_s($SELF, OperatorProperties, '$!next-term');

        nqp::push_s($parts,':iffy')    if nqp::getattr_i($SELF, OperatorProperties, '$!iffy');
        nqp::push_s($parts,':diffy')   if nqp::getattr_i($SELF, OperatorProperties, '$!diffy');
        nqp::push_s($parts,':fiddly')  if nqp::getattr_i($SELF, OperatorProperties, '$!fiddly');
        nqp::push_s($parts,':adverb')  if nqp::getattr_i($SELF, OperatorProperties, '$!adverb');
        nqp::push_s($parts,':ternary') if nqp::getattr_i($SELF, OperatorProperties, '$!ternary');

        $name ~ '.new: ' ~ nqp::join(', ',$parts)
    
    });
    add-method(OperatorProperties, 'bracket-openers', [OperatorProperties, '', 0, 0], anon sub bracket-openers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 146 src/Raku/ast/operator-properties.rakumod
        
        my constant OPENERS :=
            "\x0028\x003C\x005B\x007B\x00AB\x0F3A\x0F3C\x169B\x2018\x201A"
          ~ "\x201B\x201C\x201E\x201F\x2039\x2045\x207D\x208D\x2208\x2209"
          ~ "\x220A\x2215\x223C\x2243\x2252\x2254\x2264\x2266\x2268\x226A"
          ~ "\x226E\x2270\x2272\x2274\x2276\x2278\x227A\x227C\x227E\x2280"
          ~ "\x2282\x2284\x2286\x2288\x228A\x228F\x2291\x2298\x22A2\x22A6"
          ~ "\x22A8\x22A9\x22AB\x22B0\x22B2\x22B4\x22B6\x22C9\x22CB\x22D0"
          ~ "\x22D6\x22D8\x22DA\x22DC\x22DE\x22E0\x22E2\x22E4\x22E6\x22E8"
          ~ "\x22EA\x22EC\x22F0\x22F2\x22F3\x22F4\x22F6\x22F7\x2308\x230A"
          ~ "\x23B4\x2768\x276A\x276C\x276E\x2770\x2772\x2774\x27C3\x27C5"
          ~ "\x27D5\x27DD\x27E2\x27E4\x27E6\x27E8\x27EA\x27EC\x27EE\x2983"
          ~ "\x2985\x2987\x2989\x298B\x298D\x298F\x2991\x2993\x2995\x2997"
          ~ "\x29C0\x29C4\x29CF\x29D1\x29D4\x29D8\x29DA\x29F8\x29FC\x2A2B"
          ~ "\x2A2D\x2A34\x2A3C\x2A64\x2A79\x2A7D\x2A7F\x2A81\x2A83\x2A8B"
          ~ "\x2A91\x2A93\x2A95\x2A97\x2A99\x2A9B\x2AA1\x2AA6\x2AA8\x2AAA"
          ~ "\x2AAC\x2AAF\x2AB3\x2ABB\x2ABD\x2ABF\x2AC1\x2AC3\x2AC5\x2ACD"
          ~ "\x2ACF\x2AD1\x2AD3\x2AD5\x2AEC\x2AF7\x2AF9\x2E02\x2E04\x2E09"
          ~ "\x2E0C\x2E1C\x2E20\x2E22\x2E24\x2E26\x2E28\x3008\x3008\x300A"
          ~ "\x300C\x300E\x3010\x3014\x3016\x3018\x301A\x301D\xFE17\xFE35"
          ~ "\xFE37\xFE39\xFE3B\xFE3D\xFE3F\xFE41\xFE43\xFE47\xFE59\xFE5B"
          ~ "\xFE5D\xFF08\xFF1C\xFF3B\xFF5B\xFF5F\xFF62"
        ;
    
    });
    add-method(OperatorProperties, 'bracket-closers', [OperatorProperties, '', 0, 0], anon sub bracket-closers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 172 src/Raku/ast/operator-properties.rakumod
        
        my constant CLOSERS :=
            "\x0029\x003E\x005D\x007D\x00BB\x0F3B\x0F3D\x169C\x2019\x2019"
          ~ "\x2019\x201D\x201D\x201D\x203A\x2046\x207E\x208E\x220B\x220C"
          ~ "\x220D\x29F5\x223D\x22CD\x2253\x2255\x2265\x2267\x2269\x226B"
          ~ "\x226F\x2271\x2273\x2275\x2277\x2279\x227B\x227D\x227F\x2281"
          ~ "\x2283\x2285\x2287\x2289\x228B\x2290\x2292\x29B8\x22A3\x2ADE"
          ~ "\x2AE4\x2AE3\x2AE5\x22B1\x22B3\x22B5\x22B7\x22CA\x22CC\x22D1"
          ~ "\x22D7\x22D9\x22DB\x22DD\x22DF\x22E1\x22E3\x22E5\x22E7\x22E9"
          ~ "\x22EB\x22ED\x22F1\x22FA\x22FB\x22FC\x22FD\x22FE\x2309\x230B"
          ~ "\x23B5\x2769\x276B\x276D\x276F\x2771\x2773\x2775\x27C4\x27C6"
          ~ "\x27D6\x27DE\x27E3\x27E5\x27E7\x27E9\x27EB\x27ED\x27EF\x2984"
          ~ "\x2986\x2988\x298A\x298C\x2990\x298E\x2992\x2994\x2996\x2998"
          ~ "\x29C1\x29C5\x29D0\x29D2\x29D5\x29D9\x29DB\x29F9\x29FD\x2A2C"
          ~ "\x2A2E\x2A35\x2A3D\x2A65\x2A7A\x2A7E\x2A80\x2A82\x2A84\x2A8C"
          ~ "\x2A92\x2A94\x2A96\x2A98\x2A9A\x2A9C\x2AA2\x2AA7\x2AA9\x2AAB"
          ~ "\x2AAD\x2AB0\x2AB4\x2ABC\x2ABE\x2AC0\x2AC2\x2AC4\x2AC6\x2ACE"
          ~ "\x2AD0\x2AD2\x2AD4\x2AD6\x2AED\x2AF8\x2AFA\x2E03\x2E05\x2E0A"
          ~ "\x2E0D\x2E1D\x2E21\x2E23\x2E25\x2E27\x2E29\x3009\x3009\x300B"
          ~ "\x300D\x300F\x3011\x3015\x3017\x3019\x301B\x301E\xFE18\xFE36"
          ~ "\xFE38\xFE3A\xFE3C\xFE3E\xFE40\xFE42\xFE44\xFE48\xFE5A\xFE5C"
          ~ "\xFE5E\xFF09\xFF1E\xFF3D\xFF5D\xFF60\xFF63"
        ;
    
    });
    add-method(OperatorProperties, 'bracket-closer-for-opener', [OperatorProperties, '', 0, 0, str, '$opener', 0, 0], anon sub bracket-closer-for-opener ($SELF_CONT, $opener!) {
        my $SELF := nqp::decont($SELF_CONT);
        $opener := nqp::decont($opener);
#line 198 src/Raku/ast/operator-properties.rakumod
        
        (my int $index := nqp::index($SELF.bracket-openers,$opener)) < 0
          ?? Nil
          !! nqp::substr($SELF.bracket-closers,$index,1)
    
    });
    add-method(OperatorProperties, 'bracket-opener-for-closer', [OperatorProperties, '', 0, 0, str, '$closer', 0, 0], anon sub bracket-opener-for-closer ($SELF_CONT, $closer!) {
        my $SELF := nqp::decont($SELF_CONT);
        $closer := nqp::decont($closer);
#line 207 src/Raku/ast/operator-properties.rakumod
        
        (my int $index := nqp::index($SELF.bracket-closers,$closer)) < 0
          ?? Nil
          !! nqp::substr($SELF.bracket-openers,$index,1)
    
    });
    add-method(OperatorProperties, 'reserved-operators-lookup', [OperatorProperties, '', 0, 0], anon sub reserved-operators-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 217 src/Raku/ast/operator-properties.rakumod
        
        my constant RESERVED := nqp::hash(
          'infix:sym<=>',   "",
          'infix:sym<:=>',  "",
          'infix:sym<::=>', "",
          'infix:sym<~~>',  "(consider implementing an ACCEPTS method)",
          'prefix:sym<|>',  ""
        )
    
    });
    add-method(OperatorProperties, 'is-reserved-operator', [OperatorProperties, '', 0, 0, str, '$operator', 0, 0], anon sub is-reserved-operator ($SELF_CONT, $operator!) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 228 src/Raku/ast/operator-properties.rakumod
        
        nqp::existskey($SELF.reserved-operators-lookup,$operator)
    
    });
    add-method(OperatorProperties, 'reserved-operator-hint', [OperatorProperties, '', 0, 0, str, '$operator', 0, 0], anon sub reserved-operator-hint ($SELF_CONT, $operator!) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 233 src/Raku/ast/operator-properties.rakumod
        
        nqp::atkey($SELF.reserved-operators-lookup,$operator)
    
    });
    add-method(OperatorProperties, 'precedence', [OperatorProperties, '', 0, 0], anon sub precedence ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 243 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!precedence')     !! "" 
    });
    add-method(OperatorProperties, 'sub-precedence', [OperatorProperties, '', 0, 0], anon sub sub-precedence ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 244 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!sub-precedence') !! "" 
    });
    add-method(OperatorProperties, 'associative', [OperatorProperties, '', 0, 0], anon sub associative ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 245 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!associative')    !! "" 
    });
    add-method(OperatorProperties, 'thunky', [OperatorProperties, '', 0, 0], anon sub thunky ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 246 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!thunky')         !! "" 
    });
    add-method(OperatorProperties, 'dba', [OperatorProperties, '', 0, 0], anon sub dba ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 247 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!dba')            !! "" 
    });
    add-method(OperatorProperties, 'next-term', [OperatorProperties, '', 0, 0], anon sub next-term ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 248 src/Raku/ast/operator-properties.rakumod
        
        (nqp::isconcrete($SELF) ?? nqp::getattr_s($SELF, OperatorProperties, '$!next-term') !! "") || 'termish'
    
    });
    add-method(OperatorProperties, 'iffy', [OperatorProperties, '', 0, 0], anon sub iffy ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 252 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!iffy')    !! 0 
    });
    add-method(OperatorProperties, 'diffy', [OperatorProperties, '', 0, 0], anon sub diffy ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 253 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!diffy')   !! 0 
    });
    add-method(OperatorProperties, 'fiddly', [OperatorProperties, '', 0, 0], anon sub fiddly ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 254 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!fiddly')  !! 0 
    });
    add-method(OperatorProperties, 'adverb', [OperatorProperties, '', 0, 0], anon sub adverb ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 255 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!adverb')  !! 0 
    });
    add-method(OperatorProperties, 'ternary', [OperatorProperties, '', 0, 0], anon sub ternary ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 256 src/Raku/ast/operator-properties.rakumod
         nqp::isconcrete($SELF) ?? nqp::getattr_i($SELF, OperatorProperties, '$!ternary') !! 0 
    });
    add-method(OperatorProperties, 'chain', [OperatorProperties, '', 0, 0], anon sub chain ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 259 src/Raku/ast/operator-properties.rakumod
        
        nqp::isconcrete($SELF) && nqp::getattr_s($SELF, OperatorProperties, '$!associative') eq 'chain'
    
    });
    add-method(OperatorProperties, 'short-circuit', [OperatorProperties, '', 0, 0], anon sub short-circuit ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 262 src/Raku/ast/operator-properties.rakumod
        
        nqp::isconcrete($SELF) && nqp::getattr_s($SELF, OperatorProperties, '$!thunky') ne ""
    
    });
    add-method(OperatorProperties, 'sub-or-precedence', [OperatorProperties, '', 0, 0], anon sub sub-or-precedence ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 265 src/Raku/ast/operator-properties.rakumod
        
        nqp::isconcrete($SELF) ?? (nqp::getattr_s($SELF, OperatorProperties, '$!sub-precedence') || nqp::getattr_s($SELF, OperatorProperties, '$!precedence')) !! ""
    
    });
    add-method(OperatorProperties, 'not-reducable', [OperatorProperties, '', 0, 0], anon sub not-reducable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 271 src/Raku/ast/operator-properties.rakumod
        
        nqp::isconcrete($SELF)
          ?? ""
          !! nqp::getattr_i($SELF, OperatorProperties, '$!fiddly')
            ?? "fiddly"
            !! nqp::getattr_i($SELF, OperatorProperties, '$!diffy') && nqp::getattr_s($SELF, OperatorProperties, '$!associative') eq 'chain'
              ?? "diffy and not chaining"
              !! ""
    
    });
    add-method(OperatorProperties, 'reducer-name', [OperatorProperties, '', 0, 0], anon sub reducer-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 282 src/Raku/ast/operator-properties.rakumod
        
        if nqp::isconcrete($SELF) {
            if nqp::iseq_s(nqp::getattr_s($SELF, OperatorProperties, '$!precedence'),'f=') {
                '&METAOP_REDUCE_LISTINFIX'
            }
            else {
                my $associative := nqp::getattr_s($SELF, OperatorProperties, '$!associative');
                nqp::chars($associative)
                  ?? nqp::iseq_s($associative,'chain')
                    ?? '&METAOP_REDUCE_CHAIN'
                    !! nqp::iseq_s($associative,'list')
                      ?? '&METAOP_REDUCE_LIST'
                      !! nqp::iseq_s($associative,'right')
                        ?? '&METAOP_REDUCE_RIGHT'
                        !! '&METAOP_REDUCE_LEFT'    # assume 'left' or 'non'
                  !! '&METAOP_REDUCE_LEFT'
            }
        }
        else {
            '&METAOP_REDUCE_LEFT'
        }
    
    });
    add-method(OperatorProperties, 'prec', [OperatorProperties, '', 0, 0, str, '$key', 0, 1], anon sub prec ($SELF_CONT, $key?) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
#line 306 src/Raku/ast/operator-properties.rakumod
        
        if nqp::isconcrete($SELF) {
            if $key {
                nqp::atkey($SELF.prec,$key)
            }
            else {
                my $hash := nqp::hash;
                nqp::bindkey($hash,'prec',nqp::getattr_s($SELF, OperatorProperties, '$!precedence'))    if nqp::getattr_s($SELF, OperatorProperties, '$!precedence');
                nqp::bindkey($hash,'sub',nqp::getattr_s($SELF, OperatorProperties, '$!sub-precedence')) if nqp::getattr_s($SELF, OperatorProperties, '$!sub-precedence');
                nqp::bindkey($hash,'assoc',nqp::getattr_s($SELF, OperatorProperties, '$!associative'))  if nqp::getattr_s($SELF, OperatorProperties, '$!associative');
                nqp::bindkey($hash,'thunky',nqp::getattr_s($SELF, OperatorProperties, '$!thunky'))      if nqp::getattr_s($SELF, OperatorProperties, '$!thunky');
                nqp::bindkey($hash,'dba',nqp::getattr_s($SELF, OperatorProperties, '$!dba'))            if nqp::getattr_s($SELF, OperatorProperties, '$!dba');
                nqp::bindkey($hash,'nextterm',nqp::getattr_s($SELF, OperatorProperties, '$!next-term')) if nqp::getattr_s($SELF, OperatorProperties, '$!next-term');
                nqp::bindkey($hash,'iffy',nqp::getattr_i($SELF, OperatorProperties, '$!iffy'))          if nqp::getattr_i($SELF, OperatorProperties, '$!iffy');
                nqp::bindkey($hash,'diffy',nqp::getattr_i($SELF, OperatorProperties, '$!diffy'))        if nqp::getattr_i($SELF, OperatorProperties, '$!diffy');
                nqp::bindkey($hash,'fiddly',nqp::getattr_i($SELF, OperatorProperties, '$!fiddly'))      if nqp::getattr_i($SELF, OperatorProperties, '$!fiddly');
                nqp::bindkey($hash,'adverb',nqp::getattr_i($SELF, OperatorProperties, '$!adverb'))      if nqp::getattr_i($SELF, OperatorProperties, '$!adverb');
                nqp::bindkey($hash,'ternary',nqp::getattr_i($SELF, OperatorProperties, '$!ternary'))    if nqp::getattr_i($SELF, OperatorProperties, '$!ternary');
                $hash
            }
        }

        # called on type object
        else {
            if $key {
                $key eq 'prec' || $key eq 'assoc' || $key eq 'thunky'
                  ?? ""
                  !! $key eq 'iffy'
                    ?? 0
                    !! nqp::null
            }
            else {
                nqp::hash
            }
        }
    
    });
    add-method(OperatorProperties, 'known-category', [OperatorProperties, '', 0, 0, str, '$category', 0, 0], anon sub known-category ($SELF_CONT, $category!) {
        my $SELF := nqp::decont($SELF_CONT);
        $category := nqp::decont($category);
#line 344 src/Raku/ast/operator-properties.rakumod
        
        my constant CATEGORIES := nqp::hash(
          'infix',1, 'prefix',1, 'postfix',1, 'postcircumfix',1, 'circumfix',1
        );
        nqp::existskey(CATEGORIES,$category)
    
    });
    add-method(OperatorProperties, 'equiv', [OperatorProperties, '', 0, 0, str, '$associative', 0, 0], anon sub equiv ($SELF_CONT, $associative!) {
        my $SELF := nqp::decont($SELF_CONT);
        $associative := nqp::decont($associative);
#line 354 src/Raku/ast/operator-properties.rakumod
        
        nqp::isconcrete($SELF)
          ?? $SELF.new(
               associative => nqp::isnull_s($associative)
                                ?? nqp::getattr_s($SELF, OperatorProperties, '$!associative')
                                !! $associative
             )
          !! $SELF.new
    
    });
    add-method(OperatorProperties, 'tighter', [OperatorProperties, '', 0, 0, str, '$associative', 0, 0], anon sub tighter ($SELF_CONT, $associative!) {
        my $SELF := nqp::decont($SELF_CONT);
        $associative := nqp::decont($associative);
#line 363 src/Raku/ast/operator-properties.rakumod
        
        nqp::isconcrete($SELF)
          ?? $SELF.new(
               precedence  => nqp::join('@=',nqp::split('=',nqp::getattr_s($SELF, OperatorProperties, '$!precedence'))),
               associative => nqp::isnull_s($associative)
                                ?? nqp::getattr_s($SELF, OperatorProperties, '$!associative')
                                !! $associative
             )
          !! nqp::die("No precedence found to be tighter for")
    
    });
    add-method(OperatorProperties, 'looser', [OperatorProperties, '', 0, 0, str, '$associative', 0, 0], anon sub looser ($SELF_CONT, $associative!) {
        my $SELF := nqp::decont($SELF_CONT);
        $associative := nqp::decont($associative);
#line 373 src/Raku/ast/operator-properties.rakumod
        
        nqp::isconcrete($SELF)
          ?? $SELF.new(
               precedence  => nqp::join(':=',nqp::split('=',nqp::getattr_s($SELF, OperatorProperties, '$!precedence'))),
               associative => nqp::isnull_s($associative)
                                ?? nqp::getattr_s($SELF, OperatorProperties, '$!associative')
                                !! $associative
             )
          !! nqp::die("No precedence found to be looser for")
    
    });
    add-method(OperatorProperties, 'properties-for-group', [OperatorProperties, '', 0, 0, str, '$group', 0, 0], anon sub properties-for-group ($SELF_CONT, $group!) {
        my $SELF := nqp::decont($SELF_CONT);
        $group := nqp::decont($group);
#line 399 src/Raku/ast/operator-properties.rakumod
        
        my constant PROPERTIES := nqp::hash(

          'default-infix', nqp::hash(
            'precedence','t=', 'associative', 'left'
          ),
          'default-prefix', nqp::hash(
            'precedence','v=', 'associative', 'unary'
          ),
          'default-postfix', nqp::hash(
            'precedence','x=', 'associative', 'unary'
          ),
          'default-postcircumfix', nqp::hash(
            'precedence','y='
           ),
          'default-circumfix', nqp::hash(),
          'methodcall', nqp::hash(
            'precedence','y=', 'associative','unary', 'fiddly', 1
          ),
          'autoincrement', nqp::hash(
            'precedence','x=', 'associative','unary'
          ),
          'exponentiation', nqp::hash(
            'precedence','w=', 'associative','right'
          ),
          'symbolic-unary', nqp::hash(
            'precedence','v=', 'associative','unary'
          ),
          'dotty-infix', nqp::hash(
            'precedence','v=', 'associative','left', 'next-term','dottyopish',
            'sub-precedence','z=', 'fiddly',1
          ),
          'multiplicative', nqp::hash(
            'precedence','u=', 'associative','left'
          ),
          'multiplicative-iffy', nqp::hash(
            'precedence','u=', 'associative','left', 'iffy',1
          ),
          'additive', nqp::hash(
            'precedence','t=', 'associative','left'
          ),
          'additive-iffy', nqp::hash(
            'precedence','t=', 'associative','left', 'iffy',1
          ),
          'replication-x', nqp::hash(
            'precedence','s=', 'associative','left'
          ),
          'replication-xx', nqp::hash(
            'precedence','s=', 'associative','left', 'thunky','t.'
          ),
          'concatenation', nqp::hash(
            'precedence','r=', 'associative','left'
          ),
          'junctive-and', nqp::hash(
            'precedence','q=', 'associative','list'
          ),
          'junctive-and-iffy', nqp::hash(
            'precedence','q=', 'associative','list', 'iffy',1
          ),
          'junctive-or', nqp::hash(
            'precedence','p=', 'associative','list'
          ),
          'junctive-or-iffy', nqp::hash(
            'precedence','p=', 'associative','list', 'iffy',1
          ),
          'named-unary', nqp::hash(
            'precedence','o=', 'associative','unary'
          ),
          'structural', nqp::hash(
            'precedence','n=', 'associative','non', 'diffy',1
          ),
          'chaining', nqp::hash(
            'precedence','m=', 'associative','chain', 'iffy',1, 'diffy',1
          ),
          'tight-and', nqp::hash(
            'precedence','l=', 'associative','left', 'thunky','.t', 'iffy',1
          ),
          'tight-or', nqp::hash(
            'precedence','k=', 'associative','left', 'thunky','.t', 'iffy',1
          ),
          'tight-defor', nqp::hash(
            'precedence','k=', 'associative','left', 'thunky','.t'
          ),
          'tight-xor', nqp::hash(
            'precedence','k=', 'associative','list', 'thunky','..t', 'iffy',1
          ),
          'tight-minmax', nqp::hash(
            'precedence','k=', 'associative','list'
          ),
          'ternary', nqp::hash(
            'precedence','j=', 'associative','right', 'thunky','.tt',
            'fiddly',1, 'ternary',1
          ),
          'conditional-ff', nqp::hash(
            'precedence','j=', 'associative','right', 'thunky','tt',
            'iffy',1
          ),
          'item-assignment', nqp::hash(
            'precedence','i=', 'associative','right'
          ),
          'adverb', nqp::hash(
            'precedence','i=', 'associative','unary', 'adverb',1
          ),
          'list-assignment', nqp::hash(
            'precedence','i=', 'associative','right', 'fiddly',1,
            'sub-precedence','e='
          ),
          'loose-unary', nqp::hash(
            'precedence','h=', 'associative','unary'
          ),
          'comma', nqp::hash(
            'precedence','g=', 'associative','list', 'next-term','nulltermish'
          ),
          'list-infix', nqp::hash(
            'precedence','f=', 'associative','list'
          ),
          'list-prefix', nqp::hash(
            'precedence','e=', 'associative','right'
          ),
          'loose-and', nqp::hash(
            'precedence','d=', 'associative','left', 'thunky','.t', 'iffy',1
          ),
          'loose-andthen', nqp::hash(
            'precedence','d=', 'associative','list', 'thunky','.b'
          ),
          'loose-or', nqp::hash(
            'precedence','c=', 'associative','left', 'thunky','.t', 'iffy',1
          ),
          'loose-xor', nqp::hash(
            'precedence','c=', 'associative','list', 'thunky','.t', 'iffy',1
          ),
          'loose-orelse', nqp::hash(
            'precedence','c=', 'associative','list', 'thunky','.b'
          ),
          'sequencer', nqp::hash(
            'precedence','b=', 'associative','list'
          )
        );

        # Convert raw properties into an object
        my %value := nqp::ifnull(
          nqp::atkey(PROPERTIES,$group),
          nqp::hash()
        );
        nqp::ishash(%value)
          ?? nqp::bindkey(  # first time
               PROPERTIES,
               $group,
               OperatorProperties.new(|%value, :dba($group))
             )
          !! %value         # already instantiated
    
    });
    add-method(OperatorProperties, 'produce', [OperatorProperties, '', 0, 0, Any, '$hash', 0, 0, str, '$key', 0, 0], anon sub produce ($SELF_CONT, $hash!, $key!) {
        my $SELF := nqp::decont($SELF_CONT);
        $hash := nqp::decont($hash);
        $key := nqp::decont($key);
#line 560 src/Raku/ast/operator-properties.rakumod
        

        # Get current setting or default
        my $properties := nqp::ifnull(
          nqp::atkey($hash,$key),
          nqp::atkey($hash,$key := '')
        );

        # If not yet an instance, create an instance and update in the
        # hash if the operator is a built-in.
        if nqp::isstr($properties) {
            $properties := $SELF.properties-for-group($properties);
            nqp::bindkey($hash,$key,$properties)
              if nqp::existskey($hash,$key);
        }

        $properties
    
    });
    add-method(OperatorProperties, 'infix', [OperatorProperties, '', 0, 0, str, '$operator', 0, 1], anon sub infix ($SELF_CONT, $operator?) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 580 src/Raku/ast/operator-properties.rakumod
        
        my constant PROPERTIES := nqp::hash(
           '', 'default-infix',

           '.',  'dotty-infix',
           '.=', 'dotty-infix',

          '*',   'multiplicative',
          '×',   'multiplicative',
          '/',   'multiplicative',
          'div', 'multiplicative',
          'gcd', 'multiplicative',
          'lcm', 'multiplicative',
          '%',   'multiplicative',
          'mod', 'multiplicative',
          '+&',  'multiplicative',
          '~&',  'multiplicative',
          '+<',  'multiplicative',
          '+>',  'multiplicative',
          '~<',  'multiplicative',
          '~>',  'multiplicative',

          '%%', 'multiplicative-iffy',
          '?&', 'multiplicative-iffy',

          '+',  'additive',
          '-',  'additive',
          '−',  'additive',
          '+|', 'additive',
          '+^', 'additive',
          '~|', 'additive',
          '~^', 'additive',

          '?|', 'additive-iffy',
          '?^', 'additive-iffy',

          '**', 'exponentiation',

          'x', 'replication-x',

          'xx', 'replication-xx',

          '~', 'concatenation',

          '(&)', 'junctive-and',
          '∩',   'junctive-and',
          '(.)', 'junctive-and',
          '⊍',   'junctive-and',

          '&',   'junctive-and-iffy',

          '(+)', 'junctive-or',
          '⊎',   'junctive-or',
          '(|)', 'junctive-or',
          '∪',   'junctive-or',
          '(-)', 'junctive-or',
          '∖',   'junctive-or',
          '(^)', 'junctive-or',
          '⊖',   'junctive-or',

          '|', 'junctive-or-iffy',
          '^', 'junctive-or-iffy',

          '..',     'structural',
          '^..',    'structural',
          '..^',    'structural',
          '^..^',   'structural',
          '<=>',    'structural',
          'leg',    'structural',
          'cmp',    'structural',
          'unicmp', 'structural',
          'coll',   'structural',
          'but',    'structural',
          'does',   'structural',

          '>',      'chaining',
          '<',      'chaining',
          '>=',     'chaining',
          '<=',     'chaining',
          '(<)',    'chaining',
          '⊂',      'chaining',
          '(>)',    'chaining',
          '⊃',      'chaining',
          '(<=)',   'chaining',
          '⊆',      'chaining',
          '(>=)',   'chaining',
          '⊇',      'chaining',
          '(<+)',   'chaining',
          '≼',      'chaining',
          '(>+)',   'chaining',
          '≽',      'chaining',
          '==',     'chaining',
          '=~=',    'chaining',
          '≅',      'chaining',
          '!=',     'chaining',
          'eq',     'chaining',
          'ne',     'chaining',
          'le',     'chaining',
          'ge',     'chaining',
          'lt',     'chaining',
          'gt',     'chaining',
          '=:=',    'chaining',
          '===',    'chaining',
          'eqv',    'chaining',
          'before', 'chaining',
          'after',  'chaining',
          '~~',     'chaining',
          '!~',     'chaining',    # dummy for p5ism
          '!~~',    'chaining',
          '(elem)', 'chaining',
          '∈',      'chaining',
          '(cont)', 'chaining',
          '∋',      'chaining',
          '(==)',   'chaining',
          '≡',      'chaining',
          '∉',      'chaining',
          '∌',      'chaining',
          '⊄',      'chaining',
          '⊅',      'chaining',
          '≢',      'chaining',
          '⊈',      'chaining',
          '⊉',      'chaining',

          '&&', 'tight-and',

          '||', 'tight-or',

          '//', 'tight-defor',

          '^^', 'tight-xor',

          'min', 'tight-minmax',
          'max', 'tight-minmax',

          '?? !!', 'ternary',        # dummy for $a ?? 42 !! 666

          'ff',    'conditional-ff',
          '^ff',   'conditional-ff',
          'ff^',   'conditional-ff',
          '^ff^',  'conditional-ff',
          'fff',   'conditional-ff',
          '^fff',  'conditional-ff',
          'fff^',  'conditional-ff',
          '^fff^', 'conditional-ff',

          '=~',  'item-assignment',  # alt for = ~foo
          '$=',  'item-assignment',  # dummy for $a = 42
          '=>',  'item-assignment',
          '⇒',   'item-assignment',
          '⚛=',  'item-assignment',
          '⚛+=', 'item-assignment',
          '⚛-=', 'item-assignment',
          '⚛−=', 'item-assignment',

          '=',  'list-assignment',
          '@=', 'list-assignment',   # dummy for @a = 1,2,3
          ':=', 'list-assignment',

          ':', 'comma',              # dummy for chop 42:
          ',', 'comma',

          'X',      'list-infix',
          'Z',      'list-infix',
          '...',    'list-infix',
          '…',      'list-infix',
          '...^',   'list-infix',
          '…^',     'list-infix',
          '^...',   'list-infix',
          '^…',     'list-infix',
          '^...^',  'list-infix',
          '^…^',    'list-infix',
          'minmax', 'list-infix',

          'and', 'loose-and',

          'andthen',    'loose-andthen',
          'notandthen', 'loose-andthen',

          'or',     'loose-or',

          'xor',    'loose-xor',

          'orelse', 'loose-orelse',

          # dummy, for parsing Raku code only
          '==>',  'sequencer',
          '==>>', 'sequencer',
          '<==',  'sequencer',
          '<<==', 'sequencer',
        );

        $SELF.produce(PROPERTIES, $operator // '')
    
    });
    add-method(OperatorProperties, 'prefix', [OperatorProperties, '', 0, 0, str, '$operator', 0, 1], anon sub prefix ($SELF_CONT, $operator?) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 775 src/Raku/ast/operator-properties.rakumod
        
        my constant PROPERTIES := nqp::hash(
           '', 'default-prefix',

          '++',  'autoincrement',
          '--',  'autoincrement',
          '++⚛', 'autoincrement',
          '--⚛', 'autoincrement',

          '+',  'symbolic-unary',
          '~',  'symbolic-unary',
          '-',  'symbolic-unary',
          '?',  'symbolic-unary',
          '!',  'symbolic-unary',
          '|',  'symbolic-unary',
          '+^', 'symbolic-unary',
          '~^', 'symbolic-unary',
          '?^', 'symbolic-unary',
          '^',  'symbolic-unary',
          '⚛',  'symbolic-unary',
          '//', 'symbolic-unary',

          'so',  'loose-unary',
          'not', 'loose-unary',
        );

        $SELF.produce(PROPERTIES, $operator // '')
    
    });
    add-method(OperatorProperties, 'postfix', [OperatorProperties, '', 0, 0, str, '$operator', 0, 1], anon sub postfix ($SELF_CONT, $operator?) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 805 src/Raku/ast/operator-properties.rakumod
        
        my constant PROPERTIES := nqp::hash(
           '', 'default-postfix',

          ':', 'adverb',          # dummy for %h<a>:exists

          '()', 'methodcall',     # term()
          '.',  'methodcall',
          '!',  'methodcall',
          '.^', 'methodcall',
          '.?', 'methodcall',
          '.&', 'methodcall',
          '.=', 'methodcall',
          'i',  'methodcall',

          'ⁿ',   'autoincrement',  # power
          '+',   'autoincrement',  # vulgar

          '++',  'autoincrement',
          '--',  'autoincrement',
          '⚛++', 'autoincrement',
          '⚛--', 'autoincrement',
        );

        $SELF.produce(PROPERTIES, $operator // '')
    
    });
    add-method(OperatorProperties, 'postcircumfix', [OperatorProperties, '', 0, 0, str, '$operator', 0, 1], anon sub postcircumfix ($SELF_CONT, $operator?) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 833 src/Raku/ast/operator-properties.rakumod
        
        my constant PROPERTIES := nqp::hash(
           '', 'default-postcircumfix',

          '< >',   'methodcall',
          '<< >>', 'methodcall',
          '« »',   'methodcall',
          '[ ]',   'methodcall',
          '[; ]',  'methodcall',
          '{ }',   'methodcall',
          '{; }',  'methodcall',
        );

        $SELF.produce(PROPERTIES, $operator // '')
    
    });
    add-method(OperatorProperties, 'circumfix', [OperatorProperties, '', 0, 0, str, '$operator', 0, 1], anon sub circumfix ($SELF_CONT, $operator?) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 850 src/Raku/ast/operator-properties.rakumod
        
        my constant PROPERTIES := nqp::hash(
           '', 'default-circumfix',

          '< >',   'methodcall',
          '<< >>', 'methodcall',
          '« »',   'methodcall',
          '[ ]',   'methodcall',
          '{ }',   'methodcall',
        );

        $SELF.produce(PROPERTIES, $operator // '')
    
    });
    compose(OperatorProperties);
    parent(RakuAST::CaptureSource, RakuAST::Node);
    compose(RakuAST::CaptureSource);
    parent(RakuAST::Expression, RakuAST::IMPL::ImmediateBlockUser);
    add-attribute(RakuAST::Expression, Mu, '$!thunks');
    add-method(RakuAST::Expression, 'wrap-with-thunk', [RakuAST::Expression, '', 0, 0, RakuAST::ExpressionThunk, '$thunk', 0, 0], anon sub wrap-with-thunk ($SELF_CONT, $thunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $thunk := nqp::decont($thunk);
#line 17 src/Raku/ast/expressions.rakumod
        
        $thunk.set-next(nqp::getattr($SELF, RakuAST::Expression, '$!thunks')) if nqp::getattr($SELF, RakuAST::Expression, '$!thunks');
        nqp::bindattr($SELF, RakuAST::Expression, '$!thunks', $thunk);
        Nil
    
    });
    add-method(RakuAST::Expression, 'dump-extras', [RakuAST::Expression, '', 0, 0, int, '$indent', 0, 0], anon sub dump-extras ($SELF_CONT, $indent!) {
        my $SELF := nqp::decont($SELF_CONT);
        $indent := nqp::decont($indent);
#line 23 src/Raku/ast/expressions.rakumod
        
        my $prefix := nqp::x(' ', $indent);
        my @chunks;
        $SELF.visit-thunks(-> $thunk {
            @chunks.push("$prefix🧠 " ~ $thunk.thunk-kind ~ " " ~ $thunk.thunk-details ~ "\n");
            $thunk.visit-children(-> $child {
                @chunks.push($child.dump($indent + 2));
            });
        });
        nqp::join('', @chunks)
    
    });
    add-method(RakuAST::Expression, 'IMPL-QAST-ADD-THUNK-DECL-CODE', [RakuAST::Expression, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$target', 0, 0], anon sub IMPL-QAST-ADD-THUNK-DECL-CODE ($SELF_CONT, $context!, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $target := nqp::decont($target);
#line 35 src/Raku/ast/expressions.rakumod
        
        if nqp::getattr($SELF, RakuAST::Expression, '$!thunks') {
            nqp::getattr($SELF, RakuAST::Expression, '$!thunks').IMPL-THUNK-CODE-QAST($context, $target, $SELF);
        }
    
    });
    add-method(RakuAST::Expression, 'IMPL-TO-QAST', [RakuAST::Expression, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%opts', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!, *%opts) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %opts := nqp::decont(%opts);
#line 41 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::Expression, '$!thunks')
            ?? nqp::getattr($SELF, RakuAST::Expression, '$!thunks').IMPL-THUNK-VALUE-QAST($context)
            !! $SELF.IMPL-EXPR-QAST($context, |%opts)
    
    });
    add-method(RakuAST::Expression, 'IMPL-EXPR-QAST', [RakuAST::Expression, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 47 src/Raku/ast/expressions.rakumod
        
        nqp::die('Missing IMPL-EXPR-QAST method on ' ~ $SELF.HOW.name($SELF))
    
    });
    add-method(RakuAST::Expression, 'visit-thunks', [RakuAST::Expression, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-thunks ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 51 src/Raku/ast/expressions.rakumod
        
        my $cur-thunk := nqp::getattr($SELF, RakuAST::Expression, '$!thunks');
        while $cur-thunk {
            $visitor($cur-thunk);
            $cur-thunk := $cur-thunk.next;
        }
    
    });
    add-method(RakuAST::Expression, 'outer-most-thunk', [RakuAST::Expression, '', 0, 0], anon sub outer-most-thunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 59 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::Expression, '$!thunks')
    
    });
    add-method(RakuAST::Expression, 'IMPL-CURRY', [RakuAST::Expression, '', 0, 0], anon sub IMPL-CURRY ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 64 src/Raku/ast/expressions.rakumod
        
        my $thunk := RakuAST::CurryThunk.new($SELF.DEPARSE);
        $SELF.wrap-with-thunk($thunk);
        $thunk
    
    });
    add-method(RakuAST::Expression, 'IMPL-CURRIED', [RakuAST::Expression, '', 0, 0], anon sub IMPL-CURRIED ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 70 src/Raku/ast/expressions.rakumod
        
        my $cur-thunk := nqp::getattr($SELF, RakuAST::Expression, '$!thunks');
        while $cur-thunk {
            return $cur-thunk if nqp::istype($cur-thunk, RakuAST::CurryThunk);
            $cur-thunk := $cur-thunk.next;
        }
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Expression, 'IMPL-UNCURRY', [RakuAST::Expression, '', 0, 0], anon sub IMPL-UNCURRY ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 79 src/Raku/ast/expressions.rakumod
        
        my $prev-thunk;
        my $cur-thunk := nqp::getattr($SELF, RakuAST::Expression, '$!thunks');
        while $cur-thunk {
            if nqp::istype($cur-thunk, RakuAST::CurryThunk) {
                my $params := $cur-thunk.IMPL-PARAMS;
                if $prev-thunk {
                    $prev-thunk.set-next($cur-thunk.next);
                }
                else {
                    nqp::bindattr($SELF, RakuAST::Expression, '$!thunks', $cur-thunk.next);
                }
                return $params;
            }
            $prev-thunk := $cur-thunk;
            $cur-thunk := $cur-thunk.next;
        }
        nqp::die("UNCURRY didn't find a CurryThunk");
    
    });
    add-method(RakuAST::Expression, 'IMPL-IMMEDIATELY-USES', [RakuAST::Expression, '', 0, 0, RakuAST::Code, '$node', 0, 0], anon sub IMPL-IMMEDIATELY-USES ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 99 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::Expression, '$!thunks') ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Expression, 'IMPL-ADJUST-QAST-FOR-LVALUE', [RakuAST::Expression, '', 0, 0, Mu, '$qast', 0, 0], anon sub IMPL-ADJUST-QAST-FOR-LVALUE ($SELF_CONT, $qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $qast := nqp::decont($qast);
#line 103 src/Raku/ast/expressions.rakumod
        
        $qast
    
    });
    compose(RakuAST::Expression);
    parent(RakuAST::OperatorProperties, Any);
    add-method(RakuAST::OperatorProperties, 'properties', [RakuAST::OperatorProperties, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 115 src/Raku/ast/expressions.rakumod
        
        my $properties;
        if nqp::can($SELF,'is-resolved') {

            # This feels very much like a hack, and should probably be
            # changed at some time.  Perhaps when we get a "parse time"
            # stage?
            $SELF.resolve-with($*R) if !$SELF.is-resolved && $*R;

            if $SELF.is-resolved {
                my $resolution := $SELF.resolution;
                $properties := $resolution.compile-time-value.op_props
                  if nqp::istype($resolution,RakuAST::CompileTimeValue);
            }
        }

        nqp::isconcrete($properties)
          ?? $properties
          !! $SELF.default-operator-properties
    
    });
    compose(RakuAST::OperatorProperties);
    parent(RakuAST::Infixish, RakuAST::ImplicitLookups);
    add-method(RakuAST::Infixish, 'IMPL-LIST-INFIX-QAST', [RakuAST::Infixish, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operands', 0, 0], anon sub IMPL-LIST-INFIX-QAST ($SELF_CONT, $context!, $operands!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operands := nqp::decont($operands);
#line 144 src/Raku/ast/expressions.rakumod
        
        nqp::die('Cannot compile ' ~ $SELF.HOW.name($SELF) ~ ' as a list infix');
    
    });
    add-method(RakuAST::Infixish, 'IMPL-INFIX-COMPILE', [RakuAST::Infixish, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$left', 0, 0, RakuAST::Expression, '$right', 0, 0], anon sub IMPL-INFIX-COMPILE ($SELF_CONT, $context!, $left!, $right!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left := nqp::decont($left);
        $right := nqp::decont($right);
#line 152 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-INFIX-QAST: $context, $left.IMPL-TO-QAST($context),
            $right.IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::Infixish, 'IMPL-THUNK-ARGUMENTS', [RakuAST::Infixish, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '@operands', 0, 0], anon sub IMPL-THUNK-ARGUMENTS ($SELF_CONT, $resolver!, $context!, *@operands) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        @operands := nqp::decont(@operands);
#line 158 src/Raku/ast/expressions.rakumod
        
    
    });
    add-method(RakuAST::Infixish, 'IMPL-CURRIES', [RakuAST::Infixish, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 165 src/Raku/ast/expressions.rakumod
         0 
    });
    compose(RakuAST::Infixish);
    parent(RakuAST::Infix, RakuAST::Infixish);
    parent(RakuAST::Infix, RakuAST::OperatorProperties);
    parent(RakuAST::Infix, RakuAST::Lookup);
    add-attribute(RakuAST::Infix, str, '$!operator');
    add-method(RakuAST::Infix, 'new', [RakuAST::Infix, '', 0, 0, str, '$operator', 0, 0], anon sub new ($SELF_CONT, $operator!) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 177 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Infix, '$!operator', $operator);
        $obj
    
    });
    add-method(RakuAST::Infix, 'default-operator-properties', [RakuAST::Infix, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 183 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.infix(nqp::getattr_s($SELF, RakuAST::Infix, '$!operator'))
    
    });
    add-method(RakuAST::Infix, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Infix, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 187 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Match')),
        ])
    
    });
    add-method(RakuAST::Infix, 'resolve-with', [RakuAST::Infix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 193 src/Raku/ast/expressions.rakumod
        
        my $resolved := $resolver.resolve-infix(nqp::getattr_s($SELF, RakuAST::Infix, '$!operator'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Infix, 'reducer-name', [RakuAST::Infix, '', 0, 0], anon sub reducer-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 201 src/Raku/ast/expressions.rakumod
         $SELF.properties.reducer-name 
    });
    add-method(RakuAST::Infix, 'IMPL-THUNK-ARGUMENT', [RakuAST::Infix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$expression', 0, 0, str, '$type', 0, 0], anon sub IMPL-THUNK-ARGUMENT ($SELF_CONT, $resolver!, $context!, $expression!, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $expression := nqp::decont($expression);
        $type := nqp::decont($type);
#line 204 src/Raku/ast/expressions.rakumod
        
        if $type eq 'b' && !nqp::istype($expression, RakuAST::Code) {
            my $thunk := RakuAST::BlockThunk.new;
            $thunk.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
            $expression.wrap-with-thunk($thunk);
        }
        elsif $type eq 't' && !nqp::istype($expression, RakuAST::Code) {
            my $thunk := RakuAST::ExpressionThunk.new;
            $thunk.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
            $expression.wrap-with-thunk($thunk);
        }
        # TODO implement other thunk types
    
    });
    add-method(RakuAST::Infix, 'IMPL-THUNK-ARGUMENTS', [RakuAST::Infix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '@operands', 0, 0], anon sub IMPL-THUNK-ARGUMENTS ($SELF_CONT, $resolver!, $context!, *@operands) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        @operands := nqp::decont(@operands);
#line 219 src/Raku/ast/expressions.rakumod
        
        if (
               nqp::getattr_s($SELF, RakuAST::Infix, '$!operator') eq 'xx'     || nqp::getattr_s($SELF, RakuAST::Infix, '$!operator') eq 'andthen'
            || nqp::getattr_s($SELF, RakuAST::Infix, '$!operator') eq 'orelse' || nqp::getattr_s($SELF, RakuAST::Infix, '$!operator') eq 'notandthen'
            || nqp::getattr_s($SELF, RakuAST::Infix, '$!operator') eq 'with'   || nqp::getattr_s($SELF, RakuAST::Infix, '$!operator') eq 'without'
        ) {
            my $thunky := $SELF.properties.thunky;
            my $i := 0;
            for @operands {
                my $type := nqp::substr($thunky, $i, $i + 1);
                if $type && $type ne '.' {
                    $SELF.IMPL-THUNK-ARGUMENT($resolver, $context, $_, $type);
                }
                $i++ if $i < nqp::chars($thunky) - 1;
            }
        }
    
    });
    add-method(RakuAST::Infix, 'IMPL-CURRIES', [RakuAST::Infix, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 237 src/Raku/ast/expressions.rakumod
        
        # Lookup of infix operators and whether either left / right side
        # will curry:
        #  0 = do not curry
        #  1 = curry Whatever only
        #  2 = curry WhateverCode only
        #  3 = curry both Whatever and WhateverCode (default)
        my constant CURRIED := nqp::hash(
            '...'   , 0,
            '…'     , 0,
            '...^'  , 0,
            '…^'    , 0,
            '^...'  , 0,
            '^…'    , 0,
            '^...^' , 0,
            '^…^'   , 0,
            '='     , 0,
            ':='    , 0,
            '&&',   , 0,
            '||',   , 0,
            '~~'    , 1,
            '∘'     , 1,
            'o'     , 1,
            '..'    , 2,
            '..^'   , 2,
            '^..'   , 2,
            '^..^'  , 2,
            'xx'    , 2,
        );
        CURRIED{nqp::getattr_s($SELF, RakuAST::Infix, '$!operator')} // 3
    
    });
    add-method(RakuAST::Infix, 'IMPL-INFIX-COMPILE', [RakuAST::Infix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$left', 0, 0, RakuAST::Expression, '$right', 0, 0], anon sub IMPL-INFIX-COMPILE ($SELF_CONT, $context!, $left!, $right!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left := nqp::decont($left);
        $right := nqp::decont($right);
#line 270 src/Raku/ast/expressions.rakumod
        
        # Hash value is negation flag
        my constant OP-SMARTMATCH := nqp::hash( '~~', 0, '!~~', 1 );
        my str $op := nqp::getattr_s($SELF, RakuAST::Infix, '$!operator');
        if $op eq ':=' {
            if $left.can-be-bound-to {
                $left.IMPL-BIND-QAST($context, $right.IMPL-TO-QAST($context))
            }
            else {
                nqp::die('Cannot compile bind to ' ~ $left.HOW.name($left));
            }
        }
        elsif nqp::existskey(OP-SMARTMATCH, $op)
            && (!nqp::istype($right, RakuAST::Var) || (nqp::istype($right, RakuAST::Var::Lexical) && $right.is-topic))
        {
            $SELF.IMPL-SMARTMATCH-QAST($context, $left, $right, nqp::atkey(OP-SMARTMATCH, $op));
        }
        else {
            $SELF.IMPL-INFIX-QAST:
                $context,
                $op eq '='
                    ?? $left.IMPL-ADJUST-QAST-FOR-LVALUE($left.IMPL-TO-QAST($context))
                    !! $left.IMPL-TO-QAST($context),
                $right.IMPL-TO-QAST($context)
        }
    
    });
    add-method(RakuAST::Infix, 'IMPL-INFIX-QAST', [RakuAST::Infix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$left-qast', 0, 0, Mu, '$right-qast', 0, 0], anon sub IMPL-INFIX-QAST ($SELF_CONT, $context!, $left-qast!, $right-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left-qast := nqp::decont($left-qast);
        $right-qast := nqp::decont($right-qast);
#line 301 src/Raku/ast/expressions.rakumod
        
        # Operators that map directly into a QAST op
        my constant QAST-OP := nqp::hash(
          '||',  'unless',
          'or',  'unless',
          '&&',  'if',
          'and', 'if',
          '^^',  'xor',
          'xor', 'xor',
          '//',  'defor'
        );

        (my str $op := QAST-OP{nqp::getattr_s($SELF, RakuAST::Infix, '$!operator')})
          # Directly mapping
          ?? QAST::Op.new(:$op, $left-qast, $right-qast)
          # Otherwise, it's called by finding the lexical sub to call, and
          # compiling it as chaining if required.
          !! QAST::Op.new(
               :op($SELF.properties.chain ?? 'chain' !! 'call'),
               :name($SELF.resolution.lexical-name),
               $left-qast,
               $right-qast
             )
    
    });
    add-method(RakuAST::Infix, 'IMPL-SMARTMATCH-QAST', [RakuAST::Infix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$left', 0, 0, RakuAST::Expression, '$right', 0, 0, int, '$negate', 0, 0], anon sub IMPL-SMARTMATCH-QAST ($SELF_CONT, $context!, $left!, $right!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left := nqp::decont($left);
        $right := nqp::decont($right);
        $negate := nqp::decont($negate);
#line 329 src/Raku/ast/expressions.rakumod
        
        # Handle cases of s/// or m// separately. For a non-negating smartmatch this case could've been reduced to
        # plain topic localization except that we must ensure a False returned when there is no match.
        if nqp::istype($right, RakuAST::RegexThunk)
            && (!nqp::can($right, 'match-immediately') || $right.match-immediately)
        {
            my $match-type :=
              $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
            my $result-local := QAST::Node.unique('!sm-result');
            my $rhs := $right.IMPL-EXPR-QAST($context);
            return $SELF.IMPL-TEMPORARIZE-TOPIC(
                $left.IMPL-TO-QAST($context),
                $negate
                    ?? QAST::Op.new( :op<callmethod>, :name<not>, $rhs)
                    !! QAST::Op.new( :op<unless>, $rhs, QAST::WVal.new( :value((Bool.WHO)<False>) )));
        }

        my $accepts-call;
        if $negate {
            $accepts-call := QAST::Op.new(
                :op<callmethod>, :name<not>,
                QAST::Op.new(
                    :op('callmethod'), :name('ACCEPTS'),
                    $right.IMPL-TO-QAST($context),
                    QAST::Var.new(:name<$_>, :scope<lexical>)));
        }
        else {
            my $rhs-local := QAST::Node.unique('!sm-rhs');
            $accepts-call := QAST::Op.new(
                :op('callmethod'), :name('ACCEPTS'),
                QAST::Var.new( :name($rhs-local), :scope<local> ),
                QAST::Var.new(:name<$_>, :scope<lexical>));
            $accepts-call := QAST::Op.new(
                :op<if>,
                QAST::Op.new(
                    :op<istype>,
                    QAST::Op.new(
                        :op<bind>,
                        QAST::Var.new( :name($rhs-local), :scope<local>, :decl<var> ),
                        $right.IMPL-TO-QAST($context),
                    ),
                    QAST::WVal.new( :value(Regex) )),
                $accepts-call,
                QAST::Op.new(
                    :op<callmethod>,
                    :name<Bool>,
                    $accepts-call ));
        }
        $SELF.IMPL-TEMPORARIZE-TOPIC( $left.IMPL-TO-QAST($context), $accepts-call )
    
    });
    add-method(RakuAST::Infix, 'IMPL-LIST-INFIX-QAST', [RakuAST::Infix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operands', 0, 0], anon sub IMPL-LIST-INFIX-QAST ($SELF_CONT, $context!, $operands!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operands := nqp::decont($operands);
#line 380 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $op := QAST::Op.new( :op('call'), :$name );
        for $operands {
            $op.push($_);
        }
        $op
    
    });
    add-method(RakuAST::Infix, 'IMPL-HOP-INFIX-QAST', [RakuAST::Infix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 389 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        QAST::Var.new( :scope('lexical'), :$name )
    
    });
    add-method(RakuAST::Infix, 'IMPL-CAN-INTERPRET', [RakuAST::Infix, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 394 src/Raku/ast/expressions.rakumod
        
        nqp::istype($SELF.resolution,RakuAST::CompileTimeValue)
          && !$SELF.properties.short-circuit
          && !$SELF.properties.chain
    
    });
    add-method(RakuAST::Infix, 'IMPL-INTERPRET', [RakuAST::Infix, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0, List, '$operands', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!, $operands!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
        $operands := nqp::decont($operands);
#line 400 src/Raku/ast/expressions.rakumod
        
        my $op := $SELF.resolution.compile-time-value;
        my @operands;
        for $SELF.IMPL-UNWRAP-LIST($operands) {
            nqp::push(@operands, $_.IMPL-INTERPRET($ctx));
        }
        $op(|@operands)
    
    });
    add-method(RakuAST::Infix, 'dump-markers', [RakuAST::Infix, '', 0, 0], anon sub dump-markers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 409 src/Raku/ast/expressions.rakumod
        
        '【' ~ nqp::getattr_s($SELF, RakuAST::Infix, '$!operator') ~ '】'
    
    });
#line 175 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Infix, 'operator', [], anon sub operator ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Infix, '$!operator') });
    compose(RakuAST::Infix);
    parent(RakuAST::Feed, RakuAST::Infix);
    parent(RakuAST::Feed, RakuAST::BeginTime);
    add-method(RakuAST::Feed, 'new', [RakuAST::Feed, '', 0, 0, str, '$operator', 0, 0], anon sub new ($SELF_CONT, $operator!) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 418 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Infix, '$!operator', $operator);
        $obj
    
    });
    add-method(RakuAST::Feed, 'PERFORM-BEGIN', [RakuAST::Feed, '', 0, 0, Resolver, '$resolver', 0, 0, Context, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 424 src/Raku/ast/expressions.rakumod
        
        my $operator := nqp::getattr_s($SELF, RakuAST::Infix, '$!operator');
        if $operator eq "==>>" || $operator eq "<<==" {
            $SELF.add-sorry:
              $resolver.build-exception: 'X::Comp::NYI',
                :feature($operator ~ " feed operator");
        }
    
    });
    add-method(RakuAST::Feed, 'IMPL-LIST-INFIX-QAST', [RakuAST::Feed, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operands', 0, 0], anon sub IMPL-LIST-INFIX-QAST ($SELF_CONT, $context!, $operands!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operands := nqp::decont($operands);
#line 433 src/Raku/ast/expressions.rakumod
        
        my @stages;
        my $operator := nqp::getattr_s($SELF, RakuAST::Infix, '$!operator');
        if $operator eq "==>" {
            for $operands {
                @stages.push: $_;
            }
        } else {  # "<<==" and "==>>" are NYI
            for $operands {
                @stages.unshift: $_;
            }
        }

        # Check what's in each stage and make a chain of blocks
        # that call each other. They'll return lazy things, which
        # will be passed in as var-arg parts to other things. The
        # first thing is just considered the result.
        my $result := @stages.shift;
        for @stages {
            my $stage := $_;
            # Wrap current result in a block, so it's thunked and can be
            # called at the right point.
            $result := QAST::Block.new( $result );

            # Check what we have. XXX Real first step should be looking
            # for @(*) since if we find that it overrides all other things.
            # But that's todo...soon. :-)
            if nqp::istype($stage, QAST::Op) && $stage.op eq 'call' {
                # It's a call. Stick a call to the current supplier in
                # as its last argument.
                $stage.push(QAST::Op.new( :op('call'), $result ));
            }
            elsif nqp::istype($stage, QAST::Var) {
                # It's a variable. We need code that gets the results, pushes
                # them onto the variable and then returns them (since this
                # could well be a tap.
                my $tmp := QAST::Node.unique('feed_tmp');
                $stage := QAST::Stmts.new(
                    QAST::Op.new(
                        :op('bind'),
                        QAST::Var.new( :scope('local'), :name($tmp), :decl('var') ),
                        QAST::Op.new(
                            :op('callmethod'), :name('list'),
                            QAST::Op.new( :op('call'), $result )
                            ),
                        ),
                    QAST::Op.new(
                        :op('callmethod'), :name('append'),
                        $stage,
                        QAST::Var.new( :scope('local'), :name($tmp) )
                        ),
                    QAST::Var.new( :scope('local'), :name($tmp) )
                    );
                $stage := QAST::Op.new( :op('locallifetime'), $stage, $tmp );
            }
            else {
                my str $error := "Only routine calls or variables that can '.append' may appear on either side
of feed operators.";
                if nqp::istype($stage, QAST::Children) && nqp::istype($stage[0], QAST::Var) {
                    if nqp::istype($stage, QAST::Op) && $stage.op eq 'ifnull'
                        && nqp::eqat($stage[0].name, '&', 0) {
                        $error := "A feed may not sink values into a code object.
Did you mean a call like '"
                            ~ nqp::substr($stage[0].name, 1)
                            ~ "()' instead?";
                    }

                    # Looks like an array, yet we wound up here (which we
                    # wouldn't if it was an ordinary array.  Assume it's
                    # a shaped array definition throwing a spanner into the
                    # works.
                    elsif nqp::eqat($stage[0].name, '@', 0) {
                        $error := "Cannot feed into shaped arrays, as one cannot '.append' to them.";
                    }
                }
                $_.PRECURSOR.panic($error);
            }
            $result := $stage;
        }
        $result
    
    });
    compose(RakuAST::Feed);
    parent(RakuAST::FlipFlop, RakuAST::Infix);
    parent(RakuAST::FlipFlop, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::FlipFlop, Bool, '$!excludes-min');
    add-attribute(RakuAST::FlipFlop, Bool, '$!excludes-max');
    add-attribute(RakuAST::FlipFlop, Bool, '$!one-only');
    add-attribute(RakuAST::FlipFlop, str, '$!state-id');
    add-attribute(RakuAST::FlipFlop, RakuAST::VarDeclaration::Implicit::State, '$!state-var');
    add-method(RakuAST::FlipFlop, 'new', [RakuAST::FlipFlop, '', 0, 0, str, '$operator', 0, 0], anon sub new ($SELF_CONT, $operator!) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 527 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Infix, '$!operator', $operator);

        nqp::bindattr($obj, RakuAST::FlipFlop, '$!excludes-min',
          nqp::eqat($operator,'^',0)  ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::FlipFlop, '$!excludes-max',
          nqp::eqat($operator,'^',-1) ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::FlipFlop, '$!one-only',
          nqp::index($operator,'fff') == -1 ?? (Bool.WHO)<False> !! (Bool.WHO)<True>);

        my $state-id := QAST::Node.unique('FLIPFLOP_STATE__');
        nqp::bindattr_s($obj, RakuAST::FlipFlop, '$!state-id', $state-id);
        my $state-var := RakuAST::VarDeclaration::Implicit::State.new(
          '!' ~ $state-id, :init-to-zero(1)
        );
        nqp::bindattr($obj, RakuAST::FlipFlop, '$!state-var', $state-var);
        $obj
    
    });
    add-method(RakuAST::FlipFlop, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::FlipFlop, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 547 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Nil')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('True')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('False')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Int')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Whatever'))
        ])
    
    });
    add-method(RakuAST::FlipFlop, 'IMPL-CURRIES', [RakuAST::FlipFlop, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 557 src/Raku/ast/expressions.rakumod
         0 
    });
    add-method(RakuAST::FlipFlop, 'IMPL-INFIX-COMPILE', [RakuAST::FlipFlop, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$left', 0, 0, RakuAST::Expression, '$right', 0, 0], anon sub IMPL-INFIX-COMPILE ($SELF_CONT, $context!, $left!, $right!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left := nqp::decont($left);
        $right := nqp::decont($right);
#line 560 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-INFIX-QAST: $context, $left.IMPL-TO-QAST($context),
            $right.IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::FlipFlop, 'IMPL-INFIX-QAST', [RakuAST::FlipFlop, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$lhs', 0, 0, Mu, '$rhs', 0, 0], anon sub IMPL-INFIX-QAST ($SELF_CONT, $context!, $lhs!, $rhs!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $lhs := nqp::decont($lhs);
        $rhs := nqp::decont($rhs);
#line 569 src/Raku/ast/expressions.rakumod
        
        # Need various constants.
        my $Int   := $SELF.get-implicit-lookups.AT-POS(3).compile-time-value;
        my $Int-zero := $Int.new(0);
        my $Int-one  := $Int.new(1);
        $context.ensure-sc($Int-zero);
        $context.ensure-sc($Int-one);

        my $zero  := QAST::Want.new( QAST::WVal.new(:value($Int-zero), :returns($Int-zero.WHAT)), 'Ii', QAST::IVal.new(:value(0)) );
        my $one   := QAST::Want.new( QAST::WVal.new(:value($Int-one), :returns($Int-one.WHAT)), 'Ii', QAST::IVal.new(:value(1)) );
        my $nil   := QAST::WVal.new( :value($SELF.get-implicit-lookups.AT-POS(0).compile-time-value) );
        my $true  := QAST::WVal.new( :value($SELF.get-implicit-lookups.AT-POS(1).compile-time-value) );
        my $false := QAST::WVal.new( :value($SELF.get-implicit-lookups.AT-POS(2).compile-time-value) );
        my $topic := QAST::Var.new( :name<$_>, :scope<lexical> );

        # Twiddle to make special-case RHS * work.
        my $Whatever := $SELF.get-implicit-lookups.AT-POS(4).compile-time-value;
        if nqp::istype($rhs.returns, $Whatever) {
            $rhs := $false;
        }

        my $id := nqp::getattr_s($SELF, RakuAST::FlipFlop, '$!state-id');
        my $state := '!' ~ $id;
        # Evaluate LHS and RHS. Note that in one-only mode, we use
        # the state bit to decide which side to evaluate.
        my $ff-code := QAST::Stmts.new(
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name($id ~ '_lhs'), :scope('local'), :decl('var') ),
                (nqp::getattr($SELF, RakuAST::FlipFlop, '$!one-only') ??
                    QAST::Op.new(
                        :op('if'),
                        QAST::Var.new( :name($state), :scope('lexical') ),
                        $false,
                        QAST::Op.new( :op('call'), :name('&infix:<~~>'), $topic, $lhs )
                    ) !!
                    QAST::Op.new( :op('call'), :name('&infix:<~~>'), $topic, $lhs )
                ),
            ),
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name($id ~ '_rhs'), :scope('local'), :decl('var') ),
                (nqp::getattr($SELF, RakuAST::FlipFlop, '$!one-only') ??
                    QAST::Op.new(
                        :op('if'),
                        QAST::Var.new( :name($state), :scope('lexical') ),
                        QAST::Op.new( :op('call'), :name('&infix:<~~>'), $topic, $rhs ),
                        $false
                    ) !!
                    QAST::Op.new( :op('call'), :name('&infix:<~~>'), $topic, $rhs )
                )
            )
        );

        # Now decide what to do based on current state and current
        # results.
        $ff-code.push(QAST::Op.new(
            :op('if'),
            QAST::Var.new( :name($state), :scope('lexical') ),

            # State is currently true. Check RHS. If it's false, then we
            # increment the sequence count. If it's true, then we reset,
            # the state to zero and and what we return depends on $excludes-max.
            QAST::Op.new(
                :op('if'),
                QAST::Var.new( :name($id ~ '_rhs'), :scope('local') ),
                (nqp::getattr($SELF, RakuAST::FlipFlop, '$!excludes-max') ??
                QAST::Stmts.new(
                    QAST::Op.new(
                        :op('p6store'),
                        QAST::Var.new( :name($state), :scope('lexical') ),
                        $zero
                        ),
                    $nil
                    ) !!
                    QAST::Stmts.new(
                        QAST::Op.new(
                            :op('bind'),
                            QAST::Var.new( :name($id ~ '_orig'), :scope('local'), :decl('var') ),
                            QAST::Op.new(
                                :op('call'), :name('&prefix:<++>'),
                                QAST::Var.new( :name($state), :scope('lexical') )
                                )
                            ),
                        QAST::Op.new(
                            :op('p6store'),
                            QAST::Var.new( :name($state), :scope('lexical') ),
                            $zero
                            ),
                        QAST::Op.new(
                            :op('decont'),
                            QAST::Var.new( :name($id ~ '_orig'), :scope('local') )
                            )
                        )),
                QAST::Stmts.new(
                    QAST::Op.new(
                        :op('call'), :name('&prefix:<++>'),
                        QAST::Var.new( :name($state), :scope('lexical') )
                        )
                    )
                ),

            # State is currently false. Check LHS. If it's false, then we
            # stay in a false state. If it's true, then we flip the bit,
            # but only if the RHS is not also true. We return a result
            # based on $excludes-min.
            QAST::Op.new(
                :op('if'),
                QAST::Var.new( :name($id ~ '_lhs'), :scope('local') ),
                QAST::Op.new(
                    :op('if'),
                    QAST::Var.new( :name($id ~ '_rhs'), :scope('local') ),
                    nqp::getattr($SELF, RakuAST::FlipFlop, '$!excludes-min') || nqp::getattr($SELF, RakuAST::FlipFlop, '$!excludes-max') ?? $nil !! $one,
                    QAST::Stmts.new(
                        QAST::Op.new(
                            :op('p6store'),
                            QAST::Var.new( :name($state), :scope('lexical') ),
                            $one
                            ),
                        nqp::getattr($SELF, RakuAST::FlipFlop, '$!excludes-min') ?? $nil !! $one
                        )
                    ),
                $nil
                )
            ));

        QAST::Op.new( :op('locallifetime'), $ff-code, $id ~ '_lhs', $id ~ '_rhs' );
    
    });
    add-method(RakuAST::FlipFlop, 'visit-children', [RakuAST::FlipFlop, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 698 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::FlipFlop, '$!state-var'))
    
    });
#line 524 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::FlipFlop, 'state-id', [], anon sub state-id ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::FlipFlop, '$!state-id') });
#line 522 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::FlipFlop, 'one-only', [], anon sub one-only ($self) { nqp::getattr(nqp::decont($self), RakuAST::FlipFlop, '$!one-only') });
#line 520 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::FlipFlop, 'excludes-min', [], anon sub excludes-min ($self) { nqp::getattr(nqp::decont($self), RakuAST::FlipFlop, '$!excludes-min') });
#line 521 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::FlipFlop, 'excludes-max', [], anon sub excludes-max ($self) { nqp::getattr(nqp::decont($self), RakuAST::FlipFlop, '$!excludes-max') });
    compose(RakuAST::FlipFlop);
    parent(RakuAST::Assignment, RakuAST::Infix);
    add-attribute(RakuAST::Assignment, int, '$!item');
    add-attribute(RakuAST::Assignment, OperatorProperties, '$!properties');
    add-method(RakuAST::Assignment, 'new', [RakuAST::Assignment, '', 0, 0, Bool, '$item', 1, 1], anon sub new ($SELF_CONT, :$item?) {
        my $SELF := nqp::decont($SELF_CONT);
        $item := nqp::decont($item);
#line 714 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj,RakuAST::Infix,'$!operator','=');
        nqp::bindattr_i($obj,RakuAST::Assignment,'$!item',$item ?? 1 !! 0);
        nqp::bindattr($obj,RakuAST::Assignment,'$!properties',
          OperatorProperties.infix($item ?? '$=' !! '@='));
        $obj
    
    });
    add-method(RakuAST::Assignment, 'item', [RakuAST::Assignment, '', 0, 0], anon sub item ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 722 src/Raku/ast/expressions.rakumod
         nqp::getattr_i($SELF, RakuAST::Assignment, '$!item') ?? (Bool.WHO)<True> !! (Bool.WHO)<False> 
    });
#line 712 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Assignment, 'properties', [], anon sub properties ($self) { nqp::getattr(nqp::decont($self), RakuAST::Assignment, '$!properties') });
    compose(RakuAST::Assignment);
    parent(RakuAST::BracketedInfix, RakuAST::Infixish);
    add-attribute(RakuAST::BracketedInfix, RakuAST::Infixish, '$!infix');
    add-method(RakuAST::BracketedInfix, 'new', [RakuAST::BracketedInfix, '', 0, 0, RakuAST::Infixish, '$infix', 0, 0], anon sub new ($SELF_CONT, $infix!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
#line 731 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::BracketedInfix, '$!infix', $infix);
        $obj
    
    });
    add-method(RakuAST::BracketedInfix, 'properties', [RakuAST::BracketedInfix, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 737 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::BracketedInfix, '$!infix').properties 
    });
    add-method(RakuAST::BracketedInfix, 'visit-children', [RakuAST::BracketedInfix, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 739 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::BracketedInfix, '$!infix'));
    
    });
    add-method(RakuAST::BracketedInfix, 'reducer-name', [RakuAST::BracketedInfix, '', 0, 0], anon sub reducer-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 743 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::BracketedInfix, '$!infix').reducer-name 
    });
    add-method(RakuAST::BracketedInfix, 'IMPL-INFIX-COMPILE', [RakuAST::BracketedInfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$left', 0, 0, RakuAST::Expression, '$right', 0, 0], anon sub IMPL-INFIX-COMPILE ($SELF_CONT, $context!, $left!, $right!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left := nqp::decont($left);
        $right := nqp::decont($right);
#line 746 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::BracketedInfix, '$!infix').IMPL-INFIX-COMPILE($context, $left, $right)
    
    });
    add-method(RakuAST::BracketedInfix, 'IMPL-INFIX-QAST', [RakuAST::BracketedInfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$left-qast', 0, 0, Mu, '$right-qast', 0, 0], anon sub IMPL-INFIX-QAST ($SELF_CONT, $context!, $left-qast!, $right-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left-qast := nqp::decont($left-qast);
        $right-qast := nqp::decont($right-qast);
#line 750 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::BracketedInfix, '$!infix').IMPL-INFIX-QAST($context, $left-qast, $right-qast)
    
    });
    add-method(RakuAST::BracketedInfix, 'IMPL-HOP-INFIX-QAST', [RakuAST::BracketedInfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 754 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::BracketedInfix, '$!infix').IMPL-HOP-INFIX-QAST($context)
    
    });
#line 729 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::BracketedInfix, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::BracketedInfix, '$!infix') });
    compose(RakuAST::BracketedInfix);
    parent(RakuAST::FunctionInfix, RakuAST::Infixish);
    add-attribute(RakuAST::FunctionInfix, RakuAST::Expression, '$!function');
    add-method(RakuAST::FunctionInfix, 'new', [RakuAST::FunctionInfix, '', 0, 0, RakuAST::Expression, '$function', 0, 0], anon sub new ($SELF_CONT, $function!) {
        my $SELF := nqp::decont($SELF_CONT);
        $function := nqp::decont($function);
#line 765 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::FunctionInfix, '$!function', $function);
        $obj
    
    });
    add-method(RakuAST::FunctionInfix, 'visit-children', [RakuAST::FunctionInfix, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 771 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::FunctionInfix, '$!function'));
    
    });
    add-method(RakuAST::FunctionInfix, 'properties', [RakuAST::FunctionInfix, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 775 src/Raku/ast/expressions.rakumod
        
        # Should check if operator properties can be derived from $!function,
        # and should default to:
        OperatorProperties.infix('+')
    
    });
    add-method(RakuAST::FunctionInfix, 'reducer-name', [RakuAST::FunctionInfix, '', 0, 0], anon sub reducer-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 781 src/Raku/ast/expressions.rakumod
         '&METAOP_REDUCE_LEFT' 
    });
    add-method(RakuAST::FunctionInfix, 'IMPL-INFIX-QAST', [RakuAST::FunctionInfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$left-qast', 0, 0, Mu, '$right-qast', 0, 0], anon sub IMPL-INFIX-QAST ($SELF_CONT, $context!, $left-qast!, $right-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left-qast := nqp::decont($left-qast);
        $right-qast := nqp::decont($right-qast);
#line 783 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new:
            :op('call'),
            nqp::getattr($SELF, RakuAST::FunctionInfix, '$!function').IMPL-TO-QAST($context),
            $left-qast, $right-qast
    
    });
    add-method(RakuAST::FunctionInfix, 'IMPL-HOP-INFIX-QAST', [RakuAST::FunctionInfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 790 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::FunctionInfix, '$!function').IMPL-TO-QAST($context)
    
    });
#line 763 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::FunctionInfix, 'function', [], anon sub function ($self) { nqp::getattr(nqp::decont($self), RakuAST::FunctionInfix, '$!function') });
    compose(RakuAST::FunctionInfix);
    parent(RakuAST::MetaInfix, RakuAST::Infixish);
    parent(RakuAST::MetaInfix, RakuAST::CheckTime);
    add-method(RakuAST::MetaInfix, 'IMPL-HOP-INFIX', [RakuAST::MetaInfix, '', 0, 0], anon sub IMPL-HOP-INFIX ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 803 src/Raku/ast/expressions.rakumod
        
        $SELF.get-implicit-lookups().AT-POS(0).resolution.compile-time-value()(
            $SELF.infix.resolution.compile-time-value
        )
    
    });
    add-method(RakuAST::MetaInfix, 'PERFORM-CHECK', [RakuAST::MetaInfix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 812 src/Raku/ast/expressions.rakumod
        
        $SELF.properties.fiddly
          ?? $SELF.add-sorry(
               $resolver.build-exception("X::Syntax::CannotMeta",
                 meta     => "negate",
                 operator => $SELF.infix.operator,
                 dba      => $SELF.properties.dba,
                 reason   => "too fiddly"
               )
             )
          !! (Bool.WHO)<True>
    
    });
    add-method(RakuAST::MetaInfix, 'IMPL-CURRIES', [RakuAST::MetaInfix, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 825 src/Raku/ast/expressions.rakumod
         $SELF.infix.IMPL-CURRIES 
    });
    compose(RakuAST::MetaInfix);
    parent(RakuAST::MetaInfix::Assign, RakuAST::MetaInfix);
    add-attribute(RakuAST::MetaInfix::Assign, RakuAST::Infixish, '$!infix');
    add-method(RakuAST::MetaInfix::Assign, 'new', [RakuAST::MetaInfix::Assign, '', 0, 0, RakuAST::Infixish, '$infix', 0, 0], anon sub new ($SELF_CONT, $infix!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
#line 834 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::MetaInfix::Assign, '$!infix', $infix);
        $obj
    
    });
    add-method(RakuAST::MetaInfix::Assign, 'visit-children', [RakuAST::MetaInfix::Assign, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 840 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::MetaInfix::Assign, '$!infix'));
    
    });
    add-method(RakuAST::MetaInfix::Assign, 'PERFORM-CHECK', [RakuAST::MetaInfix::Assign, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 847 src/Raku/ast/expressions.rakumod
        
        my $properties := $SELF.properties;
        $properties.fiddly || $properties.diffy
          ?? $SELF.add-sorry(
               $resolver.build-exception("X::Syntax::CannotMeta",
                 meta     => "assign",
                 operator => $SELF.infixx.operator,
                 reason   => "too fiddly or diffy"
               )
             )
          !! (Bool.WHO)<True>
    
    });
    add-method(RakuAST::MetaInfix::Assign, 'properties', [RakuAST::MetaInfix::Assign, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 860 src/Raku/ast/expressions.rakumod
         OperatorProperties.infix('$=') 
    });
    add-method(RakuAST::MetaInfix::Assign, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::MetaInfix::Assign, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 862 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('&METAOP_ASSIGN')),
        ])
    
    });
    add-method(RakuAST::MetaInfix::Assign, 'IMPL-CURRIES', [RakuAST::MetaInfix::Assign, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 868 src/Raku/ast/expressions.rakumod
         0 
    });
    add-method(RakuAST::MetaInfix::Assign, 'IMPL-INFIX-QAST', [RakuAST::MetaInfix::Assign, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$left-qast', 0, 0, Mu, '$right-qast', 0, 0], anon sub IMPL-INFIX-QAST ($SELF_CONT, $context!, $left-qast!, $right-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left-qast := nqp::decont($left-qast);
        $right-qast := nqp::decont($right-qast);
#line 870 src/Raku/ast/expressions.rakumod
        
        if nqp::istype(nqp::getattr($SELF, RakuAST::MetaInfix::Assign, '$!infix'), RakuAST::Infix) && nqp::getattr($SELF, RakuAST::MetaInfix::Assign, '$!infix').properties.short-circuit {
            # TODO case-analyzed assignments
            my $temp := QAST::Node.unique('meta_assign');
            my $bind-lhs := QAST::Op.new(
              :op<bind>,
              QAST::Var.new(:decl('var'), :scope('local'), :name($temp)),
              $left-qast
            );
            # Compile the short-circuit ones "inside out", so we can avoid the
            # assignment.
            QAST::Stmt.new(
                $bind-lhs,
                nqp::getattr($SELF, RakuAST::MetaInfix::Assign, '$!infix').IMPL-INFIX-QAST(
                    $context,
                    QAST::Var.new( :scope('local'), :name($temp) ),
                    QAST::Op.new(
                        :op('assign'),
                        QAST::Var.new( :scope('local'), :name($temp) ),
                        $right-qast
                    )
                )
            )
        }
        else {
            QAST::Op.new(:op<call>,
              $SELF.IMPL-HOP-INFIX-QAST($context) , $left-qast, $right-qast
            )
        }
    
    });
    add-method(RakuAST::MetaInfix::Assign, 'IMPL-HOP-INFIX-QAST', [RakuAST::MetaInfix::Assign, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 901 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new:
            :op('callstatic'), :name('&METAOP_ASSIGN'),
            nqp::getattr($SELF, RakuAST::MetaInfix::Assign, '$!infix').IMPL-HOP-INFIX-QAST($context)
    
    });
#line 832 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Assign, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Assign, '$!infix') });
    compose(RakuAST::MetaInfix::Assign);
    parent(RakuAST::MetaInfix::Negate, RakuAST::MetaInfix);
    add-attribute(RakuAST::MetaInfix::Negate, RakuAST::Infixish, '$!infix');
    add-method(RakuAST::MetaInfix::Negate, 'new', [RakuAST::MetaInfix::Negate, '', 0, 0, RakuAST::Infixish, '$infix', 0, 0], anon sub new ($SELF_CONT, $infix!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
#line 914 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::MetaInfix::Negate, '$!infix', $infix);
        $obj
    
    });
    add-method(RakuAST::MetaInfix::Negate, 'visit-children', [RakuAST::MetaInfix::Negate, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 920 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::MetaInfix::Negate, '$!infix'));
    
    });
    add-method(RakuAST::MetaInfix::Negate, 'PERFORM-CHECK', [RakuAST::MetaInfix::Negate, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 927 src/Raku/ast/expressions.rakumod
        
        $SELF.properties.iffy
          || $SELF.add-sorry:
               $resolver.build-exception: "X::Syntax::CannotMeta",
                 meta     => "negate",
                 operator => $SELF.infix.operator,
                 dba      => $SELF.properties.dba,
                 reason   => "not iffy enough"
    
    });
    add-method(RakuAST::MetaInfix::Negate, 'properties', [RakuAST::MetaInfix::Negate, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 937 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::MetaInfix::Negate, '$!infix').properties 
    });
    add-method(RakuAST::MetaInfix::Negate, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::MetaInfix::Negate, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 939 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('&METAOP_NEGATE')),
        ])
    
    });
    add-method(RakuAST::MetaInfix::Negate, 'IMPL-INFIX-QAST', [RakuAST::MetaInfix::Negate, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$left-qast', 0, 0, Mu, '$right-qast', 0, 0], anon sub IMPL-INFIX-QAST ($SELF_CONT, $context!, $left-qast!, $right-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left-qast := nqp::decont($left-qast);
        $right-qast := nqp::decont($right-qast);
#line 945 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new(:op<hllbool>,
          QAST::Op.new(:op<isfalse>,
            nqp::getattr($SELF, RakuAST::MetaInfix::Negate, '$!infix').IMPL-INFIX-QAST($context, $left-qast, $right-qast)
          )
        )
    
    });
    add-method(RakuAST::MetaInfix::Negate, 'IMPL-HOP-INFIX-QAST', [RakuAST::MetaInfix::Negate, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 953 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new(:op<call>,
          :name<&METAOP_NEGATE>, nqp::getattr($SELF, RakuAST::MetaInfix::Negate, '$!infix').IMPL-HOP-INFIX-QAST($context)
        )
    
    });
#line 912 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Negate, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Negate, '$!infix') });
    compose(RakuAST::MetaInfix::Negate);
    parent(RakuAST::MetaInfix::Reverse, RakuAST::MetaInfix);
    add-attribute(RakuAST::MetaInfix::Reverse, RakuAST::Infixish, '$!infix');
    add-attribute(RakuAST::MetaInfix::Reverse, OperatorProperties, '$!properties');
    add-method(RakuAST::MetaInfix::Reverse, 'new', [RakuAST::MetaInfix::Reverse, '', 0, 0, RakuAST::Infixish, '$infix', 0, 0], anon sub new ($SELF_CONT, $infix!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
#line 967 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::MetaInfix::Reverse, '$!infix', $infix);
        nqp::bindattr($obj, RakuAST::MetaInfix::Reverse, '$!properties',
          $infix.properties.associative-reversed);
        $obj
    
    });
    add-method(RakuAST::MetaInfix::Reverse, 'visit-children', [RakuAST::MetaInfix::Reverse, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 975 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::MetaInfix::Reverse, '$!infix'));
    
    });
    add-method(RakuAST::MetaInfix::Reverse, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::MetaInfix::Reverse, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 979 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('&METAOP_REVERSE')),
        ])
    
    });
    add-method(RakuAST::MetaInfix::Reverse, 'IMPL-INFIX-QAST', [RakuAST::MetaInfix::Reverse, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$left-qast', 0, 0, Mu, '$right-qast', 0, 0], anon sub IMPL-INFIX-QAST ($SELF_CONT, $context!, $left-qast!, $right-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left-qast := nqp::decont($left-qast);
        $right-qast := nqp::decont($right-qast);
#line 985 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::MetaInfix::Reverse, '$!infix').IMPL-INFIX-QAST($context, $right-qast, $left-qast)
    
    });
    add-method(RakuAST::MetaInfix::Reverse, 'IMPL-HOP-INFIX-QAST', [RakuAST::MetaInfix::Reverse, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 989 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new:
            :op('callstatic'), :name('&METAOP_REVERSE'),
            nqp::getattr($SELF, RakuAST::MetaInfix::Reverse, '$!infix').IMPL-HOP-INFIX-QAST($context)
    
    });
#line 965 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Reverse, 'properties', [], anon sub properties ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Reverse, '$!properties') });
#line 964 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Reverse, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Reverse, '$!infix') });
    compose(RakuAST::MetaInfix::Reverse);
    parent(RakuAST::MetaInfix::Cross, RakuAST::MetaInfix);
    add-attribute(RakuAST::MetaInfix::Cross, RakuAST::Infixish, '$!infix');
    add-method(RakuAST::MetaInfix::Cross, 'new', [RakuAST::MetaInfix::Cross, '', 0, 0, RakuAST::Infixish, '$infix', 0, 0], anon sub new ($SELF_CONT, $infix!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
#line 1002 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::MetaInfix::Cross, '$!infix', $infix);
        $obj
    
    });
    add-method(RakuAST::MetaInfix::Cross, 'visit-children', [RakuAST::MetaInfix::Cross, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1008 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::MetaInfix::Cross, '$!infix'));
    
    });
    add-method(RakuAST::MetaInfix::Cross, 'properties', [RakuAST::MetaInfix::Cross, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1012 src/Raku/ast/expressions.rakumod
         OperatorProperties.infix('X') 
    });
    add-method(RakuAST::MetaInfix::Cross, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::MetaInfix::Cross, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1014 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('&METAOP_CROSS')),
        ])
    
    });
    add-method(RakuAST::MetaInfix::Cross, 'IMPL-LIST-INFIX-QAST', [RakuAST::MetaInfix::Cross, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operands', 0, 0], anon sub IMPL-LIST-INFIX-QAST ($SELF_CONT, $context!, $operands!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operands := nqp::decont($operands);
#line 1020 src/Raku/ast/expressions.rakumod
        
        my $op := QAST::Op.new( :op('call'), $SELF.IMPL-HOP-INFIX-QAST($context) );
        for $operands {
            $op.push($_);
        }
        $op
    
    });
    add-method(RakuAST::MetaInfix::Cross, 'IMPL-HOP-INFIX-QAST', [RakuAST::MetaInfix::Cross, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1028 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new:
            :op('callstatic'), :name('&METAOP_CROSS'),
            nqp::getattr($SELF, RakuAST::MetaInfix::Cross, '$!infix').IMPL-HOP-INFIX-QAST($context),
            QAST::Var.new( :name(nqp::getattr($SELF, RakuAST::MetaInfix::Cross, '$!infix').reducer-name), :scope('lexical') )
    
    });
#line 1000 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Cross, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Cross, '$!infix') });
    compose(RakuAST::MetaInfix::Cross);
    parent(RakuAST::MetaInfix::Zip, RakuAST::MetaInfix);
    add-attribute(RakuAST::MetaInfix::Zip, RakuAST::Infixish, '$!infix');
    add-method(RakuAST::MetaInfix::Zip, 'new', [RakuAST::MetaInfix::Zip, '', 0, 0, RakuAST::Infixish, '$infix', 0, 0], anon sub new ($SELF_CONT, $infix!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
#line 1042 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::MetaInfix::Zip, '$!infix', $infix);
        $obj
    
    });
    add-method(RakuAST::MetaInfix::Zip, 'visit-children', [RakuAST::MetaInfix::Zip, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1048 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::MetaInfix::Zip, '$!infix'));
    
    });
    add-method(RakuAST::MetaInfix::Zip, 'properties', [RakuAST::MetaInfix::Zip, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1052 src/Raku/ast/expressions.rakumod
         OperatorProperties.infix('Z') 
    });
    add-method(RakuAST::MetaInfix::Zip, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::MetaInfix::Zip, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1054 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('&METAOP_ZIP')),
        ])
    
    });
    add-method(RakuAST::MetaInfix::Zip, 'IMPL-LIST-INFIX-QAST', [RakuAST::MetaInfix::Zip, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operands', 0, 0], anon sub IMPL-LIST-INFIX-QAST ($SELF_CONT, $context!, $operands!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operands := nqp::decont($operands);
#line 1060 src/Raku/ast/expressions.rakumod
        
        my $op := QAST::Op.new( :op('call'), $SELF.IMPL-HOP-INFIX-QAST($context) );
        for $operands {
            $op.push($_);
        }
        $op
    
    });
    add-method(RakuAST::MetaInfix::Zip, 'IMPL-HOP-INFIX-QAST', [RakuAST::MetaInfix::Zip, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1068 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new:
            :op('callstatic'), :name('&METAOP_ZIP'),
            nqp::getattr($SELF, RakuAST::MetaInfix::Zip, '$!infix').IMPL-HOP-INFIX-QAST($context),
            QAST::Var.new( :name(nqp::getattr($SELF, RakuAST::MetaInfix::Zip, '$!infix').reducer-name), :scope('lexical') )
    
    });
#line 1040 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Zip, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Zip, '$!infix') });
    compose(RakuAST::MetaInfix::Zip);
    parent(RakuAST::MetaInfix::Hyper, RakuAST::MetaInfix);
    add-attribute(RakuAST::MetaInfix::Hyper, RakuAST::Infixish, '$!infix');
    add-attribute(RakuAST::MetaInfix::Hyper, Bool, '$!dwim-left');
    add-attribute(RakuAST::MetaInfix::Hyper, Bool, '$!dwim-right');
    add-method(RakuAST::MetaInfix::Hyper, 'new', [RakuAST::MetaInfix::Hyper, '', 0, 0, RakuAST::Infixish, '$infix', 1, 0, Bool, '$dwim-left', 1, 1, Bool, '$dwim-right', 1, 1], anon sub new ($SELF_CONT, :$infix!, :$dwim-left?, :$dwim-right?) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
        $dwim-left := nqp::decont($dwim-left);
        $dwim-right := nqp::decont($dwim-right);
#line 1084 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::MetaInfix::Hyper, '$!infix', $infix);
        nqp::bindattr($obj, RakuAST::MetaInfix::Hyper, '$!dwim-left',
            $dwim-left ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::MetaInfix::Hyper, '$!dwim-right',
            $dwim-right ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::MetaInfix::Hyper, 'visit-children', [RakuAST::MetaInfix::Hyper, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1094 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::MetaInfix::Hyper, '$!infix'));
    
    });
    add-method(RakuAST::MetaInfix::Hyper, 'properties', [RakuAST::MetaInfix::Hyper, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1098 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::MetaInfix::Hyper, '$!infix').properties 
    });
    add-method(RakuAST::MetaInfix::Hyper, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::MetaInfix::Hyper, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1100 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('&METAOP_HYPER')),
        ])
    
    });
    add-method(RakuAST::MetaInfix::Hyper, 'IMPL-INFIX-QAST', [RakuAST::MetaInfix::Hyper, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$left-qast', 0, 0, Mu, '$right-qast', 0, 0], anon sub IMPL-INFIX-QAST ($SELF_CONT, $context!, $left-qast!, $right-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $left-qast := nqp::decont($left-qast);
        $right-qast := nqp::decont($right-qast);
#line 1106 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new:
            :op('call'),
            $SELF.IMPL-HOP-INFIX-QAST($context),
            $left-qast,
            $right-qast
    
    });
    add-method(RakuAST::MetaInfix::Hyper, 'IMPL-HOP-INFIX-QAST', [RakuAST::MetaInfix::Hyper, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-INFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1114 src/Raku/ast/expressions.rakumod
        
        my $call := QAST::Op.new:
            :op('callstatic'), :name('&METAOP_HYPER'),
            nqp::getattr($SELF, RakuAST::MetaInfix::Hyper, '$!infix').IMPL-HOP-INFIX-QAST($context);
        if nqp::getattr($SELF, RakuAST::MetaInfix::Hyper, '$!dwim-left') {
            $call.push: QAST::WVal.new: :value((Bool.WHO)<True>), :named('dwim-left');
        }
        if nqp::getattr($SELF, RakuAST::MetaInfix::Hyper, '$!dwim-right') {
            $call.push: QAST::WVal.new: :value((Bool.WHO)<True>), :named('dwim-right');
        }
        $call
    
    });
    add-method(RakuAST::MetaInfix::Hyper, 'IMPL-HOP-INFIX', [RakuAST::MetaInfix::Hyper, '', 0, 0], anon sub IMPL-HOP-INFIX ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1127 src/Raku/ast/expressions.rakumod
        
        $SELF.get-implicit-lookups().AT-POS(0).resolution.compile-time-value()(
            $SELF.infix.resolution.compile-time-value,
            :dwim-left(nqp::getattr($SELF, RakuAST::MetaInfix::Hyper, '$!dwim-left')),
            :dwim-right(nqp::getattr($SELF, RakuAST::MetaInfix::Hyper, '$!dwim-right'))
        )
    
    });
#line 1080 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Hyper, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Hyper, '$!infix') });
#line 1082 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Hyper, 'dwim-right', [], anon sub dwim-right ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Hyper, '$!dwim-right') });
#line 1081 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaInfix::Hyper, 'dwim-left', [], anon sub dwim-left ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaInfix::Hyper, '$!dwim-left') });
    compose(RakuAST::MetaInfix::Hyper);
    parent(RakuAST::WhateverApplicable, Any);
    add-method(RakuAST::WhateverApplicable, 'IMPL-SHOULD-CURRY-DIRECTLY', [RakuAST::WhateverApplicable, '', 0, 0], anon sub IMPL-SHOULD-CURRY-DIRECTLY ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1148 src/Raku/ast/expressions.rakumod
        
        return (Bool.WHO)<False> unless nqp::bitand_i($SELF.operator.IMPL-CURRIES, 1);
        return (Bool.WHO)<False> unless $SELF.IMPL-CUSTOM-SHOULD-CURRY-CONDITIONS;
        for $SELF.IMPL-UNWRAP-LIST($SELF.operands) {
            return (Bool.WHO)<True> if nqp::istype($_, RakuAST::Term::Whatever)
        }
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::WhateverApplicable, 'IMPL-OPERANDS-SHOULD-CURRY-DIRECTLY', [RakuAST::WhateverApplicable, '', 0, 0], anon sub IMPL-OPERANDS-SHOULD-CURRY-DIRECTLY ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1157 src/Raku/ast/expressions.rakumod
        
        my $should-so := (Bool.WHO)<False>;
        for $SELF.IMPL-UNWRAP-LIST($SELF.operands) {
            $should-so := $should-so || (nqp::istype($_, RakuAST::WhateverApplicable) && $_.IMPL-SHOULD-CURRY-DIRECTLY)
                                     || (nqp::istype($_, RakuAST::Circumfix::Parentheses) && $_.IMPL-CONTAINS-SINGULAR-CURRYABLE-EXPRESSION)
        }
        $should-so
    
    });
    add-method(RakuAST::WhateverApplicable, 'IMPL-CUSTOM-SHOULD-CURRY-CONDITIONS', [RakuAST::WhateverApplicable, '', 0, 0], anon sub IMPL-CUSTOM-SHOULD-CURRY-CONDITIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1167 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::WhateverApplicable, 'IMPL-ALL-CHILDREN-THAT-SHOULD-CURRY', [RakuAST::WhateverApplicable, '', 0, 0], anon sub IMPL-ALL-CHILDREN-THAT-SHOULD-CURRY ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1170 src/Raku/ast/expressions.rakumod
        
        return [] unless nqp::bitand_i($SELF.operator.IMPL-CURRIES, 2);
        # Calculate self-based gaurds for $stopper only once
        my $self-is-xx := nqp::istype($SELF, RakuAST::ApplyInfix)
                && (my $operator := $SELF.operator)
                && nqp::istype($operator, RakuAST::Infix)
                && $operator.operator eq 'xx';

        my $condition := -> $n { $n.IMPL-SHOULD-CURRY-DIRECTLY || $n.IMPL-OPERANDS-SHOULD-CURRY-DIRECTLY };
        my $stopper   := -> $n {
            nqp::istype($n, RakuAST::Block)
                || nqp::istype($n, RakuAST::Postcircumfix::ArrayIndex)
                || nqp::istype($n, RakuAST::Call)
                || nqp::istype($n, RakuAST::VarDeclaration::Simple)
                || (nqp::istype($n, RakuAST::WhateverApplicable) && !nqp::bitand_i($n.operator.IMPL-CURRIES, 2))
                || ($self-is-xx && nqp::istype($n, RakuAST::ApplyInfix) && $n.IMPL-SHOULD-CURRY-DIRECTLY)
        }
        $SELF.IMPL-UNWRAP-LIST($SELF.find-nodes-exclusive(RakuAST::WhateverApplicable, :$condition, :$stopper))
    
    });
    add-method(RakuAST::WhateverApplicable, 'IMPL-SHOULD-CURRY-ACROSS-ALL-CHILDREN', [RakuAST::WhateverApplicable, '', 0, 0], anon sub IMPL-SHOULD-CURRY-ACROSS-ALL-CHILDREN ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1190 src/Raku/ast/expressions.rakumod
        
        $SELF.IMPL-SHOULD-CURRY-DIRECTLY || $SELF.IMPL-OPERANDS-SHOULD-CURRY-DIRECTLY || nqp::elems($SELF.IMPL-ALL-CHILDREN-THAT-SHOULD-CURRY) > 0
    
    });
    add-method(RakuAST::WhateverApplicable, 'IMPL-CURRY-ACROSS-ALL-CHILDREN', [RakuAST::WhateverApplicable, '', 0, 0, Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::CurryThunk, '$curried', 0, 0], anon sub IMPL-CURRY-ACROSS-ALL-CHILDREN ($SELF_CONT, $resolver!, $context!, $curried!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $curried := nqp::decont($curried);
#line 1197 src/Raku/ast/expressions.rakumod
        
        my $operator-curries := $SELF.operator.IMPL-CURRIES;
        my @curryable-children := $SELF.IMPL-ALL-CHILDREN-THAT-SHOULD-CURRY;
        @curryable-children.unshift($SELF) if $SELF.IMPL-SHOULD-CURRY-DIRECTLY || $SELF.IMPL-OPERANDS-SHOULD-CURRY-DIRECTLY;

        while @curryable-children {
            my $child := @curryable-children.shift;
            my $child-curries := $child.operator.IMPL-CURRIES;
            my $child-curries-whatever := nqp::bitand_i($child-curries, 1);
            my $child-curries-whatevercode := nqp::bitand_i($child-curries, 2);

            # We might have already visited this node and resolved the RakuAST::Term::Whatever nodes to the
            # respective $whatevercode_arg parameter target. If so, move on!
            next unless $child.IMPL-SHOULD-CURRY-DIRECTLY || $child.IMPL-OPERANDS-SHOULD-CURRY-DIRECTLY;

            # Each of these has their own small specificities, such as the name of the class/attribute to bind into
            # but they follow the same patterns.
            # For ApplyInfix and ApplyListInfix
            #   - For all $child.operands, inspect each to determine whether we should should curry across all of their
            #       (curryable) children.
            #   - Otherwise, check to determine if this is operand is a curryable whatever *. If so, call IMPL-ADD-PARAM
            #       to create a new '$whatevercode_arg_*' parameter and then bind the lookup to the target of that parameter
            #       into the location that previously held the curryable *.
            # For ApplyPrefix and ApplyPostfix
            #   - Same procedure as above, except we only check for direct curryability rather than whether there are curryable children.
            #       Instead we utilize their respective PERFORM-BEGIN-AFTER-CHILDREN routines to finalize relevant currables.
             if nqp::istype($child, RakuAST::ApplyListInfix) {
                my @operands := $SELF.IMPL-UNWRAP-LIST($SELF.operands);
                my $index := -1;
                for @operands {
                    my $operand := $_;
                    $index++; # it needs to count every time so that we write into the appropriate slot in @operands
                    if  $child-curries-whatevercode
                            &&
                        ((nqp::istype($operand, RakuAST::WhateverApplicable)
                            && $operand.IMPL-SHOULD-CURRY-ACROSS-ALL-CHILDREN)
                                ||
                        ($child-curries-whatever
                            && nqp::istype($operand, RakuAST::Circumfix::Parentheses)
                            && (my $curryable-expression := $operand.IMPL-CONTAINS-SINGULAR-CURRYABLE-EXPRESSION)
                            && $curryable-expression.IMPL-SHOULD-CURRY-ACROSS-ALL-CHILDREN))
                    {
                        ($curryable-expression // $operand).IMPL-CURRY-ACROSS-ALL-CHILDREN($resolver, $context, $curried);
                    }
                    next unless $child-curries-whatever && nqp::istype($operand, RakuAST::Term::Whatever);
                    @operands[$index] := $curried.IMPL-ADD-PARAM($resolver, $context).target.generate-lookup;
                }
                nqp::bindattr($child, RakuAST::ApplyListInfix, '$!operands', @operands);
            }
            elsif nqp::istype($child, RakuAST::ApplyInfix) {
                for "left", "right" {
                    my $operand := $child."$_"();
                    if  $child-curries-whatevercode
                            &&
                        ((nqp::istype($operand, RakuAST::WhateverApplicable)
                            && $operand.IMPL-SHOULD-CURRY-ACROSS-ALL-CHILDREN)
                                ||
                        ($child-curries-whatever
                            && nqp::istype($operand, RakuAST::Circumfix::Parentheses)
                            && (my $curryable-expression := $operand.IMPL-CONTAINS-SINGULAR-CURRYABLE-EXPRESSION)
                            && $curryable-expression.IMPL-SHOULD-CURRY-ACROSS-ALL-CHILDREN))
                    {
                        ($curryable-expression // $operand).IMPL-CURRY-ACROSS-ALL-CHILDREN($resolver, $context, $curried);
                    }
                    next unless $child-curries-whatever && nqp::istype($operand, RakuAST::Term::Whatever);
                    $child."set-$_"($curried.IMPL-ADD-PARAM($resolver, $context).target.generate-lookup);
                }
            }
            elsif nqp::istype($child, RakuAST::ApplyPostfix) {
                next unless $child-curries-whatever && nqp::istype($child.operand, RakuAST::Term::Whatever);
                nqp::bindattr($child, RakuAST::ApplyPostfix, '$!operand',
                    $curried.IMPL-ADD-PARAM($resolver, $context).target.generate-lookup);
            }
            elsif nqp::istype($child, RakuAST::ApplyPrefix) {
                next unless $child-curries-whatever && nqp::istype($child.operand, RakuAST::Term::Whatever);
                nqp::bindattr($child, RakuAST::ApplyPrefix, '$!operand',
                    $curried.IMPL-ADD-PARAM($resolver, $context).target.generate-lookup);
            }
        }
    
    });
    compose(RakuAST::WhateverApplicable);
    parent(RakuAST::ApplyInfix, RakuAST::Expression);
    parent(RakuAST::ApplyInfix, RakuAST::BeginTime);
    parent(RakuAST::ApplyInfix, RakuAST::CheckTime);
    parent(RakuAST::ApplyInfix, RakuAST::WhateverApplicable);
    add-attribute(RakuAST::ApplyInfix, RakuAST::Infixish, '$!infix');
    add-attribute(RakuAST::ApplyInfix, RakuAST::ArgList, '$!args');
    add-method(RakuAST::ApplyInfix, 'new', [RakuAST::ApplyInfix, '', 0, 0, RakuAST::Infixish, '$infix', 1, 0, RakuAST::Expression, '$left', 1, 0, RakuAST::Expression, '$right', 1, 0], anon sub new ($SELF_CONT, :$infix!, :$left!, :$right!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
        $left := nqp::decont($left);
        $right := nqp::decont($right);
#line 1290 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj,RakuAST::ApplyInfix,'$!infix',$infix);
        nqp::bindattr($obj,RakuAST::ApplyInfix,'$!args',RakuAST::ArgList.new);
        $obj.set-left($left);
        $obj.set-right($right);
        $obj
    
    });
    add-method(RakuAST::ApplyInfix, 'left', [RakuAST::ApplyInfix, '', 0, 0], anon sub left ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1299 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').arg-at-pos(0) 
    });
    add-method(RakuAST::ApplyInfix, 'set-left', [RakuAST::ApplyInfix, '', 0, 0, RakuAST::Expression, '$left', 0, 0], anon sub set-left ($SELF_CONT, $left!) {
        my $SELF := nqp::decont($SELF_CONT);
        $left := nqp::decont($left);
#line 1300 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').set-arg-at-pos(0, $left);
    
    });
    add-method(RakuAST::ApplyInfix, 'right', [RakuAST::ApplyInfix, '', 0, 0], anon sub right ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1303 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').arg-at-pos(1) 
    });
    add-method(RakuAST::ApplyInfix, 'set-right', [RakuAST::ApplyInfix, '', 0, 0, RakuAST::Expression, '$right', 0, 0], anon sub set-right ($SELF_CONT, $right!) {
        my $SELF := nqp::decont($SELF_CONT);
        $right := nqp::decont($right);
#line 1304 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').set-arg-at-pos(1, $right);
    
    });
    add-method(RakuAST::ApplyInfix, 'add-colonpair', [RakuAST::ApplyInfix, '', 0, 0, RakuAST::ColonPair, '$pair', 0, 0], anon sub add-colonpair ($SELF_CONT, $pair!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pair := nqp::decont($pair);
#line 1307 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').push($pair);
        Nil
    
    });
    add-method(RakuAST::ApplyInfix, 'operands', [RakuAST::ApplyInfix, '', 0, 0], anon sub operands ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1311 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').args) 
    });
    add-method(RakuAST::ApplyInfix, 'operator', [RakuAST::ApplyInfix, '', 0, 0], anon sub operator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1312 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyInfix, '$!infix') 
    });
    add-method(RakuAST::ApplyInfix, 'is-begin-performed-before-children', [RakuAST::ApplyInfix, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1314 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ApplyInfix, 'is-begin-performed-after-children', [RakuAST::ApplyInfix, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1315 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ApplyInfix, 'PERFORM-BEGIN-BEFORE-CHILDREN', [RakuAST::ApplyInfix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-BEFORE-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1317 src/Raku/ast/expressions.rakumod
        
        my $curried;
        if $SELF.IMPL-SHOULD-CURRY-ACROSS-ALL-CHILDREN {
            $curried := $SELF.IMPL-CURRY;
            $SELF.IMPL-CURRY-ACROSS-ALL-CHILDREN($resolver, $context, $curried);
        }
        # There is a chance that we didn't actually meet the conditions to curry inside of IMPL-CURRY-ACROSS-ALL-CHILDREN.
        # If no actual params have been set, we can assume that this happened.
        $SELF.IMPL-UNCURRY if $curried && nqp::elems($curried.IMPL-PARAMS) == 0;
    
    });
    add-method(RakuAST::ApplyInfix, 'PERFORM-BEGIN-AFTER-CHILDREN', [RakuAST::ApplyInfix, '', 0, 0, Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-AFTER-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1328 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyInfix, '$!infix').IMPL-THUNK-ARGUMENTS($resolver, $context, $SELF.left, $SELF.right);
    
    });
    add-method(RakuAST::ApplyInfix, 'PERFORM-CHECK', [RakuAST::ApplyInfix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1335 src/Raku/ast/expressions.rakumod
        
        my $infix := nqp::getattr($SELF, RakuAST::ApplyInfix, '$!infix');
        my $left  := $SELF.left;
        my $right := $SELF.right;

        # handle op=
        if nqp::eqaddr($infix.WHAT,RakuAST::MetaInfix::Assign) {
            my str $operator := $infix.infix.operator;
            if $operator eq ',' || $operator eq 'xx' {
                my $sigil := (try $left.sigil) // '';
                if $sigil eq '$' || $sigil eq '@' {
                    $SELF.add-worry:
                      $resolver.build-exception: 'X::AdHoc',
                        payload => "Using $operator on a "
                          ~ ($sigil eq '$' ?? 'scalar' !! 'array')
                          ~ " is probably NOT what you want, as it will create\n"
                          ~ "a self-referential structure with little meaning";
                }
            }
        }

        # a "normal" infix op
        elsif nqp::istype($infix,RakuAST::Infix) {
            if $infix.operator eq ':=' && !$left.can-be-bound-to {
                $SELF.add-sorry:
                  $resolver.build-exception: 'X::Bind';
            }
        }
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::ApplyInfix, 'IMPL-EXPR-QAST', [RakuAST::ApplyInfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1366 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyInfix, '$!infix').IMPL-INFIX-COMPILE($context, $SELF.left, $SELF.right)
    
    });
    add-method(RakuAST::ApplyInfix, 'visit-children', [RakuAST::ApplyInfix, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1370 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ApplyInfix, '$!infix'));
        $visitor(nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args'))
    
    });
    add-method(RakuAST::ApplyInfix, 'IMPL-CAN-INTERPRET', [RakuAST::ApplyInfix, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1375 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyInfix, '$!infix').IMPL-CAN-INTERPRET && nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').IMPL-CAN-INTERPRET
    
    });
    add-method(RakuAST::ApplyInfix, 'IMPL-INTERPRET', [RakuAST::ApplyInfix, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 1379 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyInfix, '$!infix').IMPL-INTERPRET($ctx, $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::ApplyInfix, '$!args').args) );
    
    });
#line 1286 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyInfix, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyInfix, '$!infix') });
#line 1287 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyInfix, 'args', [], anon sub args ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyInfix, '$!args') });
    compose(RakuAST::ApplyInfix);
    parent(RakuAST::ApplyListInfix, RakuAST::Expression);
    parent(RakuAST::ApplyListInfix, RakuAST::BeginTime);
    parent(RakuAST::ApplyListInfix, RakuAST::WhateverApplicable);
    add-attribute(RakuAST::ApplyListInfix, RakuAST::Infixish, '$!infix');
    add-attribute(RakuAST::ApplyListInfix, List, '$!operands');
    add-method(RakuAST::ApplyListInfix, 'new', [RakuAST::ApplyListInfix, '', 0, 0, RakuAST::Infixish, '$infix', 1, 0, List, '$operands', 1, 0], anon sub new ($SELF_CONT, :$infix!, :$operands!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
        $operands := nqp::decont($operands);
#line 1393 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ApplyListInfix, '$!infix', $infix);
        nqp::bindattr($obj, RakuAST::ApplyListInfix, '$!operands', my $list := []);
        for $SELF.IMPL-UNWRAP-LIST($operands) {
            if nqp::istype($_, RakuAST::ColonPairs) {
                for $_.colonpairs {
                    nqp::push($list, $_);
                }
            }
            else {
                nqp::push($list, $_);
            }
        }
        $obj
    
    });
    add-method(RakuAST::ApplyListInfix, 'operands', [RakuAST::ApplyListInfix, '', 0, 0], anon sub operands ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1410 src/Raku/ast/expressions.rakumod
         $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!operands'))
    });
    add-method(RakuAST::ApplyListInfix, 'operator', [RakuAST::ApplyListInfix, '', 0, 0], anon sub operator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1411 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!infix') 
    });
    add-method(RakuAST::ApplyListInfix, 'IMPL-EXPR-QAST', [RakuAST::ApplyListInfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1413 src/Raku/ast/expressions.rakumod
        
        my @operands;
        for nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!operands') {
            @operands.push($_.IMPL-TO-QAST($context));
        }
        nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!infix').IMPL-LIST-INFIX-QAST: $context, @operands;
    
    });
    add-method(RakuAST::ApplyListInfix, 'visit-children', [RakuAST::ApplyListInfix, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1421 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!infix'));
        for nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!operands') {
            $visitor($_);
        }
    
    });
    add-method(RakuAST::ApplyListInfix, 'IMPL-CUSTOM-SHOULD-CURRY-CONDITIONS', [RakuAST::ApplyListInfix, '', 0, 0], anon sub IMPL-CUSTOM-SHOULD-CURRY-CONDITIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1428 src/Raku/ast/expressions.rakumod
        
        # Anything but a ','
        !(nqp::istype(nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!infix'), RakuAST::Infix) && nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!infix').operator eq ',')
    
    });
    add-method(RakuAST::ApplyListInfix, 'PERFORM-BEGIN', [RakuAST::ApplyListInfix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1433 src/Raku/ast/expressions.rakumod
        
        my $curried;
        if $SELF.IMPL-SHOULD-CURRY-ACROSS-ALL-CHILDREN {
            $curried := $SELF.IMPL-CURRY;
            $SELF.IMPL-CURRY-ACROSS-ALL-CHILDREN($resolver, $context, $curried);
        }
        # There is a chance that we didn't actually meet the conditions to curry inside of IMPL-CURRY-ACROSS-ALL-CHILDREN.
        # If no actual params have been set, we can assume that this happened.
        $SELF.IMPL-UNCURRY if $curried && nqp::elems($curried.IMPL-PARAMS) == 0;

        nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!infix').IMPL-THUNK-ARGUMENTS($resolver, $context, |$SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!operands')));
    
    });
    add-method(RakuAST::ApplyListInfix, 'IMPL-CAN-INTERPRET', [RakuAST::ApplyListInfix, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1446 src/Raku/ast/expressions.rakumod
        
        if nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!infix').IMPL-CAN-INTERPRET {
            for $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!operands')) {
                return (Bool.WHO)<False> unless $_.IMPL-CAN-INTERPRET;
            }
            (Bool.WHO)<True>
        }
        else {
            (Bool.WHO)<False>
        }
    
    });
    add-method(RakuAST::ApplyListInfix, 'IMPL-INTERPRET', [RakuAST::ApplyListInfix, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 1458 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!infix').IMPL-INTERPRET($ctx, nqp::getattr($SELF, RakuAST::ApplyListInfix, '$!operands'))
    
    });
#line 1390 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyListInfix, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyListInfix, '$!infix') });
    compose(RakuAST::ApplyListInfix);
    parent(RakuAST::DottyInfixish, RakuAST::Node);
    parent(RakuAST::DottyInfixish, RakuAST::OperatorProperties);
    add-method(RakuAST::DottyInfixish, 'new', [RakuAST::DottyInfixish, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1471 src/Raku/ast/expressions.rakumod
         nqp::create($SELF) 
    });
    compose(RakuAST::DottyInfixish);
    parent(RakuAST::DottyInfix::Call, RakuAST::DottyInfixish);
    add-method(RakuAST::DottyInfix::Call, 'IMPL-DOTTY-INFIX-QAST', [RakuAST::DottyInfix::Call, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$lhs-qast', 0, 0, RakuAST::Postfixish, '$rhs-ast', 0, 0], anon sub IMPL-DOTTY-INFIX-QAST ($SELF_CONT, $context!, $lhs-qast!, $rhs-ast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $lhs-qast := nqp::decont($lhs-qast);
        $rhs-ast := nqp::decont($rhs-ast);
#line 1480 src/Raku/ast/expressions.rakumod
        
        $rhs-ast.IMPL-POSTFIX-QAST($context, $lhs-qast)
    
    });
    add-method(RakuAST::DottyInfix::Call, 'default-operator-properties', [RakuAST::DottyInfix::Call, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1484 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.infix('.')
    
    });
    compose(RakuAST::DottyInfix::Call);
    parent(RakuAST::DottyInfix::CallAssign, RakuAST::DottyInfixish);
    add-method(RakuAST::DottyInfix::CallAssign, 'default-operator-properties', [RakuAST::DottyInfix::CallAssign, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1494 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.infix('.=')
    
    });
    add-method(RakuAST::DottyInfix::CallAssign, 'IMPL-DOTTY-INFIX-QAST', [RakuAST::DottyInfix::CallAssign, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$lhs-qast', 0, 0, RakuAST::Postfixish, '$rhs-ast', 0, 0], anon sub IMPL-DOTTY-INFIX-QAST ($SELF_CONT, $context!, $lhs-qast!, $rhs-ast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $lhs-qast := nqp::decont($lhs-qast);
        $rhs-ast := nqp::decont($rhs-ast);
#line 1499 src/Raku/ast/expressions.rakumod
        
        # Store the target in a temporary, so we only evaluate it once.
        my $temp := QAST::Node.unique('meta_assign');
        my $bind-lhs := QAST::Op.new(
            :op('bind'),
            QAST::Var.new( :decl('var'), :scope('local'), :name($temp) ),
            $lhs-qast
        );

        # Emit the assignment.
        # TODO case analyze these
        QAST::Stmt.new(
            $bind-lhs,
            QAST::Op.new(
                :op('assign'),
                QAST::Var.new( :scope('local'), :name($temp) ),
                $rhs-ast.IMPL-POSTFIX-QAST(
                    $context,
                    QAST::Var.new( :scope('local'), :name($temp) ),
                )
            )
        )
    
    });
    compose(RakuAST::DottyInfix::CallAssign);
    parent(RakuAST::ApplyDottyInfix, RakuAST::Expression);
    add-attribute(RakuAST::ApplyDottyInfix, RakuAST::DottyInfixish, '$!infix');
    add-attribute(RakuAST::ApplyDottyInfix, RakuAST::Expression, '$!left');
    add-attribute(RakuAST::ApplyDottyInfix, RakuAST::Postfixish, '$!right');
    add-method(RakuAST::ApplyDottyInfix, 'new', [RakuAST::ApplyDottyInfix, '', 0, 0, RakuAST::DottyInfixish, '$infix', 1, 0, RakuAST::Expression, '$left', 1, 0, RakuAST::Postfixish, '$right', 1, 0], anon sub new ($SELF_CONT, :$infix!, :$left!, :$right!) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
        $left := nqp::decont($left);
        $right := nqp::decont($right);
#line 1535 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ApplyDottyInfix, '$!infix', $infix);
        nqp::bindattr($obj, RakuAST::ApplyDottyInfix, '$!left', $left);
        nqp::bindattr($obj, RakuAST::ApplyDottyInfix, '$!right', $right);
        $obj
    
    });
    add-method(RakuAST::ApplyDottyInfix, 'properties', [RakuAST::ApplyDottyInfix, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1543 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyDottyInfix, '$!infix').properties 
    });
    add-method(RakuAST::ApplyDottyInfix, 'IMPL-EXPR-QAST', [RakuAST::ApplyDottyInfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1545 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyDottyInfix, '$!infix').IMPL-DOTTY-INFIX-QAST: $context,
            nqp::getattr($SELF, RakuAST::ApplyDottyInfix, '$!left').IMPL-TO-QAST($context),
            nqp::getattr($SELF, RakuAST::ApplyDottyInfix, '$!right')
    
    });
    add-method(RakuAST::ApplyDottyInfix, 'visit-children', [RakuAST::ApplyDottyInfix, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1551 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ApplyDottyInfix, '$!left'));
        $visitor(nqp::getattr($SELF, RakuAST::ApplyDottyInfix, '$!infix'));
        $visitor(nqp::getattr($SELF, RakuAST::ApplyDottyInfix, '$!right'));
    
    });
#line 1532 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyDottyInfix, 'right', [], anon sub right ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyDottyInfix, '$!right') });
#line 1531 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyDottyInfix, 'left', [], anon sub left ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyDottyInfix, '$!left') });
#line 1530 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyDottyInfix, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyDottyInfix, '$!infix') });
    compose(RakuAST::ApplyDottyInfix);
    parent(RakuAST::Prefixish, RakuAST::Node);
    add-attribute(RakuAST::Prefixish, List, '$!colonpairs');
    add-method(RakuAST::Prefixish, 'add-colonpair', [RakuAST::Prefixish, '', 0, 0, RakuAST::ColonPair, '$pair', 0, 0], anon sub add-colonpair ($SELF_CONT, $pair!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pair := nqp::decont($pair);
#line 1567 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::Prefixish, '$!colonpairs').push: $pair;
    
    });
    add-method(RakuAST::Prefixish, 'visit-colonpairs', [RakuAST::Prefixish, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-colonpairs ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1571 src/Raku/ast/expressions.rakumod
        
        for nqp::getattr($SELF, RakuAST::Prefixish, '$!colonpairs') {
            $visitor($_);
        }
    
    });
    add-method(RakuAST::Prefixish, 'IMPL-ADD-COLONPAIRS-TO-OP', [RakuAST::Prefixish, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$op', 0, 0], anon sub IMPL-ADD-COLONPAIRS-TO-OP ($SELF_CONT, $context!, $op!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $op := nqp::decont($op);
#line 1577 src/Raku/ast/expressions.rakumod
        
        for nqp::getattr($SELF, RakuAST::Prefixish, '$!colonpairs') {
            my $val-ast := $_.named-arg-value.IMPL-TO-QAST($context);
            $val-ast.named($_.named-arg-name);
            $op.push($val-ast);
        }
    
    });
    add-method(RakuAST::Prefixish, 'IMPL-CURRIES', [RakuAST::Prefixish, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1585 src/Raku/ast/expressions.rakumod
         3 
    });
#line 1565 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Prefixish, 'colonpairs', [], anon sub colonpairs ($self) { nqp::getattr(nqp::decont($self), RakuAST::Prefixish, '$!colonpairs') });
    compose(RakuAST::Prefixish);
    parent(RakuAST::Prefix, RakuAST::Prefixish);
    parent(RakuAST::Prefix, RakuAST::OperatorProperties);
    parent(RakuAST::Prefix, RakuAST::Lookup);
    add-attribute(RakuAST::Prefix, str, '$!operator');
    add-method(RakuAST::Prefix, 'new', [RakuAST::Prefix, '', 0, 0, str, '$operator', 0, 0], anon sub new ($SELF_CONT, $operator!) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
#line 1596 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Prefix, '$!operator', $operator);
        nqp::bindattr($obj, RakuAST::Prefixish, '$!colonpairs', []);
        $obj
    
    });
    add-method(RakuAST::Prefix, 'default-operator-properties', [RakuAST::Prefix, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1603 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.prefix(nqp::getattr_s($SELF, RakuAST::Prefix, '$!operator'))
    
    });
    add-method(RakuAST::Prefix, 'resolve-with', [RakuAST::Prefix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1607 src/Raku/ast/expressions.rakumod
        
        my $resolved := $resolver.resolve-prefix(nqp::getattr_s($SELF, RakuAST::Prefix, '$!operator'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Prefix, 'IMPL-PREFIX-QAST', [RakuAST::Prefix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-PREFIX-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 1615 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $op := QAST::Op.new( :op('call'), :$name, $operand-qast );
        $SELF.IMPL-ADD-COLONPAIRS-TO-OP($context, $op);
        $op
    
    });
    add-method(RakuAST::Prefix, 'IMPL-HOP-PREFIX-QAST', [RakuAST::Prefix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-HOP-PREFIX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1622 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        QAST::Var.new( :scope('lexical'), :$name )
    
    });
#line 1594 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Prefix, 'operator', [], anon sub operator ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Prefix, '$!operator') });
    compose(RakuAST::Prefix);
    parent(RakuAST::MetaPrefix::Hyper, RakuAST::Prefixish);
    add-attribute(RakuAST::MetaPrefix::Hyper, RakuAST::Prefix, '$!prefix');
    add-method(RakuAST::MetaPrefix::Hyper, 'new', [RakuAST::MetaPrefix::Hyper, '', 0, 0, RakuAST::Prefix, '$prefix', 0, 0], anon sub new ($SELF_CONT, $prefix!) {
        my $SELF := nqp::decont($SELF_CONT);
        $prefix := nqp::decont($prefix);
#line 1634 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::MetaPrefix::Hyper, '$!prefix', $prefix);
        nqp::bindattr($obj, RakuAST::Prefixish, '$!colonpairs', []);
        $obj
    
    });
    add-method(RakuAST::MetaPrefix::Hyper, 'IMPL-PREFIX-QAST', [RakuAST::MetaPrefix::Hyper, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-PREFIX-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 1641 src/Raku/ast/expressions.rakumod
        
        my $op := QAST::Op.new:
            :op('call'),
            QAST::Op.new(
                :op('callstatic'), :name('&METAOP_HYPER_PREFIX'),
                nqp::getattr($SELF, RakuAST::MetaPrefix::Hyper, '$!prefix').IMPL-HOP-PREFIX-QAST($context)
            ),
            $operand-qast;
        $SELF.IMPL-ADD-COLONPAIRS-TO-OP($context, $op);
        $op
    
    });
    add-method(RakuAST::MetaPrefix::Hyper, 'visit-children', [RakuAST::MetaPrefix::Hyper, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1653 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::MetaPrefix::Hyper, '$!prefix'));
    
    });
    add-method(RakuAST::MetaPrefix::Hyper, 'properties', [RakuAST::MetaPrefix::Hyper, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1657 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::MetaPrefix::Hyper, '$!prefix').properties 
    });
#line 1632 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaPrefix::Hyper, 'prefix', [], anon sub prefix ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaPrefix::Hyper, '$!prefix') });
    compose(RakuAST::MetaPrefix::Hyper);
    parent(RakuAST::Termish, RakuAST::Expression);
    parent(RakuAST::Termish, RakuAST::CaptureSource);
    compose(RakuAST::Termish);
    parent(RakuAST::Term, RakuAST::Termish);
    compose(RakuAST::Term);
    parent(RakuAST::ApplyPrefix, RakuAST::Termish);
    parent(RakuAST::ApplyPrefix, RakuAST::BeginTime);
    parent(RakuAST::ApplyPrefix, RakuAST::WhateverApplicable);
    add-attribute(RakuAST::ApplyPrefix, RakuAST::Prefixish, '$!prefix');
    add-attribute(RakuAST::ApplyPrefix, RakuAST::Expression, '$!operand');
    add-method(RakuAST::ApplyPrefix, 'new', [RakuAST::ApplyPrefix, '', 0, 0, Any, '$prefix', 1, 0, Any, '$operand', 1, 0], anon sub new ($SELF_CONT, :$prefix!, :$operand!) {
        my $SELF := nqp::decont($SELF_CONT);
        $prefix := nqp::decont($prefix);
        $operand := nqp::decont($operand);
#line 1680 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ApplyPrefix, '$!prefix', $prefix);
        nqp::bindattr($obj, RakuAST::ApplyPrefix, '$!operand', $operand);
        $obj
    
    });
    add-method(RakuAST::ApplyPrefix, 'add-colonpair', [RakuAST::ApplyPrefix, '', 0, 0, RakuAST::ColonPair, '$pair', 0, 0], anon sub add-colonpair ($SELF_CONT, $pair!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pair := nqp::decont($pair);
#line 1687 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!prefix').add-colonpair($pair);
    
    });
    add-method(RakuAST::ApplyPrefix, 'operands', [RakuAST::ApplyPrefix, '', 0, 0], anon sub operands ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1691 src/Raku/ast/expressions.rakumod
         [nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!operand')] 
    });
    add-method(RakuAST::ApplyPrefix, 'operator', [RakuAST::ApplyPrefix, '', 0, 0], anon sub operator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1692 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!prefix') 
    });
    add-method(RakuAST::ApplyPrefix, 'is-begin-performed-before-children', [RakuAST::ApplyPrefix, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1694 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ApplyPrefix, 'is-begin-performed-after-children', [RakuAST::ApplyPrefix, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1695 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ApplyPrefix, 'PERFORM-BEGIN-BEFORE-CHILDREN', [RakuAST::ApplyPrefix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-BEFORE-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1697 src/Raku/ast/expressions.rakumod
        
        if $SELF.IMPL-SHOULD-CURRY-DIRECTLY {
            nqp::bindattr($SELF, RakuAST::ApplyPrefix, '$!operand',
                $SELF.IMPL-CURRY.IMPL-ADD-PARAM($resolver, $context).target.generate-lookup);
        }
    
    });
    add-method(RakuAST::ApplyPrefix, 'PERFORM-BEGIN-AFTER-CHILDREN', [RakuAST::ApplyPrefix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-AFTER-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1704 src/Raku/ast/expressions.rakumod
        
        my $operand := nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!operand');
        if nqp::bitand_i(nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!prefix').IMPL-CURRIES, 2) {
            if $operand.IMPL-CURRIED {
                my @params := $operand.IMPL-UNCURRY;
                my $curried := $SELF.IMPL-CURRY;
                for @params {
                    $curried.IMPL-ADD-PARAM($resolver, $context, :name($_.target.lexical-name));
                }
            }
            elsif nqp::istype($operand, RakuAST::Circumfix::Parentheses)
                && (my $expression := $operand.IMPL-SINGULAR-CURRIED-EXPRESSION)
            {
                my @params := $expression.IMPL-UNCURRY;
                my $curried := $SELF.IMPL-CURRY;
                for @params {
                    $curried.IMPL-ADD-PARAM($resolver, $context, :name($_.target.lexical-name));
                }
            }
        }
    
    });
    add-method(RakuAST::ApplyPrefix, 'IMPL-EXPR-QAST', [RakuAST::ApplyPrefix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1726 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!prefix').IMPL-PREFIX-QAST($context, nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!operand').IMPL-TO-QAST($context))
    
    });
    add-method(RakuAST::ApplyPrefix, 'visit-children', [RakuAST::ApplyPrefix, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1730 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!prefix'));
        $visitor(nqp::getattr($SELF, RakuAST::ApplyPrefix, '$!operand'));
    
    });
#line 1677 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyPrefix, 'prefix', [], anon sub prefix ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyPrefix, '$!prefix') });
#line 1678 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyPrefix, 'operand', [], anon sub operand ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyPrefix, '$!operand') });
    compose(RakuAST::ApplyPrefix);
    parent(RakuAST::Postfixish, RakuAST::Node);
    parent(RakuAST::Postfixish, RakuAST::OperatorProperties);
    add-attribute(RakuAST::Postfixish, List, '$!colonpairs');
    add-method(RakuAST::Postfixish, 'set-colonpairs', [RakuAST::Postfixish, '', 0, 0, List, '$pairs', 0, 0], anon sub set-colonpairs ($SELF_CONT, $pairs!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pairs := nqp::decont($pairs);
#line 1746 src/Raku/ast/expressions.rakumod
        
        my @pairs;
        if $pairs {
            for $SELF.IMPL-UNWRAP-LIST($pairs) {
                nqp::push(@pairs,$_);
            }
        }
        nqp::bindattr($SELF,RakuAST::Postfixish,'$!colonpairs',@pairs);
    
    });
    add-method(RakuAST::Postfixish, 'add-colonpair', [RakuAST::Postfixish, '', 0, 0, RakuAST::ColonPair, '$pair', 0, 0], anon sub add-colonpair ($SELF_CONT, $pair!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pair := nqp::decont($pair);
#line 1756 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::Postfixish, '$!colonpairs').push: $pair;
    
    });
    add-method(RakuAST::Postfixish, 'visit-colonpairs', [RakuAST::Postfixish, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-colonpairs ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1760 src/Raku/ast/expressions.rakumod
        
        for nqp::getattr($SELF, RakuAST::Postfixish, '$!colonpairs') {
            $visitor($_);
        }
    
    });
    add-method(RakuAST::Postfixish, 'IMPL-ADD-COLONPAIRS-TO-OP', [RakuAST::Postfixish, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$op', 0, 0], anon sub IMPL-ADD-COLONPAIRS-TO-OP ($SELF_CONT, $context!, $op!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $op := nqp::decont($op);
#line 1766 src/Raku/ast/expressions.rakumod
        
        for nqp::getattr($SELF, RakuAST::Postfixish, '$!colonpairs') {
            my $val-ast := $_.named-arg-value.IMPL-TO-QAST($context);
            $val-ast.named($_.named-arg-name);
            $op.push($val-ast);
        }
    
    });
    add-method(RakuAST::Postfixish, 'IMPL-CURRIES', [RakuAST::Postfixish, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1778 src/Raku/ast/expressions.rakumod
         0 
    });
    add-method(RakuAST::Postfixish, 'can-be-used-with-hyper', [RakuAST::Postfixish, '', 0, 0], anon sub can-be-used-with-hyper ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1780 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<False> 
    });
#line 1744 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Postfixish, 'colonpairs', [], anon sub colonpairs ($self) { nqp::getattr(nqp::decont($self), RakuAST::Postfixish, '$!colonpairs') });
    compose(RakuAST::Postfixish);
    parent(RakuAST::Postfix, RakuAST::Postfixish);
    parent(RakuAST::Postfix, RakuAST::Lookup);
    add-attribute(RakuAST::Postfix, str, '$!operator');
    add-method(RakuAST::Postfix, 'new', [RakuAST::Postfix, '', 0, 0, str, '$operator', 1, 0, List, '$colonpairs', 1, 1], anon sub new ($SELF_CONT, :$operator!, :$colonpairs?) {
        my $SELF := nqp::decont($SELF_CONT);
        $operator := nqp::decont($operator);
        $colonpairs := nqp::decont($colonpairs);
#line 1790 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Postfix, '$!operator', $operator);
        $obj.set-colonpairs($colonpairs);
        $obj
    
    });
    add-method(RakuAST::Postfix, 'default-operator-properties', [RakuAST::Postfix, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1797 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.postfix(nqp::getattr_s($SELF, RakuAST::Postfix, '$!operator'))
    
    });
    add-method(RakuAST::Postfix, 'resolve-with', [RakuAST::Postfix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1801 src/Raku/ast/expressions.rakumod
        
        my $resolved := $resolver.resolve-postfix(nqp::getattr_s($SELF, RakuAST::Postfix, '$!operator'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Postfix, 'IMPL-POSTFIX-QAST', [RakuAST::Postfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 1812 src/Raku/ast/expressions.rakumod
        
        my $op := QAST::Op.new(
          :op('call'), :name($SELF.resolution.lexical-name), $operand-qast
        );
        $SELF.IMPL-ADD-COLONPAIRS-TO-OP($context, $op);
        $op
    
    });
    add-method(RakuAST::Postfix, 'can-be-used-with-hyper', [RakuAST::Postfix, '', 0, 0], anon sub can-be-used-with-hyper ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1820 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Postfix, 'IMPL-POSTFIX-HYPER-QAST', [RakuAST::Postfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-HYPER-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 1822 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new:
            :op('callstatic'), :name('&METAOP_HYPER_POSTFIX_ARGS'),
            $operand-qast,
            $SELF.resolution.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::Postfix, 'IMPL-CURRIES', [RakuAST::Postfix, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1829 src/Raku/ast/expressions.rakumod
         3 
    });
#line 1788 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Postfix, 'operator', [], anon sub operator ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Postfix, '$!operator') });
    compose(RakuAST::Postfix);
    parent(RakuAST::Postfix::Literal, RakuAST::Postfixish);
    parent(RakuAST::Postfix::Literal, RakuAST::Lookup);
    add-attribute(RakuAST::Postfix::Literal, Mu, '$!value');
    add-method(RakuAST::Postfix::Literal, 'new', [RakuAST::Postfix::Literal, '', 0, 0, Mu, '$value', 0, 0], anon sub new ($SELF_CONT, $value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $value := nqp::decont($value);
#line 1839 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Postfix::Literal, '$!value', $value);
        # NOTE: these can never have colonpairs
        nqp::bindattr($obj, RakuAST::Postfixish, '$!colonpairs', []);
        $obj
    
    });
    add-method(RakuAST::Postfix::Literal, 'IMPL-POSTFIX-QAST', [RakuAST::Postfix::Literal, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 1847 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        $context.ensure-sc(nqp::getattr($SELF, RakuAST::Postfix::Literal, '$!value'));
        QAST::Op.new:
            :op('call'), :$name,
            $operand-qast,
            QAST::WVal.new( :value(nqp::getattr($SELF, RakuAST::Postfix::Literal, '$!value')) )
    
    });
    add-method(RakuAST::Postfix::Literal, 'can-be-used-with-hyper', [RakuAST::Postfix::Literal, '', 0, 0], anon sub can-be-used-with-hyper ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1856 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Postfix::Literal, 'IMPL-CURRIES', [RakuAST::Postfix::Literal, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1858 src/Raku/ast/expressions.rakumod
         3 
    });
    compose(RakuAST::Postfix::Literal);
    parent(RakuAST::Postfix::Power, RakuAST::Postfix::Literal);
    add-method(RakuAST::Postfix::Power, 'properties', [RakuAST::Postfix::Power, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1866 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.postfix('ⁿ')
    
    });
    add-method(RakuAST::Postfix::Power, 'resolve-with', [RakuAST::Postfix::Power, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1870 src/Raku/ast/expressions.rakumod
        
        my $resolved := $resolver.resolve-postfix('ⁿ');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Postfix::Power, 'power', [RakuAST::Postfix::Power, '', 0, 0], anon sub power ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1878 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF,RakuAST::Postfix::Literal,'$!value') 
    });
    compose(RakuAST::Postfix::Power);
    parent(RakuAST::Postfix::Vulgar, RakuAST::Postfix::Literal);
    add-method(RakuAST::Postfix::Vulgar, 'properties', [RakuAST::Postfix::Vulgar, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1886 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.postfix('+')
    
    });
    add-method(RakuAST::Postfix::Vulgar, 'resolve-with', [RakuAST::Postfix::Vulgar, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1890 src/Raku/ast/expressions.rakumod
        
        # Note that we're trying to resolve it here as an infix +, because
        # that's what this actually does (and there is no &postfix:<+> sub)
        my $resolved := $resolver.resolve-infix('+');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Postfix::Vulgar, 'vulgar', [RakuAST::Postfix::Vulgar, '', 0, 0], anon sub vulgar ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1900 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF,RakuAST::Postfix::Literal,'$!value') 
    });
    compose(RakuAST::Postfix::Vulgar);
    parent(RakuAST::Postcircumfix, RakuAST::Postfixish);
    compose(RakuAST::Postcircumfix);
    parent(RakuAST::Postcircumfix::ArrayIndex, RakuAST::Postcircumfix);
    parent(RakuAST::Postcircumfix::ArrayIndex, RakuAST::Lookup);
    add-attribute(RakuAST::Postcircumfix::ArrayIndex, RakuAST::SemiList, '$!index');
    add-attribute(RakuAST::Postcircumfix::ArrayIndex, RakuAST::Expression, '$!assignee');
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'new', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0, RakuAST::SemiList, '$index', 1, 0, RakuAST::Expression, '$assignee', 1, 1, List, '$colonpairs', 1, 1], anon sub new ($SELF_CONT, :$index!, :$assignee?, :$colonpairs?) {
        my $SELF := nqp::decont($SELF_CONT);
        $index := nqp::decont($index);
        $assignee := nqp::decont($assignee);
        $colonpairs := nqp::decont($colonpairs);
#line 1923 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Postcircumfix::ArrayIndex, '$!index', $index);
        nqp::bindattr($obj, RakuAST::Postcircumfix::ArrayIndex, '$!assignee', $assignee // RakuAST::Expression);
        $obj.set-colonpairs($colonpairs);
        $obj
    
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'set-assignee', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0, RakuAST::Expression, '$assignee', 0, 0], anon sub set-assignee ($SELF_CONT, $assignee!) {
        my $SELF := nqp::decont($SELF_CONT);
        $assignee := nqp::decont($assignee);
#line 1931 src/Raku/ast/expressions.rakumod
        
        nqp::bindattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!assignee', $assignee);
    
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'can-be-bound-to', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1935 src/Raku/ast/expressions.rakumod
        
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'resolve-with', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1939 src/Raku/ast/expressions.rakumod
        
        my $resolved := $resolver.resolve-lexical(
            nqp::elems(nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!index').code-statements) > 1
                ?? '&postcircumfix:<[; ]>'
                !! '&postcircumfix:<[ ]>');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'default-operator-properties', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1950 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.postcircumfix('[ ]')
    
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'visit-children', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1954 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!index'));
        $visitor(nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!assignee')) if nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!assignee');
        $SELF.visit-colonpairs($visitor);
    
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'IMPL-CURRIES', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1960 src/Raku/ast/expressions.rakumod
         3 
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'IMPL-POSTFIX-QAST', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 1962 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $op := QAST::Op.new( :op('call'), :$name, $operand-qast );
        $op.push(nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!index').IMPL-TO-QAST($context)) unless nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!index').is-empty;
        $op.push(nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!assignee').IMPL-TO-QAST($context)) if nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!assignee');
        $SELF.IMPL-ADD-COLONPAIRS-TO-OP($context, $op);
        $op
    
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'IMPL-BIND-POSTFIX-QAST', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$operand', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-POSTFIX-QAST ($SELF_CONT, $context!, $operand!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand := nqp::decont($operand);
        $source-qast := nqp::decont($source-qast);
#line 1972 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $op := QAST::Op.new( :op('call'), :$name, $operand.IMPL-TO-QAST($context) );
        $op.push(nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!index').IMPL-TO-QAST($context)) unless nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!index').is-empty;
        my $bind := $source-qast;
        $bind.named('BIND');
        $op.push($bind);
        $op
    
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'can-be-used-with-hyper', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0], anon sub can-be-used-with-hyper ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1982 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'IMPL-POSTFIX-HYPER-QAST', [RakuAST::Postcircumfix::ArrayIndex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-HYPER-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 1984 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new:
            :op('callstatic'), :name('&METAOP_HYPER_POSTFIX_ARGS'),
            $operand-qast,
            nqp::getattr($SELF, RakuAST::Postcircumfix::ArrayIndex, '$!index').IMPL-TO-QAST($context),
            $SELF.resolution.IMPL-LOOKUP-QAST($context)
    
    });
#line 1916 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'index', [], anon sub index ($self) { nqp::getattr(nqp::decont($self), RakuAST::Postcircumfix::ArrayIndex, '$!index') });
#line 1917 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Postcircumfix::ArrayIndex, 'assignee', [], anon sub assignee ($self) { nqp::getattr(nqp::decont($self), RakuAST::Postcircumfix::ArrayIndex, '$!assignee') });
    compose(RakuAST::Postcircumfix::ArrayIndex);
    parent(RakuAST::Postcircumfix::HashIndex, RakuAST::Postcircumfix);
    parent(RakuAST::Postcircumfix::HashIndex, RakuAST::Lookup);
    add-attribute(RakuAST::Postcircumfix::HashIndex, RakuAST::SemiList, '$!index');
    add-method(RakuAST::Postcircumfix::HashIndex, 'new', [RakuAST::Postcircumfix::HashIndex, '', 0, 0, RakuAST::SemiList, '$index', 1, 0, List, '$colonpairs', 1, 1], anon sub new ($SELF_CONT, :$index!, :$colonpairs?) {
        my $SELF := nqp::decont($SELF_CONT);
        $index := nqp::decont($index);
        $colonpairs := nqp::decont($colonpairs);
#line 2000 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj,RakuAST::Postcircumfix::HashIndex,'$!index',$index);
        $obj.set-colonpairs($colonpairs);
        $obj
    
    });
    add-method(RakuAST::Postcircumfix::HashIndex, 'can-be-bound-to', [RakuAST::Postcircumfix::HashIndex, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2007 src/Raku/ast/expressions.rakumod
        
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Postcircumfix::HashIndex, 'resolve-with', [RakuAST::Postcircumfix::HashIndex, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 2011 src/Raku/ast/expressions.rakumod
        
        my $resolved := $resolver.resolve-lexical(
            nqp::elems(nqp::getattr($SELF, RakuAST::Postcircumfix::HashIndex, '$!index').code-statements) > 1
                ?? '&postcircumfix:<{; }>'
                !! '&postcircumfix:<{ }>');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Postcircumfix::HashIndex, 'visit-children', [RakuAST::Postcircumfix::HashIndex, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2022 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Postcircumfix::HashIndex, '$!index'));
        $SELF.visit-colonpairs($visitor);
    
    });
    add-method(RakuAST::Postcircumfix::HashIndex, 'default-operator-properties', [RakuAST::Postcircumfix::HashIndex, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2027 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.postcircumfix('{ }')
    
    });
    add-method(RakuAST::Postcircumfix::HashIndex, 'IMPL-CURRIES', [RakuAST::Postcircumfix::HashIndex, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2031 src/Raku/ast/expressions.rakumod
         3 
    });
    add-method(RakuAST::Postcircumfix::HashIndex, 'IMPL-POSTFIX-QAST', [RakuAST::Postcircumfix::HashIndex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 2033 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $op := QAST::Op.new( :op('call'), :$name, $operand-qast );
        $op.push(nqp::getattr($SELF, RakuAST::Postcircumfix::HashIndex, '$!index').IMPL-TO-QAST($context)) unless nqp::getattr($SELF, RakuAST::Postcircumfix::HashIndex, '$!index').is-empty;
        $SELF.IMPL-ADD-COLONPAIRS-TO-OP($context, $op);
        $op
    
    });
    add-method(RakuAST::Postcircumfix::HashIndex, 'IMPL-BIND-POSTFIX-QAST', [RakuAST::Postcircumfix::HashIndex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$operand', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-POSTFIX-QAST ($SELF_CONT, $context!, $operand!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand := nqp::decont($operand);
        $source-qast := nqp::decont($source-qast);
#line 2042 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $op := QAST::Op.new( :op('call'), :$name, $operand.IMPL-TO-QAST($context) );
        $op.push(nqp::getattr($SELF, RakuAST::Postcircumfix::HashIndex, '$!index').IMPL-TO-QAST($context)) unless nqp::getattr($SELF, RakuAST::Postcircumfix::HashIndex, '$!index').is-empty;
        $SELF.IMPL-ADD-COLONPAIRS-TO-OP($context, $op);
        my $bind := $source-qast;
        $bind.named('BIND');
        $op.push($bind);
        $op
    
    });
#line 1998 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Postcircumfix::HashIndex, 'index', [], anon sub index ($self) { nqp::getattr(nqp::decont($self), RakuAST::Postcircumfix::HashIndex, '$!index') });
    compose(RakuAST::Postcircumfix::HashIndex);
    parent(RakuAST::Postcircumfix::LiteralHashIndex, RakuAST::Postcircumfix);
    parent(RakuAST::Postcircumfix::LiteralHashIndex, RakuAST::Lookup);
    add-attribute(RakuAST::Postcircumfix::LiteralHashIndex, RakuAST::QuotedString, '$!index');
    add-attribute(RakuAST::Postcircumfix::LiteralHashIndex, RakuAST::Expression, '$!assignee');
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'new', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0, RakuAST::QuotedString, '$index', 1, 0, RakuAST::Expression, '$assignee', 1, 1, List, '$colonpairs', 1, 1], anon sub new ($SELF_CONT, :$index!, :$assignee?, :$colonpairs?) {
        my $SELF := nqp::decont($SELF_CONT);
        $index := nqp::decont($index);
        $assignee := nqp::decont($assignee);
        $colonpairs := nqp::decont($colonpairs);
#line 2066 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Postcircumfix::LiteralHashIndex, '$!index', $index);
        nqp::bindattr($obj, RakuAST::Postcircumfix::LiteralHashIndex, '$!assignee', $assignee // RakuAST::Expression);
        $obj.set-colonpairs($colonpairs);
        $obj
    
    });
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'set-assignee', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0, RakuAST::Expression, '$assignee', 0, 0], anon sub set-assignee ($SELF_CONT, $assignee!) {
        my $SELF := nqp::decont($SELF_CONT);
        $assignee := nqp::decont($assignee);
#line 2074 src/Raku/ast/expressions.rakumod
        
        nqp::bindattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!assignee', $assignee);
    
    });
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'can-be-bound-to', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2078 src/Raku/ast/expressions.rakumod
        
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'resolve-with', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 2082 src/Raku/ast/expressions.rakumod
        
        my $resolved := $resolver.resolve-lexical('&postcircumfix:<{ }>');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'visit-children', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2090 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!index'));
        $visitor(nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!assignee')) if nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!assignee');
        $SELF.visit-colonpairs($visitor);
    
    });
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'default-operator-properties', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2096 src/Raku/ast/expressions.rakumod
        
        OperatorProperties.postcircumfix('< >')
    
    });
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'IMPL-CURRIES', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2100 src/Raku/ast/expressions.rakumod
         3 
    });
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'IMPL-POSTFIX-QAST', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 2102 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $op := QAST::Op.new( :op('call'), :$name, $operand-qast );
        $op.push(nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!index').IMPL-TO-QAST($context)) unless nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!index').is-empty-words;
        $op.push(nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!assignee').IMPL-TO-QAST($context)) if nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!assignee');
        $SELF.IMPL-ADD-COLONPAIRS-TO-OP($context, $op);
        $op
    
    });
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'IMPL-BIND-POSTFIX-QAST', [RakuAST::Postcircumfix::LiteralHashIndex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Expression, '$operand', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-POSTFIX-QAST ($SELF_CONT, $context!, $operand!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand := nqp::decont($operand);
        $source-qast := nqp::decont($source-qast);
#line 2112 src/Raku/ast/expressions.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $op := QAST::Op.new( :op('call'), :$name, $operand.IMPL-TO-QAST($context) );
        $op.push(nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!index').IMPL-TO-QAST($context)) unless nqp::getattr($SELF, RakuAST::Postcircumfix::LiteralHashIndex, '$!index').is-empty-words;
        $SELF.IMPL-ADD-COLONPAIRS-TO-OP($context, $op);
        my $bind := $source-qast;
        $bind.named('BIND');
        $op.push($bind);
        $op
    
    });
#line 2059 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'index', [], anon sub index ($self) { nqp::getattr(nqp::decont($self), RakuAST::Postcircumfix::LiteralHashIndex, '$!index') });
#line 2060 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Postcircumfix::LiteralHashIndex, 'assignee', [], anon sub assignee ($self) { nqp::getattr(nqp::decont($self), RakuAST::Postcircumfix::LiteralHashIndex, '$!assignee') });
    compose(RakuAST::Postcircumfix::LiteralHashIndex);
    parent(RakuAST::MetaPostfix::Hyper, RakuAST::Postfixish);
    parent(RakuAST::MetaPostfix::Hyper, RakuAST::CheckTime);
    add-attribute(RakuAST::MetaPostfix::Hyper, RakuAST::Postfixish, '$!postfix');
    add-method(RakuAST::MetaPostfix::Hyper, 'new', [RakuAST::MetaPostfix::Hyper, '', 0, 0, RakuAST::Postfixish, '$postfix', 0, 0], anon sub new ($SELF_CONT, $postfix!) {
        my $SELF := nqp::decont($SELF_CONT);
        $postfix := nqp::decont($postfix);
#line 2131 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::MetaPostfix::Hyper, '$!postfix', $postfix);
        # NOTE: can not have colonpairs specified
        nqp::bindattr($obj, RakuAST::Postfixish, '$!colonpairs', []);
        $obj
    
    });
    add-method(RakuAST::MetaPostfix::Hyper, 'PERFORM-CHECK', [RakuAST::MetaPostfix::Hyper, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 2139 src/Raku/ast/expressions.rakumod
        
        unless nqp::getattr($SELF, RakuAST::MetaPostfix::Hyper, '$!postfix').can-be-used-with-hyper {
            $SELF.add-sorry:
              $resolver.build-exception: 'X::AdHoc',
                payload => 'Cannot hyper this postfix';
        }
    
    });
    add-method(RakuAST::MetaPostfix::Hyper, 'IMPL-POSTFIX-QAST', [RakuAST::MetaPostfix::Hyper, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 2147 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::MetaPostfix::Hyper, '$!postfix').IMPL-POSTFIX-HYPER-QAST($context, $operand-qast)
    
    });
    add-method(RakuAST::MetaPostfix::Hyper, 'visit-children', [RakuAST::MetaPostfix::Hyper, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2151 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::MetaPostfix::Hyper, '$!postfix'));
        $SELF.visit-colonpairs($visitor);
    
    });
    add-method(RakuAST::MetaPostfix::Hyper, 'default-operator-properties', [RakuAST::MetaPostfix::Hyper, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2156 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::MetaPostfix::Hyper, '$!postfix').properties
    
    });
#line 2129 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::MetaPostfix::Hyper, 'postfix', [], anon sub postfix ($self) { nqp::getattr(nqp::decont($self), RakuAST::MetaPostfix::Hyper, '$!postfix') });
    compose(RakuAST::MetaPostfix::Hyper);
    parent(RakuAST::ApplyPostfix, RakuAST::Termish);
    parent(RakuAST::ApplyPostfix, RakuAST::BeginTime);
    parent(RakuAST::ApplyPostfix, RakuAST::WhateverApplicable);
    add-attribute(RakuAST::ApplyPostfix, RakuAST::Postfixish, '$!postfix');
    add-attribute(RakuAST::ApplyPostfix, RakuAST::Expression, '$!operand');
    add-method(RakuAST::ApplyPostfix, 'new', [RakuAST::ApplyPostfix, '', 0, 0, RakuAST::Postfixish, '$postfix', 1, 0, RakuAST::Expression, '$operand', 1, 0], anon sub new ($SELF_CONT, :$postfix!, :$operand!) {
        my $SELF := nqp::decont($SELF_CONT);
        $postfix := nqp::decont($postfix);
        $operand := nqp::decont($operand);
#line 2170 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ApplyPostfix, '$!postfix', $postfix);

        if nqp::istype($operand, RakuAST::Circumfix::Parentheses)
            && $operand.semilist.IMPL-IS-SINGLE-EXPRESSION
        {
            my $statement :=
              $SELF.IMPL-UNWRAP-LIST($operand.semilist.code-statements)[0];
            $operand := $statement.expression
                unless $statement.condition-modifier || $statement.loop-modifier;
        }
        nqp::bindattr($obj, RakuAST::ApplyPostfix, '$!operand', $operand);
        $obj
    
    });
    add-method(RakuAST::ApplyPostfix, 'add-colonpair', [RakuAST::ApplyPostfix, '', 0, 0, RakuAST::ColonPair, '$pair', 0, 0], anon sub add-colonpair ($SELF_CONT, $pair!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pair := nqp::decont($pair);
#line 2186 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix').add-colonpair($pair);
    
    });
    add-method(RakuAST::ApplyPostfix, 'operands', [RakuAST::ApplyPostfix, '', 0, 0], anon sub operands ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2190 src/Raku/ast/expressions.rakumod
         [nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand')] 
    });
    add-method(RakuAST::ApplyPostfix, 'operator', [RakuAST::ApplyPostfix, '', 0, 0], anon sub operator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2191 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix') 
    });
    add-method(RakuAST::ApplyPostfix, 'can-be-bound-to', [RakuAST::ApplyPostfix, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2193 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix').can-be-bound-to
    
    });
    add-method(RakuAST::ApplyPostfix, 'on-topic', [RakuAST::ApplyPostfix, '', 0, 0], anon sub on-topic ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2197 src/Raku/ast/expressions.rakumod
        
        nqp::istype(nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand'),RakuAST::Var::Lexical) && nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand').name eq '$_'
    
    });
    add-method(RakuAST::ApplyPostfix, 'is-begin-performed-before-children', [RakuAST::ApplyPostfix, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2201 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ApplyPostfix, 'is-begin-performed-after-children', [RakuAST::ApplyPostfix, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2202 src/Raku/ast/expressions.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ApplyPostfix, 'PERFORM-BEGIN-BEFORE-CHILDREN', [RakuAST::ApplyPostfix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-BEFORE-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 2204 src/Raku/ast/expressions.rakumod
        
        if $SELF.IMPL-SHOULD-CURRY-DIRECTLY {
            nqp::bindattr($SELF, RakuAST::ApplyPostfix, '$!operand',
                $SELF.IMPL-CURRY.IMPL-ADD-PARAM($resolver, $context).target.generate-lookup);
        }
    
    });
    add-method(RakuAST::ApplyPostfix, 'PERFORM-BEGIN-AFTER-CHILDREN', [RakuAST::ApplyPostfix, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-AFTER-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 2211 src/Raku/ast/expressions.rakumod
        
        my $operand := nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand');
        # This should only really happens in special circumstances, such as (* ~ *).uc.
        if nqp::bitand_i(nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix').IMPL-CURRIES, 2) {
            if $operand.IMPL-CURRIED {
                my $params := $operand.IMPL-UNCURRY;
                if nqp::elems($params) > 0 {
                    my $curried := $SELF.IMPL-CURRY;
                    for $params {
                        $curried.IMPL-ADD-PARAM($resolver, $context, :name($_.target.lexical-name));
                    }
                }
            }
        }
    
    });
    add-method(RakuAST::ApplyPostfix, 'IMPL-EXPR-QAST', [RakuAST::ApplyPostfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2227 src/Raku/ast/expressions.rakumod
        
        my $postfix-ast := nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix').IMPL-POSTFIX-QAST($context, nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand').IMPL-TO-QAST($context));
        # Method calls may be to a foreign language, and thus return
        # values may need type mapping into Raku land.
        nqp::istype(nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix'), RakuAST::Call::Methodish)
            ?? QAST::Op.new(:op<hllize>, $postfix-ast)
            !! $postfix-ast
    
    });
    add-method(RakuAST::ApplyPostfix, 'IMPL-BIND-QAST', [RakuAST::ApplyPostfix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 2236 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix').IMPL-BIND-POSTFIX-QAST($context, nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand'), $source-qast)
    
    });
    add-method(RakuAST::ApplyPostfix, 'visit-children', [RakuAST::ApplyPostfix, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2240 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand'));
        $visitor(nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix'));
    
    });
    add-method(RakuAST::ApplyPostfix, 'IMPL-CAN-INTERPRET', [RakuAST::ApplyPostfix, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2245 src/Raku/ast/expressions.rakumod
         nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand').IMPL-CAN-INTERPRET && nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix').IMPL-CAN-INTERPRET 
    });
    add-method(RakuAST::ApplyPostfix, 'IMPL-INTERPRET', [RakuAST::ApplyPostfix, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 2247 src/Raku/ast/expressions.rakumod
        
        nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!postfix').IMPL-INTERPRET($ctx, -> { nqp::getattr($SELF, RakuAST::ApplyPostfix, '$!operand').IMPL-INTERPRET($ctx) })
    
    });
#line 2167 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyPostfix, 'postfix', [], anon sub postfix ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyPostfix, '$!postfix') });
#line 2168 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::ApplyPostfix, 'operand', [], anon sub operand ($self) { nqp::getattr(nqp::decont($self), RakuAST::ApplyPostfix, '$!operand') });
    compose(RakuAST::ApplyPostfix);
    parent(RakuAST::Ternary, RakuAST::Expression);
    add-attribute(RakuAST::Ternary, RakuAST::Expression, '$!condition');
    add-attribute(RakuAST::Ternary, RakuAST::Expression, '$!then');
    add-attribute(RakuAST::Ternary, RakuAST::Expression, '$!else');
    add-method(RakuAST::Ternary, 'new', [RakuAST::Ternary, '', 0, 0, RakuAST::Expression, '$condition', 1, 0, RakuAST::Expression, '$then', 1, 0, RakuAST::Expression, '$else', 1, 0], anon sub new ($SELF_CONT, :$condition!, :$then!, :$else!) {
        my $SELF := nqp::decont($SELF_CONT);
        $condition := nqp::decont($condition);
        $then := nqp::decont($then);
        $else := nqp::decont($else);
#line 2264 src/Raku/ast/expressions.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Ternary, '$!condition', $condition);
        nqp::bindattr($obj, RakuAST::Ternary, '$!then', $then);
        nqp::bindattr($obj, RakuAST::Ternary, '$!else', $else);
        $obj
    
    });
    add-method(RakuAST::Ternary, 'IMPL-EXPR-QAST', [RakuAST::Ternary, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2272 src/Raku/ast/expressions.rakumod
        
        QAST::Op.new(
            :op('if'),
            nqp::getattr($SELF, RakuAST::Ternary, '$!condition').IMPL-TO-QAST($context),
            nqp::getattr($SELF, RakuAST::Ternary, '$!then').IMPL-TO-QAST($context),
            nqp::getattr($SELF, RakuAST::Ternary, '$!else').IMPL-TO-QAST($context),
        )
    
    });
    add-method(RakuAST::Ternary, 'visit-children', [RakuAST::Ternary, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2281 src/Raku/ast/expressions.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Ternary, '$!condition'));
        $visitor(nqp::getattr($SELF, RakuAST::Ternary, '$!then'));
        $visitor(nqp::getattr($SELF, RakuAST::Ternary, '$!else'));
    
    });
    add-method(RakuAST::Ternary, 'properties', [RakuAST::Ternary, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2287 src/Raku/ast/expressions.rakumod
         OperatorProperties.infix('?? !!') 
    });
#line 2260 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Ternary, 'then', [], anon sub then ($self) { nqp::getattr(nqp::decont($self), RakuAST::Ternary, '$!then') });
#line 2261 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Ternary, 'else', [], anon sub else ($self) { nqp::getattr(nqp::decont($self), RakuAST::Ternary, '$!else') });
#line 2259 src/Raku/ast/expressions.rakumod
    add-method(RakuAST::Ternary, 'condition', [], anon sub condition ($self) { nqp::getattr(nqp::decont($self), RakuAST::Ternary, '$!condition') });
    compose(RakuAST::Ternary);
    parent(RakuAST::Pragma, RakuAST::Statement);
    parent(RakuAST::Pragma, RakuAST::BeginTime);
    parent(RakuAST::Pragma, RakuAST::ProducesNil);
    add-attribute(RakuAST::Pragma, Str, '$!name');
    add-attribute(RakuAST::Pragma, RakuAST::Expression, '$!argument');
    add-attribute(RakuAST::Pragma, int, '$!off');
    add-method(RakuAST::Pragma, 'new', [RakuAST::Pragma, '', 0, 0, Str, '$name', 1, 0, RakuAST::Expression, '$argument', 1, 1, Any, '$off', 1, 1], anon sub new ($SELF_CONT, :$name!, :$argument?, :$off?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $argument := nqp::decont($argument);
        $off := nqp::decont($off);
#line 10 src/Raku/ast/pragma.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr(  $obj, RakuAST::Pragma, '$!name', $name // "");
        nqp::bindattr(  $obj, RakuAST::Pragma, '$!argument',
          $argument // RakuAST::Expression);
        nqp::bindattr_i($obj, RakuAST::Pragma, '$!off', $off ?? 1 !! 0);
        $obj
    
    });
    add-method(RakuAST::Pragma, 'IS-NYI', [RakuAST::Pragma, '', 0, 0, Str, '$name', 0, 0], anon sub IS-NYI ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 19 src/Raku/ast/pragma.rakumod
        
        my constant NYI-PRAGMAS := nqp::hash(
          'internals',  1,
          'invocant',   1,
          'parameters', 1,
        );

        nqp::existskey(NYI-PRAGMAS, $name)
    
    });
    add-method(RakuAST::Pragma, 'KNOWN-PRAGMAS', [RakuAST::Pragma, '', 0, 0], anon sub KNOWN-PRAGMAS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 29 src/Raku/ast/pragma.rakumod
        
        # 0 means specific handling required, 1 means just (un)set pragma
        # by that name
        my constant KNOWN-PRAGMAS := nqp::hash(
          'attributes',         0,
          'dynamic-scope',      0,
          'fatal',              1,
          'internals',          1,
          'invocant',           0,
          'isms',               0,
          'lib',                0,
          'MONKEY',             0,
#          'MONKEY-BARS',        1,
#          'MONKEY-BRAINS',      1,
#          'MONKEY-BUSINESS',    1,
          'MONKEY-GUTS',        1,
          'MONKEY-SEE-NO-EVAL', 1,
#          'MONKEY-SHINE',       1,
#          'MONKEY-TRAP',        1,
          'MONKEY-TYPING',      1,
#          'MONKEY-WRENCH',      1,
          'nqp',                1,
          'parameters',         0,
          'precompilation',     0,
          'soft',               0,
          'strict',             1,
          'trace',              1,
          'variables',          0,
          'worries',            1,
        );
    
    });
    add-method(RakuAST::Pragma, 'IS-PRAGMA', [RakuAST::Pragma, '', 0, 0, Str, '$name', 0, 0], anon sub IS-PRAGMA ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 61 src/Raku/ast/pragma.rakumod
        
        nqp::existskey($SELF.KNOWN-PRAGMAS, $name)
    
    });
    add-method(RakuAST::Pragma, 'KNOWN-ISMS', [RakuAST::Pragma, '', 0, 0], anon sub KNOWN-ISMS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 65 src/Raku/ast/pragma.rakumod
        
        my constant ISMS := nqp::hash(
          'Perl5', 'p5isms',
          'C++',   'c++isms',
        )
    
    });
    add-method(RakuAST::Pragma, 'IS-ISM', [RakuAST::Pragma, '', 0, 0, Str, '$name', 0, 0], anon sub IS-ISM ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 72 src/Raku/ast/pragma.rakumod
        
        nqp::existskey($SELF.KNOWN-ISMS, $name)
    
    });
    add-method(RakuAST::Pragma, 'PERFORM-BEGIN', [RakuAST::Pragma, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 79 src/Raku/ast/pragma.rakumod
        
        my $name    := nqp::getattr($SELF, RakuAST::Pragma, '$!name');
        my $LANG    := $*LANG;
        my int $on  := nqp::not_i(nqp::getattr_i($SELF, RakuAST::Pragma, '$!off'));
        my $arglist := nqp::getattr($SELF, RakuAST::Pragma, '$!argument')
          ?? $SELF.IMPL-BEGIN-TIME-EVALUATE(
               nqp::getattr($SELF, RakuAST::Pragma, '$!argument'), $resolver, $context
             ).List.FLATTENABLE_LIST
          !! Nil;

        if $SELF.IS-NYI($name) {
            $resolver.build-exception(
              'X::NYI',
              :feature(($on ?? 'use' !! 'no') ~ " $name"),
            ).throw;
        }
        elsif $SELF.KNOWN-PRAGMAS{$name} {
            nqp::islist($arglist)
              ?? $resolver.build-exception('X::Pragma::NoArgs', :$name).throw
              !! $LANG.set_pragma($name eq 'nqp' ?? 'MONKEY-GUTS' !! $name, $on)
        }
        elsif $name eq 'MONKEY' {
            $LANG.set_pragma($_.key, $on)
              if nqp::eqat($_.key,'MONKEY',0) for $SELF.KNOWN-PRAGMAS;
        }
        elsif $name eq 'lib' {
            if nqp::getattr_i($SELF, RakuAST::Pragma, '$!off') {
                $resolver.build-exception(
                  'X::Pragma::CannotWhat', :what<no>, :$name
                ).throw;
            }
            elsif try $*CU.precompilation-mode {
                $resolver.build-exception(
                  'X::Pragma::CannotPrecomp', :what("'use lib'")
                ).throw;
            }
            elsif $*PKGDECL {
                $resolver.build-exception('X::Package::UseLib', :what($*PKGDECL));
            }
            elsif nqp::islist($arglist) {
                my $Registry := $resolver.resolve-name-constant(
                    RakuAST::Name.from-identifier-parts(
                      'CompUnit', 'RepositoryRegistry'
                    )
                ).compile-time-value;
                my $IO-Path := $resolver.resolve-name-constant(
                    RakuAST::Name.from-identifier-parts('IO', 'Path')
                ).compile-time-value;
                for $arglist -> $arg {
                    if $arg {
                        $Registry.use-repository($Registry.repository-for-spec(
                          nqp::istype($arg,$IO-Path) ?? $arg.absolute !! $arg
                        ));
                    }
                    else {
                        $resolver.build-exception('X::LibEmpty').throw;
                    }
                }
            }
            else {
                $resolver.build-exception('X::LibNone').throw;
            }
        }
        elsif $name eq 'precompilation' {
            if nqp::getattr_i($SELF, RakuAST::Pragma, '$!off') && $*CU.precompilation-mode {
                nqp::ifnull(
                  nqp::atkey(nqp::getenvhash, 'RAKUDO_PRECOMP_WITH'), 0
                ) ?? nqp::exit(0)
                  !! $resolver.build-exception(
                       'X::Pragma::CannotPrecomp', :what<no>, :$name
                     ).throw;
            }
        }
        elsif $name eq 'isms' {
            if nqp::islist($arglist) {
                for $arglist -> $ism {
                    (my $pragma := $SELF.KNOWN-ISMS{$ism})
                      ?? $LANG.set_pragma($pragma, $on)
                      !! $resolver.build-exception(
                           "X::Ism::Unknown", :name($ism)
                         ).throw;
                }
            }
            else {
                $LANG.set_pragma($_.value, $on) for $SELF.KNOWN-ISMS;
            }
        }
        elsif $name eq 'soft' {
            nqp::islist($arglist)
              ?? $resolver.build-exception(
                   'X::NYI',
                   :feature("Arguments to '{$on ?? 'use' !! 'no' } soft'"),
                 ).throw
              !! $LANG.set_pragma($name, $on);
        }
        elsif $name eq 'attributes'
           || $name eq 'invocant'
           || $name eq 'parameters'
           || $name eq 'variables' {

            $resolver.build-exception(
              'X::Pragma::CannotWhat', :what<no>, :$name
            ).throw unless $on;

            $resolver.build-exception(
              'X::Pragma::MustOneOf', :$name, :alternatives(':D, :U or :_')
            ).throw unless $arglist;

            my $Pair := $resolver.resolve-name-constant(
              RakuAST::Name.from-identifier('Pair')
            );
            my $Bool := $resolver.resolve-name-constant(
              RakuAST::Name.from-identifier('Bool')
            );

            my $type;
            for $arglist -> $arg {
                if $type {
                    $resolver.build-exception(
                      'X::Pragma::OnlyOne', :$name
                    ).throw;
                }
                elsif nqp::istype($arg,$Pair) {
                    my $value := $arg.value;
                    if nqp::istype($value,$Bool) && $value {
                        $type := $arg.key;
                        if $type eq 'D' || $type eq 'U' {
                            $LANG.set_pragma($name, $type);
                            next;
                        }
                        elsif $type eq '_' {
                            # XXX shouldn't know this
                            nqp::deletekey($*LANG.slangs,$name);
                            next;
                        }
                    }
                    $resolver.build-exception(
                      'X::InvalidTypeSmiley', :name($arg.key)
                    ).throw;
                }
                $resolver.build-exception(
                  'X::Pragma::UnknownArg', :$name, :$arg
                ).throw;
            }
        }
        elsif $name eq 'dynamic-scope' {
            if nqp::islist($arglist) && nqp::elems($arglist) {
                # Just some variables.
                my %dyn;
                for $arglist {
                    %dyn{$_} := 1;
                }
                $LANG.set_pragma('dynamic-scope', sub ($var) { %dyn{$var} || 0 });
            }
            else {
                # All variables.
                $LANG.set_pragma('dynamic-scope', sub ($var) { 1 });
            }
        }
        else {
            $resolver.build-exception("X::Pragma::Unknown",:$name).throw;
        }
    
    });
#line 8 src/Raku/ast/pragma.rakumod
    add-method(RakuAST::Pragma, 'off', [], anon sub off ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Pragma, '$!off') });
#line 6 src/Raku/ast/pragma.rakumod
    add-method(RakuAST::Pragma, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Pragma, '$!name') });
#line 7 src/Raku/ast/pragma.rakumod
    add-method(RakuAST::Pragma, 'argument', [], anon sub argument ($self) { nqp::getattr(nqp::decont($self), RakuAST::Pragma, '$!argument') });
    compose(RakuAST::Pragma);
    parent(RakuAST::NamedArg, RakuAST::Node);
    add-method(RakuAST::NamedArg, 'named-arg-name', [RakuAST::NamedArg, '', 0, 0], anon sub named-arg-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 5 src/Raku/ast/pair.rakumod
         nqp::die('named-arg-name not implemented') 
    });
    add-method(RakuAST::NamedArg, 'named-arg-value', [RakuAST::NamedArg, '', 0, 0], anon sub named-arg-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 6 src/Raku/ast/pair.rakumod
         nqp::die('named-arg-value not implemented') 
    });
    compose(RakuAST::NamedArg);
    parent(RakuAST::FatArrow, RakuAST::Term);
    parent(RakuAST::FatArrow, RakuAST::ImplicitLookups);
    parent(RakuAST::FatArrow, RakuAST::NamedArg);
    add-attribute(RakuAST::FatArrow, Str, '$!key');
    add-attribute(RakuAST::FatArrow, RakuAST::Term, '$!value');
    add-method(RakuAST::FatArrow, 'new', [RakuAST::FatArrow, '', 0, 0, Str, '$key', 1, 0, RakuAST::Term, '$value', 1, 0], anon sub new ($SELF_CONT, :$key!, :$value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
        $value := nqp::decont($value);
#line 18 src/Raku/ast/pair.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::FatArrow, '$!key', $key);
        nqp::bindattr($obj, RakuAST::FatArrow, '$!value', $value);
        $obj
    
    });
    add-method(RakuAST::FatArrow, 'set-key', [RakuAST::FatArrow, '', 0, 0, Str, '$key', 0, 0], anon sub set-key ($SELF_CONT, $key!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
#line 25 src/Raku/ast/pair.rakumod
        
        nqp::bindattr($SELF, RakuAST::FatArrow, '$!key', $key);
    
    });
    add-method(RakuAST::FatArrow, 'named-arg-name', [RakuAST::FatArrow, '', 0, 0], anon sub named-arg-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 29 src/Raku/ast/pair.rakumod
         nqp::getattr($SELF, RakuAST::FatArrow, '$!key') 
    });
    add-method(RakuAST::FatArrow, 'named-arg-value', [RakuAST::FatArrow, '', 0, 0], anon sub named-arg-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 31 src/Raku/ast/pair.rakumod
         nqp::getattr($SELF, RakuAST::FatArrow, '$!value') 
    });
    add-method(RakuAST::FatArrow, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::FatArrow, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 33 src/Raku/ast/pair.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Pair')),
        ])
    
    });
    add-method(RakuAST::FatArrow, 'IMPL-EXPR-QAST', [RakuAST::FatArrow, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 39 src/Raku/ast/pair.rakumod
        
        my $pair-type :=
          $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
        my $key := nqp::getattr($SELF, RakuAST::FatArrow, '$!key');
        $context.ensure-sc($key);
        QAST::Op.new(
            :op('callmethod'), :name('new'),
            QAST::WVal.new( :value($pair-type) ),
            QAST::WVal.new( :value($key) ),
            nqp::getattr($SELF, RakuAST::FatArrow, '$!value').IMPL-TO-QAST($context)
        )
    
    });
    add-method(RakuAST::FatArrow, 'visit-children', [RakuAST::FatArrow, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 52 src/Raku/ast/pair.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::FatArrow, '$!value'));
    
    });
#line 16 src/Raku/ast/pair.rakumod
    add-method(RakuAST::FatArrow, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::FatArrow, '$!value') });
#line 15 src/Raku/ast/pair.rakumod
    add-method(RakuAST::FatArrow, 'key', [], anon sub key ($self) { nqp::getattr(nqp::decont($self), RakuAST::FatArrow, '$!key') });
    compose(RakuAST::FatArrow);
    parent(RakuAST::ColonPairish, Any);
    add-method(RakuAST::ColonPairish, 'IMPL-QUOTE-VALUE', [RakuAST::ColonPairish, '', 0, 0, Any, '$v', 0, 0], anon sub IMPL-QUOTE-VALUE ($SELF_CONT, $v!) {
        my $SELF := nqp::decont($SELF_CONT);
        $v := nqp::decont($v);
#line 59 src/Raku/ast/pair.rakumod
        
        if $v ~~ /<[ < > ]>/ && !($v ~~ /<[ « » $ \\ " ' ]>/) {
            '«' ~ $v ~ '»'
        }
        else {
            my $new := '';
            my int $e := nqp::chars($v);
            my int $i := -1;
            while ++$i < $e {
                my $ch := nqp::substr($v,$i,1);
                $new := $new ~ '\\' if $ch eq '<' || $ch eq '>';
                $new := $new ~ $ch;
            }
            '<' ~ $new ~ '>';
        }
    
    });
    compose(RakuAST::ColonPairish);
    parent(RakuAST::ColonPair, RakuAST::ColonPairish);
    parent(RakuAST::ColonPair, RakuAST::Term);
    parent(RakuAST::ColonPair, RakuAST::ImplicitLookups);
    parent(RakuAST::ColonPair, RakuAST::NamedArg);
    add-attribute(RakuAST::ColonPair, Str, '$!key');
    add-method(RakuAST::ColonPair, 'value', [RakuAST::ColonPair, '', 0, 0], anon sub value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 86 src/Raku/ast/pair.rakumod
         nqp::die($SELF.HOW.name($SELF) ~ ' does not implement value') 
    });
    add-method(RakuAST::ColonPair, 'set-key', [RakuAST::ColonPair, '', 0, 0, Str, '$key', 0, 0], anon sub set-key ($SELF_CONT, $key!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
#line 88 src/Raku/ast/pair.rakumod
        
        nqp::bindattr($SELF, RakuAST::ColonPair, '$!key', $key);
    
    });
    add-method(RakuAST::ColonPair, 'named-arg-name', [RakuAST::ColonPair, '', 0, 0], anon sub named-arg-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 92 src/Raku/ast/pair.rakumod
         nqp::getattr($SELF, RakuAST::ColonPair, '$!key') 
    });
    add-method(RakuAST::ColonPair, 'named-arg-value', [RakuAST::ColonPair, '', 0, 0], anon sub named-arg-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 94 src/Raku/ast/pair.rakumod
         $SELF.value 
    });
    add-method(RakuAST::ColonPair, 'properties', [RakuAST::ColonPair, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 96 src/Raku/ast/pair.rakumod
         OperatorProperties.postfix(':') 
    });
    add-method(RakuAST::ColonPair, 'canonicalize', [RakuAST::ColonPair, '', 0, 0], anon sub canonicalize ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 98 src/Raku/ast/pair.rakumod
        
        my $value := $SELF.simple-compile-time-quote-value;
        $value := $SELF.value.IMPL-INTERPRET(RakuAST::IMPL::InterpContext.new)
            if !$value && $SELF.value.IMPL-CAN-INTERPRET;
        nqp::getattr($SELF, RakuAST::ColonPair, '$!key') ~ ($value ?? $SELF.IMPL-QUOTE-VALUE($value) !! $SELF.value.DEPARSE)
    
    });
    add-method(RakuAST::ColonPair, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::ColonPair, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 105 src/Raku/ast/pair.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Pair')),
        ])
    
    });
    add-method(RakuAST::ColonPair, 'IMPL-EXPR-QAST', [RakuAST::ColonPair, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 111 src/Raku/ast/pair.rakumod
        
        my $pair-type :=
          $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
        my $key := nqp::getattr($SELF, RakuAST::ColonPair, '$!key');
        $context.ensure-sc($key);
        QAST::Op.new(
            :op('callmethod'), :name('new'),
            QAST::WVal.new( :value($pair-type) ),
            QAST::WVal.new( :value($key) ),
            $SELF.IMPL-VALUE-QAST($context)
        )
    
    });
    add-method(RakuAST::ColonPair, 'IMPL-VALUE-QAST', [RakuAST::ColonPair, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-VALUE-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 124 src/Raku/ast/pair.rakumod
        
        $SELF.value.IMPL-TO-QAST($context)
    
    });
#line 84 src/Raku/ast/pair.rakumod
    add-method(RakuAST::ColonPair, 'key', [], anon sub key ($self) { nqp::getattr(nqp::decont($self), RakuAST::ColonPair, '$!key') });
    compose(RakuAST::ColonPair);
    parent(RakuAST::ColonPairs, RakuAST::Node);
    add-attribute(RakuAST::ColonPairs, Mu, '$!colonpairs');
    add-method(RakuAST::ColonPairs, 'new', [RakuAST::ColonPairs, '', 0, 0, Any, '$a', 0, 0, Any, '$b', 0, 0], anon sub new ($SELF_CONT, $a!, $b!) {
        my $SELF := nqp::decont($SELF_CONT);
        $a := nqp::decont($a);
        $b := nqp::decont($b);
#line 136 src/Raku/ast/pair.rakumod
        
        my $obj := nqp::create($SELF);
        if nqp::istype($a, RakuAST::ColonPairs) {
            nqp::bindattr($obj, RakuAST::ColonPairs, '$!colonpairs', $a.colonpairs);
        }
        else {
            nqp::bindattr($obj, RakuAST::ColonPairs, '$!colonpairs', [$a]);
        }
        nqp::push($obj.colonpairs, $b);
        $obj
    
    });
#line 134 src/Raku/ast/pair.rakumod
    add-method(RakuAST::ColonPairs, 'colonpairs', [], anon sub colonpairs ($self) { nqp::getattr(nqp::decont($self), RakuAST::ColonPairs, '$!colonpairs') });
    compose(RakuAST::ColonPairs);
    parent(RakuAST::QuotePair, RakuAST::ColonPair);
    compose(RakuAST::QuotePair);
    parent(RakuAST::ColonPair::True, RakuAST::QuotePair);
    add-method(RakuAST::ColonPair::True, 'new', [RakuAST::ColonPair::True, '', 0, 0, Str, '$key', 0, 0], anon sub new ($SELF_CONT, $key!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
#line 157 src/Raku/ast/pair.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ColonPair, '$!key', $key);
        $obj
    
    });
    add-method(RakuAST::ColonPair::True, 'canonicalize', [RakuAST::ColonPair::True, '', 0, 0], anon sub canonicalize ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 163 src/Raku/ast/pair.rakumod
        
        nqp::getattr($SELF, RakuAST::ColonPair, '$!key')
    
    });
    add-method(RakuAST::ColonPair::True, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::ColonPair::True, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 167 src/Raku/ast/pair.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Pair'))
        ])
    
    });
    add-method(RakuAST::ColonPair::True, 'value', [RakuAST::ColonPair::True, '', 0, 0], anon sub value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 173 src/Raku/ast/pair.rakumod
        
        RakuAST::Declaration::ResolvedConstant.new(compile-time-value => (Bool.WHO)<True>)
    
    });
    add-method(RakuAST::ColonPair::True, 'simple-compile-time-quote-value', [RakuAST::ColonPair::True, '', 0, 0], anon sub simple-compile-time-quote-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 177 src/Raku/ast/pair.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ColonPair::True, 'IMPL-VALUE-QAST', [RakuAST::ColonPair::True, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-VALUE-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 179 src/Raku/ast/pair.rakumod
        
        my $value := (Bool.WHO)<True>;
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
    add-method(RakuAST::ColonPair::True, 'IMPL-CAN-INTERPRET', [RakuAST::ColonPair::True, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 185 src/Raku/ast/pair.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ColonPair::True, 'IMPL-INTERPRET', [RakuAST::ColonPair::True, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 187 src/Raku/ast/pair.rakumod
        
        $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value.new(
          $SELF.key, (Bool.WHO)<True>
        )
    
    });
    compose(RakuAST::ColonPair::True);
    parent(RakuAST::ColonPair::False, RakuAST::QuotePair);
    add-method(RakuAST::ColonPair::False, 'new', [RakuAST::ColonPair::False, '', 0, 0, Str, '$key', 0, 0], anon sub new ($SELF_CONT, $key!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
#line 198 src/Raku/ast/pair.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ColonPair, '$!key', $key);
        $obj
    
    });
    add-method(RakuAST::ColonPair::False, 'canonicalize', [RakuAST::ColonPair::False, '', 0, 0], anon sub canonicalize ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 204 src/Raku/ast/pair.rakumod
        
        "!" ~ nqp::getattr($SELF, RakuAST::ColonPair, '$!key')
    
    });
    add-method(RakuAST::ColonPair::False, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::ColonPair::False, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 208 src/Raku/ast/pair.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Pair'))
        ])
    
    });
    add-method(RakuAST::ColonPair::False, 'value', [RakuAST::ColonPair::False, '', 0, 0], anon sub value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 214 src/Raku/ast/pair.rakumod
        
        RakuAST::Declaration::ResolvedConstant.new(compile-time-value => (Bool.WHO)<False>)
    
    });
    add-method(RakuAST::ColonPair::False, 'simple-compile-time-quote-value', [RakuAST::ColonPair::False, '', 0, 0], anon sub simple-compile-time-quote-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 218 src/Raku/ast/pair.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::ColonPair::False, 'IMPL-VALUE-QAST', [RakuAST::ColonPair::False, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-VALUE-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 220 src/Raku/ast/pair.rakumod
        
        my $value := (Bool.WHO)<False>;
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
    add-method(RakuAST::ColonPair::False, 'IMPL-CAN-INTERPRET', [RakuAST::ColonPair::False, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 226 src/Raku/ast/pair.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ColonPair::False, 'IMPL-INTERPRET', [RakuAST::ColonPair::False, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 228 src/Raku/ast/pair.rakumod
        
        $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value.new(
          $SELF.key, (Bool.WHO)<False>
        )
    
    });
    compose(RakuAST::ColonPair::False);
    parent(RakuAST::ColonPair::Number, RakuAST::QuotePair);
    add-attribute(RakuAST::ColonPair::Number, RakuAST::IntLiteral, '$!value');
    add-method(RakuAST::ColonPair::Number, 'new', [RakuAST::ColonPair::Number, '', 0, 0, Str, '$key', 1, 0, RakuAST::IntLiteral, '$value', 1, 1], anon sub new ($SELF_CONT, :$key!, :$value?) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
        $value := nqp::decont($value);
#line 241 src/Raku/ast/pair.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ColonPair, '$!key', $key);
        nqp::bindattr($obj, RakuAST::ColonPair::Number, '$!value', $value);
        $obj
    
    });
    add-method(RakuAST::ColonPair::Number, 'simple-compile-time-quote-value', [RakuAST::ColonPair::Number, '', 0, 0], anon sub simple-compile-time-quote-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 248 src/Raku/ast/pair.rakumod
         nqp::getattr($SELF, RakuAST::ColonPair::Number, '$!value').value 
    });
    add-method(RakuAST::ColonPair::Number, 'visit-children', [RakuAST::ColonPair::Number, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 250 src/Raku/ast/pair.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ColonPair::Number, '$!value'));
    
    });
    add-method(RakuAST::ColonPair::Number, 'IMPL-CAN-INTERPRET', [RakuAST::ColonPair::Number, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 254 src/Raku/ast/pair.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ColonPair::Number, 'IMPL-INTERPRET', [RakuAST::ColonPair::Number, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 256 src/Raku/ast/pair.rakumod
        
        $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value.new(
          $SELF.key, nqp::getattr($SELF, RakuAST::ColonPair::Number, '$!value')
        )
    
    });
#line 239 src/Raku/ast/pair.rakumod
    add-method(RakuAST::ColonPair::Number, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::ColonPair::Number, '$!value') });
    compose(RakuAST::ColonPair::Number);
    parent(RakuAST::ColonPair::Value, RakuAST::QuotePair);
    add-attribute(RakuAST::ColonPair::Value, RakuAST::Expression, '$!value');
    add-method(RakuAST::ColonPair::Value, 'new', [RakuAST::ColonPair::Value, '', 0, 0, Str, '$key', 1, 0, RakuAST::Expression, '$value', 1, 0], anon sub new ($SELF_CONT, :$key!, :$value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
        $value := nqp::decont($value);
#line 269 src/Raku/ast/pair.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ColonPair, '$!key', $key);
        nqp::bindattr($obj, RakuAST::ColonPair::Value, '$!value', $value);
        $obj
    
    });
    add-method(RakuAST::ColonPair::Value, 'visit-children', [RakuAST::ColonPair::Value, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 276 src/Raku/ast/pair.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ColonPair::Value, '$!value'));
    
    });
    add-method(RakuAST::ColonPair::Value, 'simple-compile-time-quote-value', [RakuAST::ColonPair::Value, '', 0, 0], anon sub simple-compile-time-quote-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 280 src/Raku/ast/pair.rakumod
        
        # TODO various cases we can handle here
        if nqp::istype($SELF.value, RakuAST::QuotedString) {
            $SELF.value.literal-value
        }
        else {
            Nil
        }
    
    });
    add-method(RakuAST::ColonPair::Value, 'IMPL-CAN-INTERPRET', [RakuAST::ColonPair::Value, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 290 src/Raku/ast/pair.rakumod
         nqp::getattr($SELF, RakuAST::ColonPair::Value, '$!value').IMPL-CAN-INTERPRET 
    });
    add-method(RakuAST::ColonPair::Value, 'IMPL-INTERPRET', [RakuAST::ColonPair::Value, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 292 src/Raku/ast/pair.rakumod
        
        $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value.new(
          $SELF.key, nqp::getattr($SELF, RakuAST::ColonPair::Value, '$!value').IMPL-INTERPRET($ctx)
        )
    
    });
#line 267 src/Raku/ast/pair.rakumod
    add-method(RakuAST::ColonPair::Value, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::ColonPair::Value, '$!value') });
    compose(RakuAST::ColonPair::Value);
    parent(RakuAST::ColonPair::Variable, RakuAST::ColonPair);
    add-attribute(RakuAST::ColonPair::Variable, RakuAST::Var, '$!value');
    add-method(RakuAST::ColonPair::Variable, 'new', [RakuAST::ColonPair::Variable, '', 0, 0, Str, '$key', 1, 0, RakuAST::Var, '$value', 1, 1], anon sub new ($SELF_CONT, :$key!, :$value?) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
        $value := nqp::decont($value);
#line 305 src/Raku/ast/pair.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ColonPair, '$!key', $key);
        nqp::bindattr($obj, RakuAST::ColonPair::Variable, '$!value', $value);
        $obj
    
    });
    add-method(RakuAST::ColonPair::Variable, 'visit-children', [RakuAST::ColonPair::Variable, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 312 src/Raku/ast/pair.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ColonPair::Variable, '$!value'));
    
    });
#line 303 src/Raku/ast/pair.rakumod
    add-method(RakuAST::ColonPair::Variable, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::ColonPair::Variable, '$!value') });
    compose(RakuAST::ColonPair::Variable);
    parent(RakuAST::Circumfix, RakuAST::Term);
    parent(RakuAST::Circumfix, RakuAST::Contextualizable);
    compose(RakuAST::Circumfix);
    parent(RakuAST::Circumfix::Parentheses, RakuAST::Circumfix);
    add-attribute(RakuAST::Circumfix::Parentheses, RakuAST::SemiList, '$!semilist');
    add-method(RakuAST::Circumfix::Parentheses, 'new', [RakuAST::Circumfix::Parentheses, '', 0, 0, RakuAST::SemiList, '$semilist', 0, 0], anon sub new ($SELF_CONT, $semilist!) {
        my $SELF := nqp::decont($SELF_CONT);
        $semilist := nqp::decont($semilist);
#line 12 src/Raku/ast/circumfix.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Circumfix::Parentheses, '$!semilist', $semilist);
        $obj
    
    });
    add-method(RakuAST::Circumfix::Parentheses, 'IMPL-CONTAINS-SINGULAR-CURRYABLE-EXPRESSION', [RakuAST::Circumfix::Parentheses, '', 0, 0], anon sub IMPL-CONTAINS-SINGULAR-CURRYABLE-EXPRESSION ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 22 src/Raku/ast/circumfix.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').statements)) == 1
            && (my $statement-expression := nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').statements.AT-POS(0))
            && nqp::istype($statement-expression, RakuAST::Statement::Expression)
            && (my $expression := $statement-expression.expression)
            && nqp::istype($expression, RakuAST::WhateverApplicable)
            && $expression.IMPL-SHOULD-CURRY-DIRECTLY
                ?? $expression
                !! Nil
    
    });
    add-method(RakuAST::Circumfix::Parentheses, 'IMPL-SINGULAR-CURRIED-EXPRESSION', [RakuAST::Circumfix::Parentheses, '', 0, 0], anon sub IMPL-SINGULAR-CURRIED-EXPRESSION ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 33 src/Raku/ast/circumfix.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').statements)) == 1
            && (my $statement-expression := nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').statements.AT-POS(0))
            && nqp::istype($statement-expression, RakuAST::Statement::Expression)
            && (my $expression := $statement-expression.expression)
            && nqp::istype($expression, RakuAST::WhateverApplicable)
            && $expression.IMPL-CURRIED
                ?? $expression
                !! Nil
    
    });
    add-method(RakuAST::Circumfix::Parentheses, 'IMPL-EXPR-QAST', [RakuAST::Circumfix::Parentheses, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 44 src/Raku/ast/circumfix.rakumod
        
        nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::Circumfix::Parentheses, 'visit-children', [RakuAST::Circumfix::Parentheses, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 48 src/Raku/ast/circumfix.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist'));
    
    });
    add-method(RakuAST::Circumfix::Parentheses, 'IMPL-CAN-INTERPRET', [RakuAST::Circumfix::Parentheses, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 52 src/Raku/ast/circumfix.rakumod
        
        nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').IMPL-CAN-INTERPRET
    
    });
    add-method(RakuAST::Circumfix::Parentheses, 'IMPL-INTERPRET', [RakuAST::Circumfix::Parentheses, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 56 src/Raku/ast/circumfix.rakumod
        
        nqp::getattr($SELF, RakuAST::Circumfix::Parentheses, '$!semilist').IMPL-INTERPRET($ctx)
    
    });
#line 10 src/Raku/ast/circumfix.rakumod
    add-method(RakuAST::Circumfix::Parentheses, 'semilist', [], anon sub semilist ($self) { nqp::getattr(nqp::decont($self), RakuAST::Circumfix::Parentheses, '$!semilist') });
    compose(RakuAST::Circumfix::Parentheses);
    parent(RakuAST::Circumfix::ArrayComposer, RakuAST::Circumfix);
    parent(RakuAST::Circumfix::ArrayComposer, RakuAST::Lookup);
    parent(RakuAST::Circumfix::ArrayComposer, RakuAST::ColonPairish);
    add-attribute(RakuAST::Circumfix::ArrayComposer, RakuAST::SemiList, '$!semilist');
    add-method(RakuAST::Circumfix::ArrayComposer, 'new', [RakuAST::Circumfix::ArrayComposer, '', 0, 0, RakuAST::SemiList, '$semilist', 0, 0], anon sub new ($SELF_CONT, $semilist!) {
        my $SELF := nqp::decont($SELF_CONT);
        $semilist := nqp::decont($semilist);
#line 69 src/Raku/ast/circumfix.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Circumfix::ArrayComposer, '$!semilist', $semilist);
        $obj
    
    });
    add-method(RakuAST::Circumfix::ArrayComposer, 'canonicalize', [RakuAST::Circumfix::ArrayComposer, '', 0, 0], anon sub canonicalize ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 75 src/Raku/ast/circumfix.rakumod
        
        my @statements := $SELF.semilist.code-statements;
        if nqp::elems(@statements) == 1 {
            $SELF.IMPL-QUOTE-VALUE(@statements[0].expression.literal-value)
        }
        else {
            my @parts;
            for @statements {
                nqp::die('canonicalize NYI for non-simple colonpairs: ' ~ $_.HOW.name($_))
                    unless nqp::istype($_, RakuAST::Statement::Expression);
                nqp::push(@parts, "'" ~ $_.expression.literal-value ~ "'");
            }
            '[' ~ nqp::join('; ', @parts) ~ ']'
        }
    
    });
    add-method(RakuAST::Circumfix::ArrayComposer, 'resolve-with', [RakuAST::Circumfix::ArrayComposer, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 91 src/Raku/ast/circumfix.rakumod
        
        my $resolved := $resolver.resolve-lexical('&circumfix:<[ ]>');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Circumfix::ArrayComposer, 'IMPL-EXPR-QAST', [RakuAST::Circumfix::ArrayComposer, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 99 src/Raku/ast/circumfix.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        QAST::Op.new(
            :op('call'), :$name,
            nqp::getattr($SELF, RakuAST::Circumfix::ArrayComposer, '$!semilist').IMPL-TO-QAST($context)
        )
    
    });
    add-method(RakuAST::Circumfix::ArrayComposer, 'visit-children', [RakuAST::Circumfix::ArrayComposer, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 107 src/Raku/ast/circumfix.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Circumfix::ArrayComposer, '$!semilist'));
    
    });
    add-method(RakuAST::Circumfix::ArrayComposer, 'IMPL-CAN-INTERPRET', [RakuAST::Circumfix::ArrayComposer, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 111 src/Raku/ast/circumfix.rakumod
        
        my @statements := $SELF.semilist.code-statements;
        nqp::elems(@statements) == 1 && @statements[0].IMPL-CAN-INTERPRET
    
    });
    add-method(RakuAST::Circumfix::ArrayComposer, 'IMPL-INTERPRET', [RakuAST::Circumfix::ArrayComposer, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 116 src/Raku/ast/circumfix.rakumod
        
        my @statements := $SELF.semilist.code-statements;
        my $result := @statements[0].IMPL-INTERPRET($ctx);
        Array.new($result)
    
    });
#line 67 src/Raku/ast/circumfix.rakumod
    add-method(RakuAST::Circumfix::ArrayComposer, 'semilist', [], anon sub semilist ($self) { nqp::getattr(nqp::decont($self), RakuAST::Circumfix::ArrayComposer, '$!semilist') });
    compose(RakuAST::Circumfix::ArrayComposer);
    parent(RakuAST::Circumfix::HashComposer, RakuAST::Circumfix);
    parent(RakuAST::Circumfix::HashComposer, RakuAST::Lookup);
    add-attribute(RakuAST::Circumfix::HashComposer, RakuAST::Expression, '$!expression');
    add-attribute(RakuAST::Circumfix::HashComposer, int, '$!object-hash');
    add-method(RakuAST::Circumfix::HashComposer, 'new', [RakuAST::Circumfix::HashComposer, '', 0, 0, RakuAST::Expression, '$expression', 0, 1, int, '$object-hash', 1, 1], anon sub new ($SELF_CONT, $expression?, :$object-hash?) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
        $object-hash := nqp::decont($object-hash);
#line 135 src/Raku/ast/circumfix.rakumod
        
        my $obj := nqp::create($SELF);
        $obj.set-expression($expression);
        nqp::bindattr_i($obj, RakuAST::Circumfix::HashComposer, '$!object-hash', $object-hash ?? 1 !! 0);
        $obj
    
    });
    add-method(RakuAST::Circumfix::HashComposer, 'set-expression', [RakuAST::Circumfix::HashComposer, '', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub set-expression ($SELF_CONT, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 142 src/Raku/ast/circumfix.rakumod
        
        nqp::bindattr($SELF, RakuAST::Circumfix::HashComposer, '$!expression',
            $expression // RakuAST::Expression);
        Nil
    
    });
    add-method(RakuAST::Circumfix::HashComposer, 'resolve-with', [RakuAST::Circumfix::HashComposer, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 148 src/Raku/ast/circumfix.rakumod
        
        my $resolved := nqp::getattr_i($SELF, RakuAST::Circumfix::HashComposer, '$!object-hash')
                             ?? $resolver.resolve-lexical('&circumfix:<:{ }>')
                             !! $resolver.resolve-lexical('&circumfix:<{ }>');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Circumfix::HashComposer, 'IMPL-EXPR-QAST', [RakuAST::Circumfix::HashComposer, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 158 src/Raku/ast/circumfix.rakumod
        
        my $name := $SELF.resolution.lexical-name;
        my $expression := nqp::getattr($SELF, RakuAST::Circumfix::HashComposer, '$!expression');

        my $op := QAST::Op.new(:op<call>, :$name);
        if $expression {
            $op.push($expression.IMPL-TO-QAST($context))
        }
        $op
    
    });
    add-method(RakuAST::Circumfix::HashComposer, 'visit-children', [RakuAST::Circumfix::HashComposer, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 169 src/Raku/ast/circumfix.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Circumfix::HashComposer, '$!expression')) if nqp::getattr($SELF, RakuAST::Circumfix::HashComposer, '$!expression');
    
    });
#line 133 src/Raku/ast/circumfix.rakumod
    add-method(RakuAST::Circumfix::HashComposer, 'object-hash', [], anon sub object-hash ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Circumfix::HashComposer, '$!object-hash') });
#line 132 src/Raku/ast/circumfix.rakumod
    add-method(RakuAST::Circumfix::HashComposer, 'expression', [], anon sub expression ($self) { nqp::getattr(nqp::decont($self), RakuAST::Circumfix::HashComposer, '$!expression') });
    compose(RakuAST::Circumfix::HashComposer);
    parent(RakuAST::ArgList, RakuAST::CaptureSource);
    add-attribute(RakuAST::ArgList, List, '$!args');
    add-attribute(RakuAST::ArgList, RakuAST::Expression, '$!invocant');
    add-method(RakuAST::ArgList, 'new', [RakuAST::ArgList, '', 0, 0, Any, '@args', 0, 0], anon sub new ($SELF_CONT, *@args) {
        my $SELF := nqp::decont($SELF_CONT);
        @args := nqp::decont(@args);
#line 8 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ArgList, '$!args', []);
        for @args {
            $obj.push: $_;
        }
        $obj
    
    });
    add-method(RakuAST::ArgList, 'from-comma-list', [RakuAST::ArgList, '', 0, 0, RakuAST::ApplyListInfix, '$comma-apply', 0, 0], anon sub from-comma-list ($SELF_CONT, $comma-apply!) {
        my $SELF := nqp::decont($SELF_CONT);
        $comma-apply := nqp::decont($comma-apply);
#line 17 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ArgList, '$!args', []);
        for $SELF.IMPL-UNWRAP-LIST($comma-apply.operands) {
            $obj.push: $_;
        }
        $obj
    
    });
    add-method(RakuAST::ArgList, 'from-invocant-list', [RakuAST::ArgList, '', 0, 0, RakuAST::ApplyListInfix, '$colon-apply', 0, 0], anon sub from-invocant-list ($SELF_CONT, $colon-apply!) {
        my $SELF := nqp::decont($SELF_CONT);
        $colon-apply := nqp::decont($colon-apply);
#line 26 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ArgList, '$!args', []);
        my @args := nqp::clone($SELF.IMPL-UNWRAP-LIST($colon-apply.operands));
        nqp::bindattr($obj, RakuAST::ArgList, '$!invocant', nqp::shift(@args));
        for @args {
            $obj.push: $_;
        }
        $obj
    
    });
    add-method(RakuAST::ArgList, 'arg-at-pos', [RakuAST::ArgList, '', 0, 0, int, '$pos', 0, 0], anon sub arg-at-pos ($SELF_CONT, $pos!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
#line 37 src/Raku/ast/call.rakumod
         nqp::atpos(nqp::getattr($SELF, RakuAST::ArgList, '$!args'),$pos) 
    });
    add-method(RakuAST::ArgList, 'set-arg-at-pos', [RakuAST::ArgList, '', 0, 0, int, '$pos', 0, 0, RakuAST::Expression, '$arg', 0, 0], anon sub set-arg-at-pos ($SELF_CONT, $pos!, $arg!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pos := nqp::decont($pos);
        $arg := nqp::decont($arg);
#line 38 src/Raku/ast/call.rakumod
        
        nqp::bindpos(nqp::getattr($SELF, RakuAST::ArgList, '$!args'),$pos,$arg);
        Nil
    
    });
    add-method(RakuAST::ArgList, 'push', [RakuAST::ArgList, '', 0, 0, Any, '$arg', 0, 0], anon sub push ($SELF_CONT, $arg!) {
        my $SELF := nqp::decont($SELF_CONT);
        $arg := nqp::decont($arg);
#line 43 src/Raku/ast/call.rakumod
        
        if nqp::istype($arg, RakuAST::ColonPairs) {
            for $arg.colonpairs {
                $SELF.push: $_
            }
        }
        else {
            nqp::push(nqp::getattr($SELF, RakuAST::ArgList, '$!args'), $arg)
        }
    
    });
    add-method(RakuAST::ArgList, 'has-args', [RakuAST::ArgList, '', 0, 0], anon sub has-args ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 54 src/Raku/ast/call.rakumod
         nqp::elems(nqp::getattr($SELF, RakuAST::ArgList, '$!args')) 
    });
    add-method(RakuAST::ArgList, 'args', [RakuAST::ArgList, '', 0, 0], anon sub args ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 56 src/Raku/ast/call.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::ArgList, '$!args'))
    
    });
    add-method(RakuAST::ArgList, 'visit-children', [RakuAST::ArgList, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 60 src/Raku/ast/call.rakumod
        
        my @args := nqp::getattr($SELF, RakuAST::ArgList, '$!args');
        $visitor(nqp::getattr($SELF, RakuAST::ArgList, '$!invocant')) if nqp::getattr($SELF, RakuAST::ArgList, '$!invocant');
        for @args {
            $visitor($_);
        }
    
    });
    add-method(RakuAST::ArgList, 'IMPL-ADD-QAST-ARGS', [RakuAST::ArgList, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Op, '$call', 0, 0], anon sub IMPL-ADD-QAST-ARGS ($SELF_CONT, $context!, $call!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $call := nqp::decont($call);
#line 68 src/Raku/ast/call.rakumod
        
        # We need to remove duplicate named args, so make a first pass through to
        # collect those.
        my %named-counts;
        for nqp::getattr($SELF, RakuAST::ArgList, '$!args') -> $arg {
            if nqp::istype($arg, RakuAST::NamedArg) {
                %named-counts{$arg.named-arg-name}++;
            }
        }

        # Now emit code to compile and pass each argument.
        for nqp::getattr($SELF, RakuAST::ArgList, '$!args') -> $arg {
            if $SELF.IMPL-IS-FLATTENING($arg) {
                # Flattening argument; evaluate it once and pass the array and hash
                # flattening parts.
                my $temp := QAST::Node.unique('flattening_');
                $call.push(QAST::Op.new(
                    :op('callmethod'), :name('FLATTENABLE_LIST'),
                    QAST::Op.new(
                        :op('bind'),
                        QAST::Var.new( :name($temp), :scope('local'), :decl('var') ),
                        $arg.operand.IMPL-TO-QAST($context)
                    ),
                    :flat(1)
                ));
                $call.push(QAST::Op.new(
                    :op('callmethod'), :name('FLATTENABLE_HASH'),
                    QAST::Var.new( :name($temp), :scope('local') ),
                    :flat(1), :named(1)
                ));
            }
            elsif nqp::istype($arg, RakuAST::NamedArg) {
                my $name := $arg.named-arg-name;
                if %named-counts{$name} == 1 {
                    # It's the final appearance of this name, so emit it as the
                    # named argument.
                    my $val-ast := $arg.named-arg-value.IMPL-TO-QAST($context);
                    $val-ast.named($name);
                    $call.push($val-ast);
                }
                else {
                    # It's a discarded value. If it has side-effects, then we
                    # must evaluate those.
                    my $value := $arg.named-arg-value;
                    unless $value.pure {
                        $call.push(QAST::Stmts.new(
                            :flat,
                            $value.IMPL-TO-QAST($context),
                            QAST::Op.new( :op('list') ) # flattens to nothing
                        ));
                    }
                    %named-counts{$name}--;
                }
            }
            else {
                # Positional argument.
                $call.push($arg.IMPL-TO-QAST($context))
            }
        }
    
    });
    add-method(RakuAST::ArgList, 'IMPL-IS-ONE-POS-ARG', [RakuAST::ArgList, '', 0, 0], anon sub IMPL-IS-ONE-POS-ARG ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 129 src/Raku/ast/call.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::ArgList, '$!args')) == 1 &&
            !nqp::istype(nqp::getattr($SELF, RakuAST::ArgList, '$!args')[0], RakuAST::NamedArg) &&
            !$SELF.IMPL-IS-FLATTENING(nqp::getattr($SELF, RakuAST::ArgList, '$!args')[0])
    
    });
    add-method(RakuAST::ArgList, 'IMPL-IS-FLATTENING', [RakuAST::ArgList, '', 0, 0, RakuAST::Node, '$arg', 0, 0], anon sub IMPL-IS-FLATTENING ($SELF_CONT, $arg!) {
        my $SELF := nqp::decont($SELF_CONT);
        $arg := nqp::decont($arg);
#line 135 src/Raku/ast/call.rakumod
        
        nqp::istype($arg, RakuAST::ApplyPrefix) &&
            nqp::istype($arg.prefix, RakuAST::Prefix) &&
            $arg.prefix.operator eq '|'
    
    });
    add-method(RakuAST::ArgList, 'IMPL-CAN-INTERPRET', [RakuAST::ArgList, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 141 src/Raku/ast/call.rakumod
        
        for nqp::getattr($SELF, RakuAST::ArgList, '$!args') -> $arg {
            if $SELF.IMPL-IS-FLATTENING($arg) {
                # Flattening args not implemented in the interpreter
                # (possible, maybe some ordering subtleties).
                return (Bool.WHO)<False>;
            }
            elsif nqp::istype($arg, RakuAST::NamedArg) {
                return (Bool.WHO)<False> unless $arg.named-arg-value.IMPL-CAN-INTERPRET;
            }
            else {
                return (Bool.WHO)<False> unless $arg.IMPL-CAN-INTERPRET;
            }
        }
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::ArgList, 'IMPL-INTERPRET', [RakuAST::ArgList, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 158 src/Raku/ast/call.rakumod
        
        my @pos;
        my %named;
        for nqp::getattr($SELF, RakuAST::ArgList, '$!args') -> $arg {
            if nqp::istype($arg, RakuAST::NamedArg) {
                %named{$arg.named-arg-name} := $arg.named-arg-value.IMPL-INTERPRET($ctx);
            }
            else {
                nqp::push(@pos, $arg.IMPL-INTERPRET($ctx));
            }
        }
        [@pos, %named]
    
    });
    add-method(RakuAST::ArgList, 'IMPL-HAS-ONLY-COMPILE-TIME-VALUES', [RakuAST::ArgList, '', 0, 0], anon sub IMPL-HAS-ONLY-COMPILE-TIME-VALUES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 172 src/Raku/ast/call.rakumod
        
        for nqp::getattr($SELF, RakuAST::ArgList, '$!args') -> $arg {
            return (Bool.WHO)<False> unless nqp::istype($arg, RakuAST::CompileTimeValue);
        }
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::ArgList, 'IMPL-COMPILE-TIME-VALUES', [RakuAST::ArgList, '', 0, 0], anon sub IMPL-COMPILE-TIME-VALUES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 179 src/Raku/ast/call.rakumod
        
        my @pos;
        my %named;
        for nqp::getattr($SELF, RakuAST::ArgList, '$!args') -> $arg {
            if nqp::istype($arg, RakuAST::NamedArg) {
                %named{$arg.named-arg-name} := $arg.named-arg-value.compile-time-value;
            }
            else {
                nqp::push(@pos, $arg.compile-time-value);
            }
        }
        [@pos, %named]
    
    });
#line 6 src/Raku/ast/call.rakumod
    add-method(RakuAST::ArgList, 'invocant', [], anon sub invocant ($self) { nqp::getattr(nqp::decont($self), RakuAST::ArgList, '$!invocant') });
    compose(RakuAST::ArgList);
    parent(RakuAST::Call, Any);
    add-attribute(RakuAST::Call, RakuAST::ArgList, '$!args');
    add-method(RakuAST::Call, 'add-colonpair', [RakuAST::Call, '', 0, 0, RakuAST::ColonPair, '$pair', 0, 0], anon sub add-colonpair ($SELF_CONT, $pair!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pair := nqp::decont($pair);
#line 199 src/Raku/ast/call.rakumod
        
        nqp::getattr($SELF, RakuAST::Call, '$!args').push($pair);
        Nil
    
    });
#line 197 src/Raku/ast/call.rakumod
    add-method(RakuAST::Call, 'args', [], anon sub args ($self) { nqp::getattr(nqp::decont($self), RakuAST::Call, '$!args') });
    compose(RakuAST::Call);
    parent(RakuAST::Call::Name, RakuAST::Term);
    parent(RakuAST::Call::Name, RakuAST::Call);
    parent(RakuAST::Call::Name, RakuAST::Lookup);
    add-attribute(RakuAST::Call::Name, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Call::Name, Mu, '$!package');
    add-method(RakuAST::Call::Name, 'new', [RakuAST::Call::Name, '', 0, 0, RakuAST::Name, '$name', 1, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$name!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $args := nqp::decont($args);
#line 214 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Call::Name, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Call, '$!args', $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Call::Name, 'visit-children', [RakuAST::Call::Name, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 221 src/Raku/ast/call.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Call::Name, '$!name'));
        $visitor($SELF.args);
    
    });
    add-method(RakuAST::Call::Name, 'properties', [RakuAST::Call::Name, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 230 src/Raku/ast/call.rakumod
         OperatorProperties.prefix 
    });
    add-method(RakuAST::Call::Name, 'needs-resolution', [RakuAST::Call::Name, '', 0, 0], anon sub needs-resolution ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 232 src/Raku/ast/call.rakumod
         nqp::getattr($SELF, RakuAST::Call::Name, '$!name').is-identifier 
    });
    add-method(RakuAST::Call::Name, 'resolve-with', [RakuAST::Call::Name, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 234 src/Raku/ast/call.rakumod
        
        nqp::bindattr($SELF, RakuAST::Call::Name, '$!package', $resolver.current-package);
        my $resolved := $resolver.resolve-name(nqp::getattr($SELF, RakuAST::Call::Name, '$!name'), :sigil('&'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        elsif nqp::getattr($SELF, RakuAST::Call::Name, '$!name').is-package-lookup {
            my $name := nqp::getattr($SELF, RakuAST::Call::Name, '$!name').base-name;
            if $name.canonicalize {
                $resolved := $resolver.resolve-name($name);
                if $resolved {
                    my $v := $resolved.compile-time-value;
                    $SELF.set-resolution($resolved);
                }
            }
        }
        Nil
    
    });
    add-method(RakuAST::Call::Name, 'undeclared-symbol-details', [RakuAST::Call::Name, '', 0, 0], anon sub undeclared-symbol-details ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 253 src/Raku/ast/call.rakumod
        
        RakuAST::UndeclaredSymbolDescription::Routine.new(nqp::getattr($SELF, RakuAST::Call::Name, '$!name').canonicalize())
    
    });
    add-method(RakuAST::Call::Name, 'IMPL-EXPR-QAST', [RakuAST::Call::Name, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 257 src/Raku/ast/call.rakumod
        
        my $call := QAST::Op.new( :op('call') );
        if nqp::getattr($SELF, RakuAST::Call::Name, '$!name').is-identifier {
            $call.name($SELF.resolution.lexical-name);
        }
        else {
            if my $op := nqp::getattr($SELF, RakuAST::Call::Name, '$!name').IMPL-IS-NQP-OP {
                return RakuAST::Nqp.new($op, $SELF.args).IMPL-TO-QAST($context);
            }
            elsif nqp::getattr($SELF, RakuAST::Call::Name, '$!name').is-package-lookup {
                return $SELF.is-resolved
                    ?? nqp::getattr($SELF, RakuAST::Call::Name, '$!name').IMPL-QAST-PACKAGE-LOOKUP(
                        $context,
                        nqp::getattr($SELF, RakuAST::Call::Name, '$!package'),
                        :lexical($SELF.resolution)
                    )
                    !! nqp::getattr($SELF, RakuAST::Call::Name, '$!name').IMPL-QAST-PACKAGE-LOOKUP(
                        $context,
                        nqp::getattr($SELF, RakuAST::Call::Name, '$!package')
                    );
            }
            elsif nqp::getattr($SELF, RakuAST::Call::Name, '$!name').is-indirect-lookup {
                return nqp::getattr($SELF, RakuAST::Call::Name, '$!name').IMPL-QAST-INDIRECT-LOOKUP($context);
            }
            else {
                $call.push(
                    $SELF.is-resolved
                        ?? $SELF.resolution.IMPL-LOOKUP-QAST($context)
                        !! nqp::getattr($SELF, RakuAST::Call::Name, '$!name').IMPL-QAST-PACKAGE-LOOKUP(
                            $context,
                            nqp::getattr($SELF, RakuAST::Call::Name, '$!package'),
                            :sigil<&>,
                            :global-fallback,
                        )
                );
            }
        }
        $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
        $call
    
    });
    add-method(RakuAST::Call::Name, 'IMPL-CAN-INTERPRET', [RakuAST::Call::Name, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 298 src/Raku/ast/call.rakumod
        
        (
            (my $op := nqp::getattr($SELF, RakuAST::Call::Name, '$!name').IMPL-IS-NQP-OP) && ($op eq 'hash' || $op eq 'list_s' || $op eq 'atpos_s')
            || nqp::getattr($SELF, RakuAST::Call::Name, '$!name').is-identifier && $SELF.is-resolved
                && nqp::istype($SELF.resolution, RakuAST::CompileTimeValue)
        )
        && $SELF.args.IMPL-CAN-INTERPRET
    
    });
    add-method(RakuAST::Call::Name, 'IMPL-INTERPRET', [RakuAST::Call::Name, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 307 src/Raku/ast/call.rakumod
        
        my $op := nqp::getattr($SELF, RakuAST::Call::Name, '$!name').IMPL-IS-NQP-OP;
        if $op eq 'hash' {
            my @args := $SELF.args.IMPL-INTERPRET($ctx)[0];
            my $result := nqp::hash;
            while @args {
                my $key := nqp::shift(@args);
                my $val := nqp::shift(@args);
                $result{$key} := $val;
            }
            $result
        }
        elsif $op eq 'list_s' {
            my @args := $SELF.args.IMPL-INTERPRET($ctx)[0];
            my $result := nqp::list_s;
            for @args {
                nqp::push_s($result, $_);
            }
            $result
        }
        elsif $op eq 'atpos_s' {
            my @args := $SELF.args.IMPL-INTERPRET($ctx)[0];
            nqp::atpos_s(@args[0], @args[1]);
        }
        else {
            my $resolved := $SELF.resolution.compile-time-value;
            my @args := $SELF.args.IMPL-INTERPRET($ctx);
            my @pos := @args[0];
            my %named := @args[1];
            $resolved(|@pos, |%named);
        }
    
    });
#line 211 src/Raku/ast/call.rakumod
    add-method(RakuAST::Call::Name, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Call::Name, '$!name') });
    compose(RakuAST::Call::Name);
    parent(RakuAST::Call::Name::WithoutParentheses, RakuAST::Call::Name);
    compose(RakuAST::Call::Name::WithoutParentheses);
    parent(RakuAST::Call::Term, RakuAST::Call);
    parent(RakuAST::Call::Term, RakuAST::Postfixish);
    add-method(RakuAST::Call::Term, 'new', [RakuAST::Call::Term, '', 0, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $args := nqp::decont($args);
#line 350 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Call, '$!args', $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Call::Term, 'visit-children', [RakuAST::Call::Term, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 356 src/Raku/ast/call.rakumod
        
        $visitor($SELF.args);
    
    });
    add-method(RakuAST::Call::Term, 'default-operator-properties', [RakuAST::Call::Term, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 360 src/Raku/ast/call.rakumod
        
        OperatorProperties.postfix('()')
    
    });
    add-method(RakuAST::Call::Term, 'IMPL-POSTFIX-QAST', [RakuAST::Call::Term, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$callee-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $callee-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $callee-qast := nqp::decont($callee-qast);
#line 364 src/Raku/ast/call.rakumod
        
        my $call := QAST::Op.new( :op('call'), $callee-qast );
        $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
        $call
    
    });
    add-method(RakuAST::Call::Term, 'IMPL-CAN-INTERPRET', [RakuAST::Call::Term, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 370 src/Raku/ast/call.rakumod
        
        $SELF.args.IMPL-CAN-INTERPRET
    
    });
    add-method(RakuAST::Call::Term, 'IMPL-INTERPRET', [RakuAST::Call::Term, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0, Code, '$operand', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!, $operand!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
        $operand := nqp::decont($operand);
#line 374 src/Raku/ast/call.rakumod
        
        my $code := $operand();
        my @args := $SELF.args.IMPL-INTERPRET($ctx);
        my @pos := @args[0];
        my %named := @args[1];
        $code(|@pos, |%named)
    
    });
    compose(RakuAST::Call::Term);
    parent(RakuAST::Call::Methodish, RakuAST::Call);
    parent(RakuAST::Call::Methodish, RakuAST::Postfixish);
    add-method(RakuAST::Call::Methodish, 'IMPL-CURRIES', [RakuAST::Call::Methodish, '', 0, 0], anon sub IMPL-CURRIES ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 388 src/Raku/ast/call.rakumod
         3 
    });
    compose(RakuAST::Call::Methodish);
    parent(RakuAST::Call::Method, RakuAST::Call::Methodish);
    parent(RakuAST::Call::Method, RakuAST::CheckTime);
    parent(RakuAST::Call::Method, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Call::Method, RakuAST::Name, '$!name');
    add-method(RakuAST::Call::Method, 'new', [RakuAST::Call::Method, '', 0, 0, RakuAST::Name, '$name', 1, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$name!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $args := nqp::decont($args);
#line 400 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Call::Method, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Call, '$!args', $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Call::Method, 'visit-children', [RakuAST::Call::Method, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 407 src/Raku/ast/call.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Call::Method, '$!name'));
        $visitor($SELF.args);
    
    });
    add-method(RakuAST::Call::Method, 'default-operator-properties', [RakuAST::Call::Method, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 412 src/Raku/ast/call.rakumod
        
        OperatorProperties.postfix('.')
    
    });
    add-method(RakuAST::Call::Method, 'macroish', [RakuAST::Call::Method, '', 0, 0], anon sub macroish ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 416 src/Raku/ast/call.rakumod
        
        nqp::getattr($SELF, RakuAST::Call::Method, '$!name').is-identifier
          && (my $name := nqp::getattr($SELF, RakuAST::Call::Method, '$!name').canonicalize)
          && nqp::istrue($SELF.IMPL-SPECIAL-OP($name))
    
    });
    add-method(RakuAST::Call::Method, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Call::Method, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 422 src/Raku/ast/call.rakumod
        
        my $name := nqp::getattr($SELF, RakuAST::Call::Method, '$!name').canonicalize;
        my @lookups := [];
        if $name {
            my @parts := nqp::split('::', $name);
            if nqp::elems(@parts) > 1 {
                @parts.pop;
                @lookups.push: # joining @parts with '::' gives use the qualifying type of the name
                    RakuAST::Type::Simple.new: RakuAST::Name.from-identifier: nqp::join('::', @parts);
            }
        }
        $SELF.IMPL-WRAP-LIST(@lookups)
    
    });
    add-method(RakuAST::Call::Method, 'IMPL-SPECIAL-OP', [RakuAST::Call::Method, '', 0, 0, str, '$name', 0, 0], anon sub IMPL-SPECIAL-OP ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 436 src/Raku/ast/call.rakumod
        
        my constant SPECIAL-OPS := nqp::hash(
            'WHAT',     'what',
            'HOW',      'how',
            'WHO',      'who',
            'VAR',      'p6var',
            'REPR',     'p6reprname',
            'DEFINITE', 'p6definite',
        );
        SPECIAL-OPS{$name}
    
    });
    add-method(RakuAST::Call::Method, 'IMPL-POSTFIX-QAST', [RakuAST::Call::Method, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $invocant-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 448 src/Raku/ast/call.rakumod
        
        my $name := nqp::getattr($SELF, RakuAST::Call::Method, '$!name').canonicalize;
        if $name {
            my @parts := nqp::split('::', $name);
            if nqp::elems(@parts) == 1 {
                my $op := $SELF.IMPL-SPECIAL-OP($name);
                if $op {
                    # Not really a method call, just using that syntax.
                    QAST::Op.new(:$op, $invocant-qast)
                }
                else {
                    # A standard method call.
                    my $call := QAST::Op.new(:op('callmethod'), :$name, $invocant-qast);
                    $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
                    $call
                }
            } else {
                # TODO: In base behavior, the attempt to dispatch is performed before determining whether the type
                #       actually exists in this scope (throwing a X::Method::InvalidQualifier).
                #       The resolution below will die if the type object cannot be found, deviating from base.
                my $Qualified := $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
                $context.ensure-sc($Qualified);
                $name := @parts[ nqp::elems(@parts)-1 ];
                my $call := QAST::Op.new(:op('callmethod'), :name('dispatch:<::>'), $invocant-qast,  QAST::SVal.new(:value($name)), QAST::WVal.new(:value($Qualified)));
                $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
                $call
            }
        }
        else {
            nqp::die('Qualified method calls NYI');
        }
    
    });
    add-method(RakuAST::Call::Method, 'can-be-used-with-hyper', [RakuAST::Call::Method, '', 0, 0], anon sub can-be-used-with-hyper ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 481 src/Raku/ast/call.rakumod
         !$SELF.macroish 
    });
    add-method(RakuAST::Call::Method, 'IMPL-POSTFIX-HYPER-QAST', [RakuAST::Call::Method, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-HYPER-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 483 src/Raku/ast/call.rakumod
        
        # TODO later expand this to the qualified case
        my $name := nqp::getattr($SELF, RakuAST::Call::Method, '$!name').canonicalize;
        my $call := QAST::Op.new:
            :op('callmethod'), :name('dispatch:<hyper>'),
            $operand-qast,
            QAST::SVal.new( :value('') ),
            QAST::SVal.new( :value($name) );
        $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
        $call
    
    });
    add-method(RakuAST::Call::Method, 'IMPL-CAN-INTERPRET', [RakuAST::Call::Method, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 495 src/Raku/ast/call.rakumod
         nqp::getattr($SELF, RakuAST::Call::Method, '$!name').is-identifier && $SELF.args.IMPL-CAN-INTERPRET 
    });
    add-method(RakuAST::Call::Method, 'IMPL-INTERPRET', [RakuAST::Call::Method, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0, Mu, '$invocant-compiler', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!, $invocant-compiler!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
        $invocant-compiler := nqp::decont($invocant-compiler);
#line 497 src/Raku/ast/call.rakumod
        
        my $invocant := $invocant-compiler();
        my $name := nqp::getattr($SELF, RakuAST::Call::Method, '$!name').canonicalize;
        if $name eq 'WHAT' {
            $invocant.WHAT
        }
        elsif $name eq 'HOW' {
            $invocant.HOW
        }
        elsif $name eq 'WHO' {
            $invocant.WHO
        }
        elsif $name eq 'VAR' {
            my $var := nqp::create(Scalar);
            nqp::bindattr_s($var, Scalar, '$!value', $invocant);
            $var
        }
        elsif $name eq 'REPR' {
            nqp::box_s(nqp::reprname($invocant), Str)
        }
        elsif $name eq 'DEFINITE' {
            nqp::isconcrete($invocant) ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
        }
        else {
            my @args := $SELF.args.IMPL-INTERPRET($ctx);
            my @pos := @args[0];
            my %named := @args[1];
            $invocant."$name"(|@pos, |%named)
        }
    
    });
    add-method(RakuAST::Call::Method, 'PERFORM-CHECK', [RakuAST::Call::Method, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 531 src/Raku/ast/call.rakumod
        
        if $SELF.macroish && $SELF.args.has-args {
            $SELF.add-sorry:
              $resolver.build-exception: 'X::Syntax::Argument::MOPMacro',
                macro => nqp::getattr($SELF, RakuAST::Call::Method, '$!name').canonicalize;
        }
    
    });
#line 398 src/Raku/ast/call.rakumod
    add-method(RakuAST::Call::Method, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Call::Method, '$!name') });
    compose(RakuAST::Call::Method);
    parent(RakuAST::Call::QuotedMethod, RakuAST::Call::Methodish);
    add-attribute(RakuAST::Call::QuotedMethod, RakuAST::QuotedString, '$!name');
    add-method(RakuAST::Call::QuotedMethod, 'new', [RakuAST::Call::QuotedMethod, '', 0, 0, RakuAST::QuotedString, '$name', 1, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$name!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $args := nqp::decont($args);
#line 546 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Call::QuotedMethod, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Call, '$!args', $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Call::QuotedMethod, 'visit-children', [RakuAST::Call::QuotedMethod, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 553 src/Raku/ast/call.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Call::QuotedMethod, '$!name'));
        $visitor($SELF.args);
    
    });
    add-method(RakuAST::Call::QuotedMethod, 'default-operator-properties', [RakuAST::Call::QuotedMethod, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 558 src/Raku/ast/call.rakumod
        
        OperatorProperties.postfix('.')
    
    });
    add-method(RakuAST::Call::QuotedMethod, 'IMPL-POSTFIX-QAST', [RakuAST::Call::QuotedMethod, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $invocant-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 562 src/Raku/ast/call.rakumod
        
        my $name-qast := QAST::Op.new( :op<unbox_s>, nqp::getattr($SELF, RakuAST::Call::QuotedMethod, '$!name').IMPL-TO-QAST($context) );
        my $call := QAST::Op.new( :op('callmethod'), $invocant-qast, $name-qast );
        $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
        $call
    
    });
#line 544 src/Raku/ast/call.rakumod
    add-method(RakuAST::Call::QuotedMethod, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Call::QuotedMethod, '$!name') });
    compose(RakuAST::Call::QuotedMethod);
    parent(RakuAST::Call::PrivateMethod, RakuAST::Call::Methodish);
    parent(RakuAST::Call::PrivateMethod, RakuAST::Lookup);
    parent(RakuAST::Call::PrivateMethod, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Call::PrivateMethod, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Call::PrivateMethod, Mu, '$!package');
    add-method(RakuAST::Call::PrivateMethod, 'new', [RakuAST::Call::PrivateMethod, '', 0, 0, RakuAST::Name, '$name', 1, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$name!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $args := nqp::decont($args);
#line 579 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Call::PrivateMethod, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Call, '$!args', $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Call::PrivateMethod, 'visit-children', [RakuAST::Call::PrivateMethod, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 586 src/Raku/ast/call.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Call::PrivateMethod, '$!name'));
        $visitor($SELF.args);
    
    });
    add-method(RakuAST::Call::PrivateMethod, 'default-operator-properties', [RakuAST::Call::PrivateMethod, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 591 src/Raku/ast/call.rakumod
        
        OperatorProperties.postfix('!')
    
    });
    add-method(RakuAST::Call::PrivateMethod, 'needs-resolution', [RakuAST::Call::PrivateMethod, '', 0, 0], anon sub needs-resolution ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 595 src/Raku/ast/call.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Call::PrivateMethod, 'resolve-with', [RakuAST::Call::PrivateMethod, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 597 src/Raku/ast/call.rakumod
        
        nqp::bindattr($SELF, RakuAST::Call::PrivateMethod, '$!package', $resolver.current-package);
        Nil
    
    });
    add-method(RakuAST::Call::PrivateMethod, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Call::PrivateMethod, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 602 src/Raku/ast/call.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical::Constant.new('::?CLASS'),
        ]);
    
    });
    add-method(RakuAST::Call::PrivateMethod, 'IMPL-POSTFIX-QAST', [RakuAST::Call::PrivateMethod, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $invocant-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 608 src/Raku/ast/call.rakumod
        
        if nqp::getattr($SELF, RakuAST::Call::PrivateMethod, '$!name').is-identifier {
            my $name := $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Call::PrivateMethod, '$!name').parts)[0].name;
            my $call := QAST::Op.new(
                :op('callmethod'),
                :name('dispatch:<!>'),
                $invocant-qast,
                RakuAST::StrLiteral.new($name).IMPL-EXPR-QAST($context),
                nqp::getattr($SELF, RakuAST::Call::PrivateMethod, '$!package').HOW.archetypes.parametric
                  ?? $SELF.get-implicit-lookups.AT-POS(0).IMPL-EXPR-QAST($context)
                  !! QAST::WVal.new(:value(nqp::getattr($SELF, RakuAST::Call::PrivateMethod, '$!package'))),
            );
            $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
            $call
        }
        else {
            nqp::die('Qualified private method calls NYI');
        }
    
    });
#line 576 src/Raku/ast/call.rakumod
    add-method(RakuAST::Call::PrivateMethod, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Call::PrivateMethod, '$!name') });
    compose(RakuAST::Call::PrivateMethod);
    parent(RakuAST::Call::MetaMethod, RakuAST::Call::Methodish);
    add-attribute(RakuAST::Call::MetaMethod, str, '$!name');
    add-method(RakuAST::Call::MetaMethod, 'new', [RakuAST::Call::MetaMethod, '', 0, 0, str, '$name', 1, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$name!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $args := nqp::decont($args);
#line 635 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Call::MetaMethod, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Call, '$!args', $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Call::MetaMethod, 'visit-children', [RakuAST::Call::MetaMethod, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 642 src/Raku/ast/call.rakumod
        
        $visitor($SELF.args);
    
    });
    add-method(RakuAST::Call::MetaMethod, 'default-operator-properties', [RakuAST::Call::MetaMethod, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 646 src/Raku/ast/call.rakumod
        
        OperatorProperties.postfix('.^')
    
    });
    add-method(RakuAST::Call::MetaMethod, 'IMPL-POSTFIX-QAST', [RakuAST::Call::MetaMethod, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $invocant-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 650 src/Raku/ast/call.rakumod
        
        my $call := QAST::Op.new( :op('p6callmethodhow'), :name(nqp::getattr_s($SELF, RakuAST::Call::MetaMethod, '$!name')), $invocant-qast );
        $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
        $call
    
    });
#line 633 src/Raku/ast/call.rakumod
    add-method(RakuAST::Call::MetaMethod, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Call::MetaMethod, '$!name') });
    compose(RakuAST::Call::MetaMethod);
    parent(RakuAST::Call::MaybeMethod, RakuAST::Call::Methodish);
    add-attribute(RakuAST::Call::MaybeMethod, str, '$!name');
    add-method(RakuAST::Call::MaybeMethod, 'new', [RakuAST::Call::MaybeMethod, '', 0, 0, str, '$name', 1, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$name!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $args := nqp::decont($args);
#line 663 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Call::MaybeMethod, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Call, '$!args', $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Call::MaybeMethod, 'visit-children', [RakuAST::Call::MaybeMethod, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 670 src/Raku/ast/call.rakumod
        
        $visitor($SELF.args);
    
    });
    add-method(RakuAST::Call::MaybeMethod, 'default-operator-properties', [RakuAST::Call::MaybeMethod, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 674 src/Raku/ast/call.rakumod
        
        OperatorProperties.postfix('.?')
    
    });
    add-method(RakuAST::Call::MaybeMethod, 'IMPL-POSTFIX-QAST', [RakuAST::Call::MaybeMethod, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $invocant-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 678 src/Raku/ast/call.rakumod
        
        my $call := QAST::Op.new(
            :op('callmethod'),
            :name('dispatch:<.?>'),
            $invocant-qast,
            QAST::SVal.new(:value(nqp::getattr_s($SELF, RakuAST::Call::MaybeMethod, '$!name')))
        );
        $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
        $call
    
    });
#line 661 src/Raku/ast/call.rakumod
    add-method(RakuAST::Call::MaybeMethod, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Call::MaybeMethod, '$!name') });
    compose(RakuAST::Call::MaybeMethod);
    parent(RakuAST::Call::VarMethod, RakuAST::Call::Methodish);
    parent(RakuAST::Call::VarMethod, RakuAST::Lookup);
    add-attribute(RakuAST::Call::VarMethod, RakuAST::Name, '$!name');
    add-method(RakuAST::Call::VarMethod, 'new', [RakuAST::Call::VarMethod, '', 0, 0, RakuAST::Name, '$name', 1, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$name!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $args := nqp::decont($args);
#line 696 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Call::VarMethod, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Call, '$!args', $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Call::VarMethod, 'can-be-used-with-hyper', [RakuAST::Call::VarMethod, '', 0, 0], anon sub can-be-used-with-hyper ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 703 src/Raku/ast/call.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Call::VarMethod, 'visit-children', [RakuAST::Call::VarMethod, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 705 src/Raku/ast/call.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Call::VarMethod, '$!name'));
        $visitor($SELF.args);
    
    });
    add-method(RakuAST::Call::VarMethod, 'default-operator-properties', [RakuAST::Call::VarMethod, '', 0, 0], anon sub default-operator-properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 710 src/Raku/ast/call.rakumod
        
        OperatorProperties.postfix('.&')
    
    });
    add-method(RakuAST::Call::VarMethod, 'needs-resolution', [RakuAST::Call::VarMethod, '', 0, 0], anon sub needs-resolution ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 714 src/Raku/ast/call.rakumod
         nqp::getattr($SELF, RakuAST::Call::VarMethod, '$!name').is-identifier 
    });
    add-method(RakuAST::Call::VarMethod, 'resolve-with', [RakuAST::Call::VarMethod, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 716 src/Raku/ast/call.rakumod
        
        my $resolved := $resolver.resolve-name(nqp::getattr($SELF, RakuAST::Call::VarMethod, '$!name'), :sigil('&'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Call::VarMethod, 'undeclared-symbol-details', [RakuAST::Call::VarMethod, '', 0, 0], anon sub undeclared-symbol-details ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 724 src/Raku/ast/call.rakumod
        
        RakuAST::UndeclaredSymbolDescription::Routine.new(nqp::getattr($SELF, RakuAST::Call::VarMethod, '$!name').canonicalize())
    
    });
    add-method(RakuAST::Call::VarMethod, 'IMPL-POSTFIX-QAST', [RakuAST::Call::VarMethod, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 0, 0], anon sub IMPL-POSTFIX-QAST ($SELF_CONT, $context!, $invocant-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 728 src/Raku/ast/call.rakumod
        
        my $call := QAST::Op.new(:op<call>, $invocant-qast);
        if nqp::getattr($SELF, RakuAST::Call::VarMethod, '$!name').is-identifier {
            $call.name($SELF.resolution.lexical-name);
        }
        else {
            nqp::die('compiling complex call names NYI')
        }
        $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
        $call
    
    });
    add-method(RakuAST::Call::VarMethod, 'IMPL-POSTFIX-HYPER-QAST', [RakuAST::Call::VarMethod, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$operand-qast', 0, 0], anon sub IMPL-POSTFIX-HYPER-QAST ($SELF_CONT, $context!, $operand-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $operand-qast := nqp::decont($operand-qast);
#line 740 src/Raku/ast/call.rakumod
        
        my $name := nqp::getattr($SELF, RakuAST::Call::VarMethod, '$!name').canonicalize;
        my $call := QAST::Op.new:
            :op('callmethod'), :name('dispatch:<hyper>'),
            $operand-qast,
            $SELF.resolution.IMPL-LOOKUP-QAST($context),
            QAST::SVal.new( :value('dispatch:<var>') ),
            $SELF.resolution.IMPL-LOOKUP-QAST($context);
        $SELF.args.IMPL-ADD-QAST-ARGS($context, $call);
        $call
    
    });
#line 694 src/Raku/ast/call.rakumod
    add-method(RakuAST::Call::VarMethod, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Call::VarMethod, '$!name') });
    compose(RakuAST::Call::VarMethod);
    parent(RakuAST::Stub, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Stub, RakuAST::ArgList, '$!args');
    add-method(RakuAST::Stub, 'new', [RakuAST::Stub, '', 0, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $args := nqp::decont($args);
#line 759 src/Raku/ast/call.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Stub, '$!args', $args);
        $obj
    
    });
    add-method(RakuAST::Stub, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Stub, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 765 src/Raku/ast/call.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Simple.new(
              RakuAST::Name.from-identifier-parts('X','StubCode')
            )
        ])
    
    });
    add-method(RakuAST::Stub, 'IMPL-TO-QAST', [RakuAST::Stub, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 773 src/Raku/ast/call.rakumod
        
        my $qast := QAST::Op.new(
          :op<callmethod>, :name<new>,
          $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context)
        );
        if nqp::getattr($SELF, RakuAST::Stub, '$!args') {
            my @args := $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Stub, '$!args').args);
            if nqp::elems(@args) {
                my $value := @args[0].IMPL-EXPR-QAST($context);
                $value.named("message");
                nqp::push($qast, $value);
            }
        }

        QAST::Op.new(
          :op<callstatic>, :name('&' ~ $SELF.IMPL-FUNC-NAME),
          $qast
        )
    
    });
#line 757 src/Raku/ast/call.rakumod
    add-method(RakuAST::Stub, 'args', [], anon sub args ($self) { nqp::getattr(nqp::decont($self), RakuAST::Stub, '$!args') });
    compose(RakuAST::Stub);
    parent(RakuAST::Stub::Fail, RakuAST::Stub);
    add-method(RakuAST::Stub::Fail, 'name', [RakuAST::Stub::Fail, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 798 src/Raku/ast/call.rakumod
         '...' 
    });
    add-method(RakuAST::Stub::Fail, 'IMPL-FUNC-NAME', [RakuAST::Stub::Fail, '', 0, 0], anon sub IMPL-FUNC-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 799 src/Raku/ast/call.rakumod
         'fail' 
    });
    compose(RakuAST::Stub::Fail);
    parent(RakuAST::Stub::Warn, RakuAST::Stub);
    add-method(RakuAST::Stub::Warn, 'name', [RakuAST::Stub::Warn, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 806 src/Raku/ast/call.rakumod
         '???' 
    });
    add-method(RakuAST::Stub::Warn, 'IMPL-FUNC-NAME', [RakuAST::Stub::Warn, '', 0, 0], anon sub IMPL-FUNC-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 807 src/Raku/ast/call.rakumod
         'warn' 
    });
    compose(RakuAST::Stub::Warn);
    parent(RakuAST::Stub::Die, RakuAST::Stub);
    add-method(RakuAST::Stub::Die, 'name', [RakuAST::Stub::Die, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 814 src/Raku/ast/call.rakumod
         '!!!' 
    });
    add-method(RakuAST::Stub::Die, 'IMPL-FUNC-NAME', [RakuAST::Stub::Die, '', 0, 0], anon sub IMPL-FUNC-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 815 src/Raku/ast/call.rakumod
         'die' 
    });
    compose(RakuAST::Stub::Die);
    parent(RakuAST::Nqp, RakuAST::Expression);
    add-attribute(RakuAST::Nqp, Str, '$!op');
    add-attribute(RakuAST::Nqp, RakuAST::ArgList, '$!args');
    add-method(RakuAST::Nqp, 'new', [RakuAST::Nqp, '', 0, 0, Str, '$op', 0, 0, Any, '@args', 0, 0], anon sub new ($SELF_CONT, $op!, *@args) {
        my $SELF := nqp::decont($SELF_CONT);
        $op := nqp::decont($op);
        @args := nqp::decont(@args);
#line 8 src/Raku/ast/nqp.rakumod
        
        nqp::die('RakuAST::Nqp does not support nqp::const.  Use RakuAST::Nqp::Const')
          if $op eq 'const';

        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Nqp, '$!op', $op);

        my $args;
        if nqp::elems(@args) == 1 {
            my $it := @args[0];
            if nqp::istype($it, RakuAST::ArgList) {
                nqp::bindattr($obj, RakuAST::Nqp, '$!args', $it);
                $args := nqp::getattr(@args[0], RakuAST::ArgList, '$!args');
            }
            elsif nqp::istype($it, List) {
                $it.elems;  # reify
                $obj.set-args($args := nqp::getattr($it, List, '$!reified'));
            }
            else {
                $obj.set-args($args := @args);
            }
        }
        else {
            $obj.set-args($args := @args);
        }

        # We want to make use of nqp ops as simple as possible, so
        # we automatically convert common types to their RakuAST
        # equivalents.
        my int $i := 0;
        my int $n := nqp::elems($args);
        while $i < $n {
            my $arg := $args[$i];
            if nqp::istype($arg,Str) {
                $args[$i] := RakuAST::StrLiteral.new($arg);
            }
            elsif nqp::istype($arg,Int) {
                $args[$i] := RakuAST::IntLiteral.new($arg);
            }
            ++$i;
        }

        $obj
    
    });
    add-method(RakuAST::Nqp, 'set-args', [RakuAST::Nqp, '', 0, 0, Any, '$args', 0, 0], anon sub set-args ($SELF_CONT, $args!) {
        my $SELF := nqp::decont($SELF_CONT);
        $args := nqp::decont($args);
#line 53 src/Raku/ast/nqp.rakumod
        
        my $arglist := nqp::create(RakuAST::ArgList);
        nqp::bindattr($arglist, RakuAST::ArgList, '$!args', $args);
        nqp::bindattr($SELF, RakuAST::Nqp, '$!args', $arglist);
    
    });
    add-method(RakuAST::Nqp, 'visit-children', [RakuAST::Nqp, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 59 src/Raku/ast/nqp.rakumod
        
        my @args := nqp::getattr($SELF.args, RakuAST::ArgList, '$!args');
        for @args {
            $visitor($_);
        }
    
    });
    add-method(RakuAST::Nqp, 'IMPL-EXPR-QAST', [RakuAST::Nqp, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 66 src/Raku/ast/nqp.rakumod
        
        my $call := QAST::Op.new(:op(nqp::getattr($SELF, RakuAST::Nqp, '$!op')));
        nqp::getattr($SELF, RakuAST::Nqp, '$!args').IMPL-ADD-QAST-ARGS($context, $call);

        # We generally want to send unboxed string/int values in for dispatch
        # arguments (although leave normal ones alone); we can't really
        # know which are which, but if we're writing out an `nqp::op`
        # just assume that they should all be unboxed; most situations
        # will see the dispatch op generated anyway.
        my int $i := 0;
        my int $n := nqp::elems($call.list);
        while $i < $n {
            my $arg := $call[$i];
            if nqp::istype($arg, QAST::Want)
              && ($arg[1] eq 'Ss' || $arg[1] eq 'Ii') {
                $call[$i] := $arg[2];
            }
            $i++;
        }
        $call
    
    });
#line 5 src/Raku/ast/nqp.rakumod
    add-method(RakuAST::Nqp, 'op', [], anon sub op ($self) { nqp::getattr(nqp::decont($self), RakuAST::Nqp, '$!op') });
#line 6 src/Raku/ast/nqp.rakumod
    add-method(RakuAST::Nqp, 'args', [], anon sub args ($self) { nqp::getattr(nqp::decont($self), RakuAST::Nqp, '$!args') });
    compose(RakuAST::Nqp);
    parent(RakuAST::Nqp::Const, RakuAST::Expression);
    add-attribute(RakuAST::Nqp::Const, Str, '$!name');
    add-method(RakuAST::Nqp::Const, 'new', [RakuAST::Nqp::Const, '', 0, 0, Str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 94 src/Raku/ast/nqp.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Nqp::Const, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Nqp::Const, 'IMPL-EXPR-QAST', [RakuAST::Nqp::Const, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 100 src/Raku/ast/nqp.rakumod
        
        QAST::Op.new(:op<const>, :name(nqp::getattr($SELF, RakuAST::Nqp::Const, '$!name')));
    
    });
#line 92 src/Raku/ast/nqp.rakumod
    add-method(RakuAST::Nqp::Const, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Nqp::Const, '$!name') });
    compose(RakuAST::Nqp::Const);
    parent(RakuAST::Term::Name, RakuAST::Term);
    parent(RakuAST::Term::Name, RakuAST::Lookup);
    add-attribute(RakuAST::Term::Name, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Term::Name, Mu, '$!package');
    add-method(RakuAST::Term::Name, 'new', [RakuAST::Term::Name, '', 0, 0, RakuAST::Name, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 11 src/Raku/ast/term.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Term::Name, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Term::Name, 'attach', [RakuAST::Term::Name, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 17 src/Raku/ast/term.rakumod
        
        my $package := $resolver.find-attach-target('package');
        nqp::bindattr($SELF, RakuAST::Term::Name, '$!package', $package);
    
    });
    add-method(RakuAST::Term::Name, 'resolve-with', [RakuAST::Term::Name, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 22 src/Raku/ast/term.rakumod
        
        my $resolved := $resolver.resolve-name(nqp::getattr($SELF, RakuAST::Term::Name, '$!name'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        elsif nqp::getattr($SELF, RakuAST::Term::Name, '$!name').is-package-lookup {
            my $name := nqp::getattr($SELF, RakuAST::Term::Name, '$!name').base-name;
            if $name.canonicalize {
                $resolved := $resolver.resolve-name($name);
                if $resolved {
                    my $v := $resolved.compile-time-value;
                    $SELF.set-resolution($resolved);
                }
            }
        }
        Nil
    
    });
    add-method(RakuAST::Term::Name, 'IMPL-EXPR-QAST', [RakuAST::Term::Name, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 40 src/Raku/ast/term.rakumod
        
        if nqp::getattr($SELF, RakuAST::Term::Name, '$!name').is-pseudo-package {
            nqp::getattr($SELF, RakuAST::Term::Name, '$!name').IMPL-QAST-PSEUDO-PACKAGE-LOOKUP($context);
        }
        elsif nqp::getattr($SELF, RakuAST::Term::Name, '$!name').is-package-lookup {
            return $SELF.is-resolved
                ?? nqp::getattr($SELF, RakuAST::Term::Name, '$!name').IMPL-QAST-PACKAGE-LOOKUP(
                    $context,
                    nqp::getattr($SELF, RakuAST::Term::Name, '$!package'),
                    :lexical($SELF.resolution)
                )
                !! nqp::getattr($SELF, RakuAST::Term::Name, '$!name').IMPL-QAST-PACKAGE-LOOKUP(
                    $context,
                    nqp::getattr($SELF, RakuAST::Term::Name, '$!package')
                );
        }
        elsif nqp::getattr($SELF, RakuAST::Term::Name, '$!name').is-indirect-lookup {
            return nqp::getattr($SELF, RakuAST::Term::Name, '$!name').IMPL-QAST-INDIRECT-LOOKUP($context);
        }
        else {
            $SELF.resolution.IMPL-LOOKUP-QAST($context)
        }
    
    });
    add-method(RakuAST::Term::Name, 'visit-children', [RakuAST::Term::Name, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 64 src/Raku/ast/term.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Term::Name, '$!name'));
    
    });
#line 8 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::Name, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::Name, '$!name') });
    compose(RakuAST::Term::Name);
    parent(RakuAST::Term::True, Any);
    add-method(RakuAST::Term::True, 'new', [RakuAST::Term::True, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 71 src/Raku/ast/term.rakumod
        
        RakuAST::Term::Name.new(RakuAST::Name.from-identifier("True"))
    
    });
    compose(RakuAST::Term::True);
    parent(RakuAST::Term::False, Any);
    add-method(RakuAST::Term::False, 'new', [RakuAST::Term::False, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 78 src/Raku/ast/term.rakumod
        
        RakuAST::Term::Name.new(RakuAST::Name.from-identifier("False"))
    
    });
    compose(RakuAST::Term::False);
    parent(RakuAST::Term::Self, RakuAST::Term);
    parent(RakuAST::Term::Self, RakuAST::Lookup);
    parent(RakuAST::Term::Self, RakuAST::CheckTime);
    add-method(RakuAST::Term::Self, 'new', [RakuAST::Term::Self, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 89 src/Raku/ast/term.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Term::Self, 'resolve-with', [RakuAST::Term::Self, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 93 src/Raku/ast/term.rakumod
        
        my $resolved := $resolver.resolve-lexical('self');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Term::Self, 'PERFORM-CHECK', [RakuAST::Term::Self, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 101 src/Raku/ast/term.rakumod
        
        unless $SELF.is-resolved {
            $SELF.add-sorry:
              $resolver.build-exception: 'X::Syntax::Self::WithoutObject';
        }
    
    });
    add-method(RakuAST::Term::Self, 'IMPL-EXPR-QAST', [RakuAST::Term::Self, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 108 src/Raku/ast/term.rakumod
        
        $SELF.resolution.IMPL-LOOKUP-QAST($context)
    
    });
    compose(RakuAST::Term::Self);
    parent(RakuAST::Term::TopicCall, RakuAST::Term);
    parent(RakuAST::Term::TopicCall, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Term::TopicCall, RakuAST::Postfixish, '$!call');
    add-method(RakuAST::Term::TopicCall, 'new', [RakuAST::Term::TopicCall, '', 0, 0, RakuAST::Postfixish, '$call', 0, 0], anon sub new ($SELF_CONT, $call!) {
        my $SELF := nqp::decont($SELF_CONT);
        $call := nqp::decont($call);
#line 120 src/Raku/ast/term.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Term::TopicCall, '$!call', $call);
        $obj
    
    });
    add-method(RakuAST::Term::TopicCall, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Term::TopicCall, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 126 src/Raku/ast/term.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('$_'),
        ])
    
    });
    add-method(RakuAST::Term::TopicCall, 'IMPL-EXPR-QAST', [RakuAST::Term::TopicCall, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 132 src/Raku/ast/term.rakumod
        
        nqp::getattr($SELF, RakuAST::Term::TopicCall, '$!call').IMPL-POSTFIX-QAST(
          $context,
          $SELF.get-implicit-lookups.AT-POS(0).resolution.IMPL-LOOKUP-QAST($context)
        )
    
    });
    add-method(RakuAST::Term::TopicCall, 'visit-children', [RakuAST::Term::TopicCall, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 139 src/Raku/ast/term.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Term::TopicCall, '$!call'));
    
    });
#line 118 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::TopicCall, 'call', [], anon sub call ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::TopicCall, '$!call') });
    compose(RakuAST::Term::TopicCall);
    parent(RakuAST::Term::Named, RakuAST::Term);
    parent(RakuAST::Term::Named, RakuAST::Lookup);
    add-attribute(RakuAST::Term::Named, str, '$!name');
    add-method(RakuAST::Term::Named, 'new', [RakuAST::Term::Named, '', 0, 0, str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 151 src/Raku/ast/term.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Term::Named, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Term::Named, 'resolve-with', [RakuAST::Term::Named, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 157 src/Raku/ast/term.rakumod
        
        my $resolved := $resolver.resolve-term(nqp::getattr_s($SELF, RakuAST::Term::Named, '$!name'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Term::Named, 'IMPL-EXPR-QAST', [RakuAST::Term::Named, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 165 src/Raku/ast/term.rakumod
        
        QAST::Op.new( :op('call'), :name($SELF.resolution.lexical-name) )
    
    });
#line 149 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::Named, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Term::Named, '$!name') });
    compose(RakuAST::Term::Named);
    parent(RakuAST::Term::EmptySet, RakuAST::Term);
    parent(RakuAST::Term::EmptySet, RakuAST::Lookup);
    add-method(RakuAST::Term::EmptySet, 'new', [RakuAST::Term::EmptySet, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 175 src/Raku/ast/term.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Term::EmptySet, 'resolve-with', [RakuAST::Term::EmptySet, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 179 src/Raku/ast/term.rakumod
        
        my $resolved := $resolver.resolve-lexical('&set');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Term::EmptySet, 'IMPL-EXPR-QAST', [RakuAST::Term::EmptySet, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 187 src/Raku/ast/term.rakumod
        
        QAST::Op.new( :op('call'), :name($SELF.resolution.lexical-name) )
    
    });
    compose(RakuAST::Term::EmptySet);
    parent(RakuAST::Term::Rand, RakuAST::Term);
    parent(RakuAST::Term::Rand, RakuAST::Lookup);
    add-method(RakuAST::Term::Rand, 'new', [RakuAST::Term::Rand, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 197 src/Raku/ast/term.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Term::Rand, 'resolve-with', [RakuAST::Term::Rand, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 201 src/Raku/ast/term.rakumod
        
        my $resolved := $resolver.resolve-lexical('&rand');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Term::Rand, 'IMPL-EXPR-QAST', [RakuAST::Term::Rand, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 209 src/Raku/ast/term.rakumod
        
        QAST::Op.new( :op('call'), :name($SELF.resolution.lexical-name) )
    
    });
    compose(RakuAST::Term::Rand);
    parent(RakuAST::Term::Whatever, RakuAST::Term);
    parent(RakuAST::Term::Whatever, RakuAST::Attaching);
    add-attribute(RakuAST::Term::Whatever, RakuAST::CompUnit, '$!enclosing-comp-unit');
    add-method(RakuAST::Term::Whatever, 'new', [RakuAST::Term::Whatever, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 221 src/Raku/ast/term.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Term::Whatever, 'attach', [RakuAST::Term::Whatever, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 225 src/Raku/ast/term.rakumod
        
        my $compunit := $resolver.find-attach-target('compunit');
        $compunit.ensure-singleton-whatever($resolver);
        nqp::bindattr($SELF, RakuAST::Term::Whatever, '$!enclosing-comp-unit', $compunit);
    
    });
    add-method(RakuAST::Term::Whatever, 'IMPL-EXPR-QAST', [RakuAST::Term::Whatever, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 231 src/Raku/ast/term.rakumod
        
        my $whatever := nqp::getattr($SELF, RakuAST::Term::Whatever, '$!enclosing-comp-unit').singleton-whatever();
        $context.ensure-sc($whatever);
        QAST::WVal.new( :value($whatever), :returns($whatever) )
    
    });
    compose(RakuAST::Term::Whatever);
    parent(RakuAST::WhateverCode::Argument, RakuAST::Term);
    parent(RakuAST::WhateverCode::Argument, RakuAST::Lookup);
    add-attribute(RakuAST::WhateverCode::Argument, RakuAST::Name, '$!name');
    add-method(RakuAST::WhateverCode::Argument, 'new', [RakuAST::WhateverCode::Argument, '', 0, 0, RakuAST::Name, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 246 src/Raku/ast/term.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::WhateverCode::Argument, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::WhateverCode::Argument, 'resolve-with', [RakuAST::WhateverCode::Argument, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 252 src/Raku/ast/term.rakumod
        
        my $resolved := $resolver.resolve-name(nqp::getattr($SELF, RakuAST::WhateverCode::Argument, '$!name'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::WhateverCode::Argument, 'IMPL-EXPR-QAST', [RakuAST::WhateverCode::Argument, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 260 src/Raku/ast/term.rakumod
        
        $SELF.resolution.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::WhateverCode::Argument, 'dump-markers', [RakuAST::WhateverCode::Argument, '', 0, 0], anon sub dump-markers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 264 src/Raku/ast/term.rakumod
        
        '🔆'
    
    });
    compose(RakuAST::WhateverCode::Argument);
    parent(RakuAST::Term::HyperWhatever, RakuAST::Term);
    parent(RakuAST::Term::HyperWhatever, RakuAST::Attaching);
    add-attribute(RakuAST::Term::HyperWhatever, RakuAST::CompUnit, '$!enclosing-comp-unit');
    add-method(RakuAST::Term::HyperWhatever, 'new', [RakuAST::Term::HyperWhatever, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 276 src/Raku/ast/term.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Term::HyperWhatever, 'attach', [RakuAST::Term::HyperWhatever, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 280 src/Raku/ast/term.rakumod
        
        my $compunit := $resolver.find-attach-target('compunit');
        $compunit.ensure-singleton-hyper-whatever($resolver);
        nqp::bindattr($SELF, RakuAST::Term::HyperWhatever, '$!enclosing-comp-unit', $compunit);
    
    });
    add-method(RakuAST::Term::HyperWhatever, 'IMPL-EXPR-QAST', [RakuAST::Term::HyperWhatever, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 286 src/Raku/ast/term.rakumod
        
        my $whatever := nqp::getattr($SELF, RakuAST::Term::HyperWhatever, '$!enclosing-comp-unit').singleton-hyper-whatever();
        $context.ensure-sc($whatever);
        QAST::WVal.new( :value($whatever) )
    
    });
    compose(RakuAST::Term::HyperWhatever);
    parent(RakuAST::Term::Capture, RakuAST::Term);
    add-attribute(RakuAST::Term::Capture, RakuAST::CaptureSource, '$!source');
    add-method(RakuAST::Term::Capture, 'new', [RakuAST::Term::Capture, '', 0, 0, RakuAST::CaptureSource, '$source', 0, 0], anon sub new ($SELF_CONT, $source!) {
        my $SELF := nqp::decont($SELF_CONT);
        $source := nqp::decont($source);
#line 299 src/Raku/ast/term.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Term::Capture, '$!source', $source);
        $obj
    
    });
    add-method(RakuAST::Term::Capture, 'IMPL-EXPR-QAST', [RakuAST::Term::Capture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 305 src/Raku/ast/term.rakumod
        
        my $op := QAST::Op.new(
            :op('callmethod'),
            :name('from-args'),
            QAST::WVal.new( :value(Capture) ),
        );
        if nqp::istype(nqp::getattr($SELF, RakuAST::Term::Capture, '$!source'), RakuAST::ArgList) {
            nqp::getattr($SELF, RakuAST::Term::Capture, '$!source').IMPL-ADD-QAST-ARGS($context, $op);
        }
        else {
            $op.push(nqp::getattr($SELF, RakuAST::Term::Capture, '$!source').IMPL-TO-QAST($context));
        }
        $op
    
    });
    add-method(RakuAST::Term::Capture, 'visit-children', [RakuAST::Term::Capture, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 320 src/Raku/ast/term.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Term::Capture, '$!source'));
    
    });
#line 297 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::Capture, 'source', [], anon sub source ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::Capture, '$!source') });
    compose(RakuAST::Term::Capture);
    parent(RakuAST::Term::Reduce, RakuAST::Term);
    parent(RakuAST::Term::Reduce, RakuAST::CheckTime);
    parent(RakuAST::Term::Reduce, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Term::Reduce, RakuAST::Infixish, '$!infix');
    add-attribute(RakuAST::Term::Reduce, RakuAST::ArgList, '$!args');
    add-attribute(RakuAST::Term::Reduce, Bool, '$!triangle');
    add-method(RakuAST::Term::Reduce, 'new', [RakuAST::Term::Reduce, '', 0, 0, RakuAST::Infixish, '$infix', 1, 0, RakuAST::ArgList, '$args', 1, 0, Bool, '$triangle', 1, 1], anon sub new ($SELF_CONT, :$infix!, :$args!, :$triangle?) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
        $args := nqp::decont($args);
        $triangle := nqp::decont($triangle);
#line 335 src/Raku/ast/term.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Term::Reduce, '$!infix', $infix);
        nqp::bindattr($obj, RakuAST::Term::Reduce, '$!args', $args);
        nqp::bindattr($obj, RakuAST::Term::Reduce, '$!triangle', $triangle ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Term::Reduce, 'PERFORM-CHECK', [RakuAST::Term::Reduce, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 346 src/Raku/ast/term.rakumod
        
        (my $reason := $SELF.properties.not-reducable)
          ?? $SELF.add-sorry(
               $resolver.build-exception("X::Syntax::CannotMeta",
                 meta     => "reduce",
                 operator => $SELF.infix.operator,
                 dba      => $SELF.properties.dba,
                 reason   => $reason
               )
             )
          !! (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Term::Reduce, 'properties', [RakuAST::Term::Reduce, '', 0, 0], anon sub properties ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 359 src/Raku/ast/term.rakumod
         nqp::getattr($SELF, RakuAST::Term::Reduce, '$!infix').properties 
    });
    add-method(RakuAST::Term::Reduce, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Term::Reduce, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 361 src/Raku/ast/term.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('&infix:<,>'),
        ])
    
    });
    add-method(RakuAST::Term::Reduce, 'IMPL-EXPR-QAST', [RakuAST::Term::Reduce, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 367 src/Raku/ast/term.rakumod
        
        # Make a call to form the meta-op.
        # TODO Cache it using a dispatcher when UNIT/SETTING operator
        my $form-meta := QAST::Op.new(
            :op<call>, :name(nqp::getattr($SELF, RakuAST::Term::Reduce, '$!infix').reducer-name),
            nqp::getattr($SELF, RakuAST::Term::Reduce, '$!infix').IMPL-HOP-INFIX-QAST($context));
        if nqp::getattr($SELF, RakuAST::Term::Reduce, '$!triangle') {
            $form-meta.push(QAST::WVal.new( :value((Bool.WHO)<True>) ));
        }

        # Invoke it with the arguments.
        if nqp::getattr($SELF, RakuAST::Term::Reduce, '$!args').IMPL-IS-ONE-POS-ARG {
            # One-arg rule case, so just extract the argument
            my $arg := $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Term::Reduce, '$!args').args)[0];
            QAST::Op.new( :op<call>, $form-meta, $arg.IMPL-TO-QAST($context) )
        }
        else {
            # Form a List of the argumnets and pass it to the reducer
            # TODO thunk case
            my $name :=
              $SELF.get-implicit-lookups.AT-POS(0).resolution.lexical-name;
            my $form-list := QAST::Op.new(:op('call'), :$name);
            nqp::getattr($SELF, RakuAST::Term::Reduce, '$!args').IMPL-ADD-QAST-ARGS($context, $form-list);
            QAST::Op.new( :op<call>, $form-meta, $form-list )
        }
    
    });
    add-method(RakuAST::Term::Reduce, 'visit-children', [RakuAST::Term::Reduce, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 394 src/Raku/ast/term.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Term::Reduce, '$!infix'));
        $visitor(nqp::getattr($SELF, RakuAST::Term::Reduce, '$!args'));
    
    });
#line 333 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::Reduce, 'triangle', [], anon sub triangle ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::Reduce, '$!triangle') });
#line 331 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::Reduce, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::Reduce, '$!infix') });
#line 332 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::Reduce, 'args', [], anon sub args ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::Reduce, '$!args') });
    compose(RakuAST::Term::Reduce);
    parent(RakuAST::Term::RadixNumber, RakuAST::Term);
    add-attribute(RakuAST::Term::RadixNumber, Int, '$!radix');
    add-attribute(RakuAST::Term::RadixNumber, RakuAST::Circumfix, '$!value');
    add-attribute(RakuAST::Term::RadixNumber, Bool, '$!multi-part');
    add-method(RakuAST::Term::RadixNumber, 'new', [RakuAST::Term::RadixNumber, '', 0, 0, Int, '$radix', 1, 0, RakuAST::Circumfix, '$value', 1, 0, Bool, '$multi-part', 1, 1], anon sub new ($SELF_CONT, :$radix!, :$value!, :$multi-part?) {
        my $SELF := nqp::decont($SELF_CONT);
        $radix := nqp::decont($radix);
        $value := nqp::decont($value);
        $multi-part := nqp::decont($multi-part);
#line 409 src/Raku/ast/term.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Term::RadixNumber, '$!radix', $radix);
        nqp::bindattr($obj, RakuAST::Term::RadixNumber, '$!value', $value);
        nqp::bindattr($obj, RakuAST::Term::RadixNumber, '$!multi-part',
            $multi-part ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Term::RadixNumber, 'IMPL-EXPR-QAST', [RakuAST::Term::RadixNumber, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 418 src/Raku/ast/term.rakumod
        
        $context.ensure-sc(nqp::getattr($SELF, RakuAST::Term::RadixNumber, '$!radix'));
        QAST::Op.new:
            :op('call'), :name(nqp::getattr($SELF, RakuAST::Term::RadixNumber, '$!multi-part') ?? '&UNBASE_BRACKET' !! '&UNBASE'),
            QAST::WVal.new( :value(nqp::getattr($SELF, RakuAST::Term::RadixNumber, '$!radix')) ),
            nqp::getattr($SELF, RakuAST::Term::RadixNumber, '$!value').IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::Term::RadixNumber, 'visit-children', [RakuAST::Term::RadixNumber, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 426 src/Raku/ast/term.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Term::RadixNumber, '$!value'));
    
    });
#line 406 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::RadixNumber, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::RadixNumber, '$!value') });
#line 405 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::RadixNumber, 'radix', [], anon sub radix ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::RadixNumber, '$!radix') });
#line 407 src/Raku/ast/term.rakumod
    add-method(RakuAST::Term::RadixNumber, 'multi-part', [], anon sub multi-part ($self) { nqp::getattr(nqp::decont($self), RakuAST::Term::RadixNumber, '$!multi-part') });
    compose(RakuAST::Term::RadixNumber);
    parent(RakuAST::Name, RakuAST::ImplicitLookups);
    parent(RakuAST::Name, RakuAST::Attaching);
    add-attribute(RakuAST::Name, List, '$!parts');
    add-attribute(RakuAST::Name, List, '$!colonpairs');
    add-attribute(RakuAST::Name, Mu, '$!setting');
    add-method(RakuAST::Name, 'new', [RakuAST::Name, '', 0, 0, Any, '@parts', 0, 0], anon sub new ($SELF_CONT, *@parts) {
        my $SELF := nqp::decont($SELF_CONT);
        @parts := nqp::decont(@parts);
#line 11 src/Raku/ast/name.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Name, '$!parts', @parts);
        nqp::bindattr($obj, RakuAST::Name, '$!colonpairs', []);
        $obj
    
    });
    add-method(RakuAST::Name, 'attach', [RakuAST::Name, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 18 src/Raku/ast/name.rakumod
        
        # Might be needed for resolving CORE:: in dynamically compiled frames
        nqp::bindattr($SELF, RakuAST::Name, '$!setting', $resolver.setting);
    
    });
    add-method(RakuAST::Name, 'from-identifier', [RakuAST::Name, '', 0, 0, Str, '$identifier', 0, 0], anon sub from-identifier ($SELF_CONT, $identifier!) {
        my $SELF := nqp::decont($SELF_CONT);
        $identifier := nqp::decont($identifier);
#line 23 src/Raku/ast/name.rakumod
        
        $SELF.new(RakuAST::Name::Part::Simple.new($identifier))
    
    });
    add-method(RakuAST::Name, 'from-identifier-parts', [RakuAST::Name, '', 0, 0, Any, '@identifiers', 0, 0], anon sub from-identifier-parts ($SELF_CONT, *@identifiers) {
        my $SELF := nqp::decont($SELF_CONT);
        @identifiers := nqp::decont(@identifiers);
#line 27 src/Raku/ast/name.rakumod
        
        my @parts;
        for @identifiers {
            unless nqp::istype($_, Str) || nqp::isstr($_) {
                nqp::die('Expected identifier parts to be Str, but got ' ~ $_.HOW.name($_));
            }
            @parts.push(RakuAST::Name::Part::Simple.new($_));
        }
        $SELF.new(|@parts)
    
    });
    add-method(RakuAST::Name, 'add-colonpair', [RakuAST::Name, '', 0, 0, RakuAST::ColonPairish, '$pair', 0, 0], anon sub add-colonpair ($SELF_CONT, $pair!) {
        my $SELF := nqp::decont($SELF_CONT);
        $pair := nqp::decont($pair);
#line 38 src/Raku/ast/name.rakumod
        
        nqp::getattr($SELF, RakuAST::Name, '$!colonpairs').push: $pair;
    
    });
    add-method(RakuAST::Name, 'parts', [RakuAST::Name, '', 0, 0], anon sub parts ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 42 src/Raku/ast/name.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Name, '$!parts'))
    
    });
    add-method(RakuAST::Name, 'is-multi-part', [RakuAST::Name, '', 0, 0], anon sub is-multi-part ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 46 src/Raku/ast/name.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) > 1
    
    });
    add-method(RakuAST::Name, 'is-identifier', [RakuAST::Name, '', 0, 0], anon sub is-identifier ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 50 src/Raku/ast/name.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) == 1 && (
            nqp::istype(nqp::getattr($SELF, RakuAST::Name, '$!parts')[0], RakuAST::Name::Part::Simple)
            || nqp::istype(nqp::getattr($SELF, RakuAST::Name, '$!parts')[0], RakuAST::Name::Part::Expression) && nqp::getattr($SELF, RakuAST::Name, '$!parts')[0].has-compile-time-name
        )
    
    });
    add-method(RakuAST::Name, 'is-empty', [RakuAST::Name, '', 0, 0], anon sub is-empty ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 57 src/Raku/ast/name.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) == 0
          || (nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) == 1 && nqp::getattr($SELF, RakuAST::Name, '$!parts')[0].name eq '')
    
    });
    add-method(RakuAST::Name, 'is-simple', [RakuAST::Name, '', 0, 0], anon sub is-simple ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 62 src/Raku/ast/name.rakumod
        
        for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
            return (Bool.WHO)<False> unless nqp::istype($_, RakuAST::Name::Part::Simple);
        }
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Name, 'simple-identifier', [RakuAST::Name, '', 0, 0], anon sub simple-identifier ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 72 src/Raku/ast/name.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) == 1
          && nqp::istype((my $obj := nqp::getattr($SELF, RakuAST::Name, '$!parts')[0]),RakuAST::Name::Part::Simple)
          && $obj.name
    
    });
    add-method(RakuAST::Name, 'is-package-lookup', [RakuAST::Name, '', 0, 0], anon sub is-package-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 78 src/Raku/ast/name.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts'))
          && nqp::istype(nqp::getattr($SELF, RakuAST::Name, '$!parts')[nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) - 1],RakuAST::Name::Part::Empty)
    
    });
    add-method(RakuAST::Name, 'base-name', [RakuAST::Name, '', 0, 0], anon sub base-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 83 src/Raku/ast/name.rakumod
        
        my @parts := nqp::clone(nqp::getattr($SELF, RakuAST::Name, '$!parts'));
        @parts.pop if $SELF.is-package-lookup;
        RakuAST::Name.new(|@parts)
    
    });
    add-method(RakuAST::Name, 'is-indirect-lookup', [RakuAST::Name, '', 0, 0], anon sub is-indirect-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 89 src/Raku/ast/name.rakumod
        
        for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
            return (Bool.WHO)<True> if nqp::istype($_, RakuAST::Name::Part::Expression);
        }
    
    });
    add-method(RakuAST::Name, 'has-colonpair', [RakuAST::Name, '', 0, 0, Any, '$key', 0, 0], anon sub has-colonpair ($SELF_CONT, $key!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
#line 95 src/Raku/ast/name.rakumod
        
        for nqp::getattr($SELF, RakuAST::Name, '$!colonpairs') {
            return (Bool.WHO)<True> if $_.key eq $key;
        }
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Name, 'without-colonpair', [RakuAST::Name, '', 0, 0, Any, '$key', 0, 0], anon sub without-colonpair ($SELF_CONT, $key!) {
        my $SELF := nqp::decont($SELF_CONT);
        $key := nqp::decont($key);
#line 102 src/Raku/ast/name.rakumod
        
        my @parts := nqp::clone(nqp::getattr($SELF, RakuAST::Name, '$!parts'));
        my $type := RakuAST::Name.new(|@parts);
        for nqp::getattr($SELF, RakuAST::Name, '$!colonpairs') {
            $type.add-colonpair($_) if !nqp::istype($_, RakuAST::ColonPair) || $_.key ne $key;
        }
        $type
    
    });
    add-method(RakuAST::Name, 'without-colonpairs', [RakuAST::Name, '', 0, 0], anon sub without-colonpairs ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 111 src/Raku/ast/name.rakumod
        
        my @parts := nqp::clone(nqp::getattr($SELF, RakuAST::Name, '$!parts'));
        my $type := RakuAST::Name.new(|@parts);
        for nqp::getattr($SELF, RakuAST::Name, '$!colonpairs') {
            $type.add-colonpair($_)
              unless nqp::istype($_, RakuAST::ColonPair);
        }
        $type
    
    });
    add-method(RakuAST::Name, 'visit-children', [RakuAST::Name, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 121 src/Raku/ast/name.rakumod
        
        if nqp::isconcrete($SELF) {
            for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
                $_.visit-children($visitor);
            }
            for nqp::getattr($SELF, RakuAST::Name, '$!colonpairs') {
                $visitor($_);
            }
        }
    
    });
    add-method(RakuAST::Name, 'canonicalize', [RakuAST::Name, '', 0, 0, Any, '$colonpairs', 1, 1], anon sub canonicalize ($SELF_CONT, :$colonpairs?) {
        my $SELF := nqp::decont($SELF_CONT);
        $colonpairs := nqp::decont($colonpairs);
#line 132 src/Raku/ast/name.rakumod
        
        my $canon-parts := nqp::list_s();
        for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
            if nqp::istype($_, RakuAST::Name::Part::Simple) {
                nqp::push_s($canon-parts, $_.name);
            }
            elsif nqp::istype($_, RakuAST::Name::Part::Empty) {
                nqp::push_s($canon-parts, '');
            }
            elsif nqp::istype($_, RakuAST::Name::Part::Expression) {
                if $_.has-compile-time-name {
                    nqp::push_s($canon-parts, $_.name);
                }
                else {
                    nqp::push_s($canon-parts, '') if nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) == 1;
                    nqp::push_s($canon-parts, '(' ~ $_.expr.DEPARSE ~ ')');
                }
            }
            else {
                nqp::die('canonicalize NYI for non-simple name part ' ~ $_.HOW.name($_));
            }
        }
        my $name := nqp::join('::', $canon-parts);
        unless nqp::isconcrete($colonpairs) && !$colonpairs {
            for nqp::getattr($SELF, RakuAST::Name, '$!colonpairs') {
                if nqp::istype($_, RakuAST::ColonPairish) {
                    $name := $name ~ ':' ~ $_.canonicalize;
                }
                else {
                    nqp::die('canonicalize NYI for non-simple colonpairs: ' ~ $_.HOW.name($_));
                }
            }
        }
        $name
    
    });
    add-method(RakuAST::Name, 'is-pseudo-package', [RakuAST::Name, '', 0, 0], anon sub is-pseudo-package ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 168 src/Raku/ast/name.rakumod
        
        nqp::istype(nqp::getattr($SELF, RakuAST::Name, '$!parts')[0], RakuAST::Name::Part::Simple) && nqp::getattr($SELF, RakuAST::Name, '$!parts')[0].is-pseudo-package
        || nqp::istype(nqp::getattr($SELF, RakuAST::Name, '$!parts')[0], RakuAST::Name::Part::Empty)
    
    });
    add-method(RakuAST::Name, 'qualified-with', [RakuAST::Name, '', 0, 0, RakuAST::Name, '$target', 0, 0], anon sub qualified-with ($SELF_CONT, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $target := nqp::decont($target);
#line 173 src/Raku/ast/name.rakumod
        
        my $qualified := nqp::clone($SELF);
        my @parts := nqp::clone(nqp::getattr($target, RakuAST::Name, '$!parts'));
        for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
            nqp::push(@parts, $_);
        }
        nqp::bindattr($qualified, RakuAST::Name, '$!parts', @parts);
        $qualified
    
    });
    add-method(RakuAST::Name, 'contains-pseudo-package-illegal-for-declaration', [RakuAST::Name, '', 0, 0], anon sub contains-pseudo-package-illegal-for-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 183 src/Raku/ast/name.rakumod
        
        return 'GLOBAL' if $SELF.is-identifier && nqp::getattr($SELF, RakuAST::Name, '$!parts')[0].name eq 'GLOBAL';
        for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
            return $_.name
                if $_.is-pseudo-package
                || nqp::istype($_, RakuAST::Name::Part::Simple) && $_.name eq 'PROCESS';
        }
        Nil
    
    });
    add-method(RakuAST::Name, 'dump-markers', [RakuAST::Name, '', 0, 0], anon sub dump-markers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 193 src/Raku/ast/name.rakumod
        
        '【' ~ $SELF.canonicalize ~ '】'
    
    });
    add-method(RakuAST::Name, 'IMPL-IS-NQP-OP', [RakuAST::Name, '', 0, 0], anon sub IMPL-IS-NQP-OP ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 197 src/Raku/ast/name.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) == 2 && nqp::istype(nqp::getattr($SELF, RakuAST::Name, '$!parts')[0], RakuAST::Name::Part::Simple) && nqp::getattr($SELF, RakuAST::Name, '$!parts')[0].name eq 'nqp'
            ?? nqp::getattr($SELF, RakuAST::Name, '$!parts')[1].name
            !! ''
    
    });
    add-method(RakuAST::Name, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Name, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 203 src/Raku/ast/name.rakumod
        
        $SELF.IMPL-WRAP-LIST(
            $SELF.is-simple && !$SELF.is-pseudo-package
                ?? []
                !! [
                    RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('&INDIRECT_NAME_LOOKUP')),
                    RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('PseudoStash')),
                ]
        )
    
    });
    add-method(RakuAST::Name, 'IMPL-QAST-PSEUDO-PACKAGE-LOOKUP', [RakuAST::Name, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$sigil', 1, 1], anon sub IMPL-QAST-PSEUDO-PACKAGE-LOOKUP ($SELF_CONT, $context!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $sigil := nqp::decont($sigil);
#line 214 src/Raku/ast/name.rakumod
        
        my $final := nqp::getattr($SELF, RakuAST::Name, '$!parts')[nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) - 1];
        my $PseudoStash-lookup := $SELF.get-implicit-lookups.AT-POS(1);
        my $result;
        if $*IMPL-COMPILE-DYNAMICALLY && nqp::getattr($SELF, RakuAST::Name, '$!parts')[0].name eq 'CORE' {
            nqp::shift(nqp::getattr($SELF, RakuAST::Name, '$!parts')); #FIXME don't modify please
            my $PseudoStash := $PseudoStash-lookup.resolution.compile-time-value;
            my $stash := nqp::create($PseudoStash);
            my $found-ctx := nqp::getattr($SELF, RakuAST::Name, '$!setting');
            nqp::bindattr($stash, Map, '$!storage', nqp::ctxlexpad($found-ctx)),
            nqp::bindattr($stash, $PseudoStash, '$!ctx', $found-ctx),
            nqp::bindattr_i($stash, $PseudoStash, '$!mode', STATIC_CHAIN),
            nqp::setwho(Perl6::Metamodel::ModuleHOW.new_type(:name('CORE')), $stash);
            $context.ensure-sc($stash);
            $result := QAST::WVal.new(:value($stash));
        }
        else {
            $result := QAST::Op.new(
              :op<callmethod>,
              :name<new>,
              $PseudoStash-lookup.IMPL-TO-QAST($context)
            );
        }
        my $first := 1;
        for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
            if $first { # don't call .WHO on the pseudo package itself, index into it instead
                $first := 0;
            }
            else { # get the Stash from all real packages
                $result := QAST::Op.new( :op('who'), $result );
            }
            $result := $_.IMPL-QAST-PSEUDO-PACKAGE-LOOKUP-PART($context, $result, $_ =:= $final, :$sigil);
        }
        $result
    
    });
    add-method(RakuAST::Name, 'IMPL-QAST-PACKAGE-LOOKUP', [RakuAST::Name, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$start-package', 0, 0, RakuAST::Declaration, '$lexical', 1, 1, str, '$sigil', 1, 1, Bool, '$global-fallback', 1, 1], anon sub IMPL-QAST-PACKAGE-LOOKUP ($SELF_CONT, $context!, $start-package!, :$lexical?, :$sigil?, :$global-fallback?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $start-package := nqp::decont($start-package);
        $lexical := nqp::decont($lexical);
        $sigil := nqp::decont($sigil);
        $global-fallback := nqp::decont($global-fallback);
#line 250 src/Raku/ast/name.rakumod
        
        my $result := QAST::WVal.new(:value($start-package));
        my $final := nqp::getattr($SELF, RakuAST::Name, '$!parts')[nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) - 1];
        my int $first := 0;
        if nqp::istype(nqp::getattr($SELF, RakuAST::Name, '$!parts')[0], RakuAST::Name::Part::Simple) && nqp::getattr($SELF, RakuAST::Name, '$!parts')[0].name eq 'GLOBAL' {
            $result := QAST::Op.new(:op<getcurhllsym>, QAST::SVal.new(:value<GLOBAL>));
            $first := 1;
        }
        elsif $lexical {
            $first := 1;
            $result := $lexical.IMPL-LOOKUP-QAST($context);
            return QAST::Op.new(:op<who>, $result);
        }
        if $SELF.is-pseudo-package {
            $result := $SELF.IMPL-QAST-PSEUDO-PACKAGE-LOOKUP($context, :$sigil);
        }
        else {
            for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
                if $first { # skip GLOBAL or lexically found first part, already taken care of
                    $first := 0;
                }
                else { # get the Stash from all real packages
                    # We do .WHO on the current package, followed by the index into it.
                    $result := QAST::Op.new( :op('who'), $result );
                    $result := $_.IMPL-QAST-PACKAGE-LOOKUP-PART($context, $result, $_ =:= $final, :$sigil, :$global-fallback);
                }
            }
        }
        $result
    
    });
    add-method(RakuAST::Name, 'IMPL-QAST-INDIRECT-LOOKUP', [RakuAST::Name, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$sigil', 1, 1], anon sub IMPL-QAST-INDIRECT-LOOKUP ($SELF_CONT, $context!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $sigil := nqp::decont($sigil);
#line 281 src/Raku/ast/name.rakumod
        
        my $final   := nqp::getattr($SELF, RakuAST::Name, '$!parts')[nqp::elems(nqp::getattr($SELF, RakuAST::Name, '$!parts')) - 1];
        my $lookups := $SELF.get-implicit-lookups;
        my $result  := QAST::Op.new(
            :op<call>,
            $lookups.AT-POS(0).IMPL-TO-QAST($context),
            QAST::Op.new(
                :op<callmethod>,
                :name<new>,
                $lookups.AT-POS(1).IMPL-TO-QAST($context),
            ),
        );
        nqp::push($result, QAST::SVal.new(:value($sigil))) if $sigil;
        for nqp::getattr($SELF, RakuAST::Name, '$!parts') {
            nqp::push($result, $_.IMPL-QAST-INDIRECT-LOOKUP-PART($context, $result, $_ =:= $final));
        }
        $result
    
    });
#line 8 src/Raku/ast/name.rakumod
    add-method(RakuAST::Name, 'colonpairs', [], anon sub colonpairs ($self) { nqp::getattr(nqp::decont($self), RakuAST::Name, '$!colonpairs') });
    compose(RakuAST::Name);
    parent(RakuAST::Name::Part, Any);
    add-method(RakuAST::Name::Part, 'is-pseudo-package', [RakuAST::Name::Part, '', 0, 0], anon sub is-pseudo-package ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 303 src/Raku/ast/name.rakumod
        
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Name::Part, 'visit-children', [RakuAST::Name::Part, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 307 src/Raku/ast/name.rakumod
        
    
    });
    compose(RakuAST::Name::Part);
    parent(RakuAST::Name::Part::Simple, RakuAST::Name::Part);
    add-attribute(RakuAST::Name::Part::Simple, str, '$!name');
    add-method(RakuAST::Name::Part::Simple, 'new', [RakuAST::Name::Part::Simple, '', 0, 0, Str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 317 src/Raku/ast/name.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Name::Part::Simple, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Name::Part::Simple, 'is-pseudo-package', [RakuAST::Name::Part::Simple, '', 0, 0], anon sub is-pseudo-package ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 323 src/Raku/ast/name.rakumod
        
        my $name := nqp::getattr_s($SELF, RakuAST::Name::Part::Simple, '$!name');
           $name eq 'CALLER'
        || $name eq 'CALLERS'
        || $name eq 'CLIENT'
        || $name eq 'DYNAMIC'
        || $name eq 'CORE'
        || $name eq 'LEXICAL'
        || $name eq 'MY'
        || $name eq 'OUR'
        || $name eq 'OUTER'
        || $name eq 'OUTERS'
        || $name eq 'SETTING'
        || $name eq 'UNIT'
        || $name eq 'COMPILING' # seems to be reserved
    
    });
    add-method(RakuAST::Name::Part::Simple, 'IMPL-QAST-PACKAGE-LOOKUP-PART', [RakuAST::Name::Part::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$stash-qast', 0, 0, Int, '$is-final', 0, 0, str, '$sigil', 1, 1, Bool, '$global-fallback', 1, 1], anon sub IMPL-QAST-PACKAGE-LOOKUP-PART ($SELF_CONT, $context!, $stash-qast!, $is-final!, :$sigil?, :$global-fallback?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $stash-qast := nqp::decont($stash-qast);
        $is-final := nqp::decont($is-final);
        $sigil := nqp::decont($sigil);
        $global-fallback := nqp::decont($global-fallback);
#line 340 src/Raku/ast/name.rakumod
        
        my $op := QAST::Op.new(
            :op('callmethod'),
            :name($is-final ?? 'AT-KEY' !! 'package_at_key'),
            $stash-qast,
            QAST::SVal.new( :value($is-final && $sigil ?? $sigil ~ nqp::getattr_s($SELF, RakuAST::Name::Part::Simple, '$!name') !! nqp::getattr_s($SELF, RakuAST::Name::Part::Simple, '$!name')) )
        );
        $op.push(QAST::WVal.new(:value((Bool.WHO)<True>), :named<global_fallback>)) if $is-final && $global-fallback;
        $op
    
    });
    add-method(RakuAST::Name::Part::Simple, 'IMPL-QAST-PSEUDO-PACKAGE-LOOKUP-PART', [RakuAST::Name::Part::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$stash-qast', 0, 0, Int, '$is-final', 0, 0, str, '$sigil', 1, 1], anon sub IMPL-QAST-PSEUDO-PACKAGE-LOOKUP-PART ($SELF_CONT, $context!, $stash-qast!, $is-final!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $stash-qast := nqp::decont($stash-qast);
        $is-final := nqp::decont($is-final);
        $sigil := nqp::decont($sigil);
#line 351 src/Raku/ast/name.rakumod
        
        QAST::Op.new(
            :op('call'),
            :name('&postcircumfix:<{ }>'),
            $stash-qast,
            QAST::SVal.new( :value($is-final && $sigil ?? $sigil ~ nqp::getattr_s($SELF, RakuAST::Name::Part::Simple, '$!name') !! nqp::getattr_s($SELF, RakuAST::Name::Part::Simple, '$!name')) )
        )
    
    });
    add-method(RakuAST::Name::Part::Simple, 'IMPL-QAST-INDIRECT-LOOKUP-PART', [RakuAST::Name::Part::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$stash-qast', 0, 0, Int, '$is-final', 0, 0, str, '$sigil', 1, 1], anon sub IMPL-QAST-INDIRECT-LOOKUP-PART ($SELF_CONT, $context!, $stash-qast!, $is-final!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $stash-qast := nqp::decont($stash-qast);
        $is-final := nqp::decont($is-final);
        $sigil := nqp::decont($sigil);
#line 360 src/Raku/ast/name.rakumod
        
        QAST::SVal.new( :value($is-final && $sigil ?? $sigil ~ nqp::getattr_s($SELF, RakuAST::Name::Part::Simple, '$!name') !! nqp::getattr_s($SELF, RakuAST::Name::Part::Simple, '$!name')) )
    
    });
#line 315 src/Raku/ast/name.rakumod
    add-method(RakuAST::Name::Part::Simple, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Name::Part::Simple, '$!name') });
    compose(RakuAST::Name::Part::Simple);
    parent(RakuAST::Name::Part::Expression, RakuAST::Name::Part);
    add-attribute(RakuAST::Name::Part::Expression, RakuAST::Expression, '$!expr');
    add-method(RakuAST::Name::Part::Expression, 'new', [RakuAST::Name::Part::Expression, '', 0, 0, RakuAST::Expression, '$expr', 0, 0], anon sub new ($SELF_CONT, $expr!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expr := nqp::decont($expr);
#line 370 src/Raku/ast/name.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Name::Part::Expression, '$!expr', $expr);
        $obj
    
    });
    add-method(RakuAST::Name::Part::Expression, 'IMPL-QAST-PSEUDO-PACKAGE-LOOKUP-PART', [RakuAST::Name::Part::Expression, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$stash-qast', 0, 0, Int, '$is-final', 0, 0, str, '$sigil', 1, 1], anon sub IMPL-QAST-PSEUDO-PACKAGE-LOOKUP-PART ($SELF_CONT, $context!, $stash-qast!, $is-final!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $stash-qast := nqp::decont($stash-qast);
        $is-final := nqp::decont($is-final);
        $sigil := nqp::decont($sigil);
#line 376 src/Raku/ast/name.rakumod
        
        QAST::Op.new(
            :op('call'),
            :name('&postcircumfix:<{ }>'),
            $stash-qast,
            nqp::getattr($SELF, RakuAST::Name::Part::Expression, '$!expr').IMPL-TO-QAST($context),
        )
    
    });
    add-method(RakuAST::Name::Part::Expression, 'IMPL-QAST-PACKAGE-LOOKUP-PART', [RakuAST::Name::Part::Expression, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$stash-qast', 0, 0, Int, '$is-final', 0, 0, str, '$sigil', 1, 1, Bool, '$global-fallback', 1, 1], anon sub IMPL-QAST-PACKAGE-LOOKUP-PART ($SELF_CONT, $context!, $stash-qast!, $is-final!, :$sigil?, :$global-fallback?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $stash-qast := nqp::decont($stash-qast);
        $is-final := nqp::decont($is-final);
        $sigil := nqp::decont($sigil);
        $global-fallback := nqp::decont($global-fallback);
#line 385 src/Raku/ast/name.rakumod
        
        QAST::Op.new(
            :op('callmethod'),
            :name($is-final ?? 'AT-KEY' !! 'package_at_key'),
            $stash-qast,
            nqp::getattr($SELF, RakuAST::Name::Part::Expression, '$!expr').IMPL-TO-QAST($context),
        )
    
    });
    add-method(RakuAST::Name::Part::Expression, 'IMPL-QAST-INDIRECT-LOOKUP-PART', [RakuAST::Name::Part::Expression, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$stash-qast', 0, 0, Int, '$is-final', 0, 0, str, '$sigil', 1, 1], anon sub IMPL-QAST-INDIRECT-LOOKUP-PART ($SELF_CONT, $context!, $stash-qast!, $is-final!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $stash-qast := nqp::decont($stash-qast);
        $is-final := nqp::decont($is-final);
        $sigil := nqp::decont($sigil);
#line 394 src/Raku/ast/name.rakumod
        
        nqp::getattr($SELF, RakuAST::Name::Part::Expression, '$!expr').IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::Name::Part::Expression, 'visit-children', [RakuAST::Name::Part::Expression, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 398 src/Raku/ast/name.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Name::Part::Expression, '$!expr'));
    
    });
    add-method(RakuAST::Name::Part::Expression, 'has-compile-time-name', [RakuAST::Name::Part::Expression, '', 0, 0], anon sub has-compile-time-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 402 src/Raku/ast/name.rakumod
        
        nqp::defined(nqp::getattr($SELF, RakuAST::Name::Part::Expression, '$!expr').literalize)
    
    });
    add-method(RakuAST::Name::Part::Expression, 'name', [RakuAST::Name::Part::Expression, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 406 src/Raku/ast/name.rakumod
        
        nqp::getattr($SELF, RakuAST::Name::Part::Expression, '$!expr').literalize // nqp::die('Name ' ~ nqp::getattr($SELF, RakuAST::Name::Part::Expression, '$!expr').DEPARSE ~ ' is not compile-time known')
    
    });
#line 368 src/Raku/ast/name.rakumod
    add-method(RakuAST::Name::Part::Expression, 'expr', [], anon sub expr ($self) { nqp::getattr(nqp::decont($self), RakuAST::Name::Part::Expression, '$!expr') });
    compose(RakuAST::Name::Part::Expression);
    parent(RakuAST::Name::Part::Empty, RakuAST::Name::Part);
    add-method(RakuAST::Name::Part::Empty, 'new', [RakuAST::Name::Part::Empty, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 415 src/Raku/ast/name.rakumod
        
        nqp::create($SELF);
    
    });
    add-method(RakuAST::Name::Part::Empty, 'IMPL-QAST-PSEUDO-PACKAGE-LOOKUP-PART', [RakuAST::Name::Part::Empty, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$stash-qast', 0, 0, Int, '$is-final', 0, 0, str, '$sigil', 1, 1], anon sub IMPL-QAST-PSEUDO-PACKAGE-LOOKUP-PART ($SELF_CONT, $context!, $stash-qast!, $is-final!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $stash-qast := nqp::decont($stash-qast);
        $is-final := nqp::decont($is-final);
        $sigil := nqp::decont($sigil);
#line 419 src/Raku/ast/name.rakumod
        
        $stash-qast
    
    });
    add-method(RakuAST::Name::Part::Empty, 'IMPL-QAST-PACKAGE-LOOKUP-PART', [RakuAST::Name::Part::Empty, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$stash-qast', 0, 0, Int, '$is-final', 0, 0, str, '$sigil', 1, 1, Bool, '$global-fallback', 1, 1], anon sub IMPL-QAST-PACKAGE-LOOKUP-PART ($SELF_CONT, $context!, $stash-qast!, $is-final!, :$sigil?, :$global-fallback?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $stash-qast := nqp::decont($stash-qast);
        $is-final := nqp::decont($is-final);
        $sigil := nqp::decont($sigil);
        $global-fallback := nqp::decont($global-fallback);
#line 423 src/Raku/ast/name.rakumod
        
        $stash-qast
    
    });
    add-method(RakuAST::Name::Part::Empty, 'name', [RakuAST::Name::Part::Empty, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 427 src/Raku/ast/name.rakumod
         "" 
    });
    compose(RakuAST::Name::Part::Empty);
    parent(RakuAST::Type, RakuAST::Term);
    parent(RakuAST::Type, RakuAST::Meta);
    add-method(RakuAST::Type, 'is-known-to-be', [RakuAST::Type, '', 0, 0, Mu, '$type', 0, 0], anon sub is-known-to-be ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 8 src/Raku/ast/type.rakumod
        
        nqp::die('Expected a type object') if nqp::isconcrete($type);
        if nqp::istype($SELF, RakuAST::Lookup) && $SELF.is-resolved {
            my $resolution := $SELF.resolution;
            if nqp::istype($resolution, RakuAST::CompileTimeValue) {
                return nqp::istype($resolution.compile-time-value, $type);
            }
        }
        0
    
    });
    add-method(RakuAST::Type, 'is-known-to-be-exactly', [RakuAST::Type, '', 0, 0, Mu, '$type', 0, 0], anon sub is-known-to-be-exactly ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 18 src/Raku/ast/type.rakumod
        
        nqp::die('Expected a type object') if nqp::isconcrete($type);
        if nqp::istype($SELF, RakuAST::Lookup) && $SELF.is-resolved {
            my $resolution := $SELF.resolution;
            if nqp::istype($resolution, RakuAST::CompileTimeValue) {
                return $resolution.compile-time-value =:= $type;
            }
        }
        0
    
    });
    add-method(RakuAST::Type, 'dba', [RakuAST::Type, '', 0, 0], anon sub dba ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 29 src/Raku/ast/type.rakumod
         'type' 
    });
    add-method(RakuAST::Type, 'IMPL-BASE-TYPE', [RakuAST::Type, '', 0, 0], anon sub IMPL-BASE-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 31 src/Raku/ast/type.rakumod
        
        $SELF
    
    });
    add-method(RakuAST::Type, 'IMPL-TARGET-TYPE', [RakuAST::Type, '', 0, 0], anon sub IMPL-TARGET-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 35 src/Raku/ast/type.rakumod
        
        $SELF
    
    });
    compose(RakuAST::Type);
    parent(RakuAST::Type::Simple, RakuAST::Type);
    parent(RakuAST::Type::Simple, RakuAST::Lookup);
    add-attribute(RakuAST::Type::Simple, RakuAST::Name, '$!name');
    add-method(RakuAST::Type::Simple, 'new', [RakuAST::Type::Simple, '', 0, 0, RakuAST::Name, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 47 src/Raku/ast/type.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Type::Simple, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Type::Simple, 'resolve-with', [RakuAST::Type::Simple, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 53 src/Raku/ast/type.rakumod
        
        my $resolved := $resolver.resolve-name-constant(nqp::getattr($SELF, RakuAST::Type::Simple, '$!name'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Type::Simple, 'PRODUCE-META-OBJECT', [RakuAST::Type::Simple, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 61 src/Raku/ast/type.rakumod
        
        $SELF.resolution.compile-time-value
    
    });
    add-method(RakuAST::Type::Simple, 'IMPL-EXPR-QAST', [RakuAST::Type::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 65 src/Raku/ast/type.rakumod
        
        my $value := $SELF.resolution.compile-time-value;
        if $value.HOW.archetypes.generic {
            QAST::Var.new( :name(nqp::getattr($SELF, RakuAST::Type::Simple, '$!name').canonicalize), :scope('lexical') )
        }
        else {
            $context.ensure-sc($value);
            QAST::WVal.new( :$value )
        }
    
    });
    add-method(RakuAST::Type::Simple, 'IMPL-CAN-INTERPRET', [RakuAST::Type::Simple, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 76 src/Raku/ast/type.rakumod
        
        $SELF.is-resolved && nqp::istype($SELF.resolution, RakuAST::CompileTimeValue)
    
    });
    add-method(RakuAST::Type::Simple, 'IMPL-INTERPRET', [RakuAST::Type::Simple, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 80 src/Raku/ast/type.rakumod
        
        $SELF.resolution.compile-time-value
    
    });
    add-method(RakuAST::Type::Simple, 'visit-children', [RakuAST::Type::Simple, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 84 src/Raku/ast/type.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Type::Simple, '$!name'));
    
    });
#line 45 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Simple, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Simple, '$!name') });
    compose(RakuAST::Type::Simple);
    parent(RakuAST::Type::Setting, RakuAST::Type::Simple);
    add-method(RakuAST::Type::Setting, 'resolve-with', [RakuAST::Type::Setting, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 94 src/Raku/ast/type.rakumod
        
        my $resolved := $resolver.resolve-name-constant-in-setting($SELF.name);
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    compose(RakuAST::Type::Setting);
    parent(RakuAST::Type::Derived, RakuAST::Type);
    parent(RakuAST::Type::Derived, RakuAST::Lookup);
    add-attribute(RakuAST::Type::Derived, RakuAST::Type, '$!base-type');
    add-method(RakuAST::Type::Derived, 'resolve-with', [RakuAST::Type::Derived, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 109 src/Raku/ast/type.rakumod
        
        nqp::getattr($SELF, RakuAST::Type::Derived, '$!base-type').resolve-with($resolver);
        $SELF.set-resolution($SELF);
        Nil
    
    });
    add-method(RakuAST::Type::Derived, 'IMPL-BASE-TYPE', [RakuAST::Type::Derived, '', 0, 0], anon sub IMPL-BASE-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 115 src/Raku/ast/type.rakumod
        
        nqp::istype(nqp::getattr($SELF, RakuAST::Type::Derived, '$!base-type'), RakuAST::Type::Derived) ?? nqp::getattr($SELF, RakuAST::Type::Derived, '$!base-type').IMPL-BASE-TYPE !! nqp::getattr($SELF, RakuAST::Type::Derived, '$!base-type')
    
    });
#line 107 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Derived, 'base-type', [], anon sub base-type ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Derived, '$!base-type') });
    compose(RakuAST::Type::Derived);
    parent(RakuAST::Type::Coercion, RakuAST::Type::Derived);
    parent(RakuAST::Type::Coercion, RakuAST::Declaration);
    add-attribute(RakuAST::Type::Coercion, RakuAST::Type, '$!constraint');
    add-method(RakuAST::Type::Coercion, 'new', [RakuAST::Type::Coercion, '', 0, 0, RakuAST::Type, '$base-type', 1, 0, Mu, '$constraint', 1, 1], anon sub new ($SELF_CONT, :$base-type!, :$constraint?) {
        my $SELF := nqp::decont($SELF_CONT);
        $base-type := nqp::decont($base-type);
        $constraint := nqp::decont($constraint);
#line 126 src/Raku/ast/type.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Type::Derived, '$!base-type', $base-type);
        nqp::bindattr($obj, RakuAST::Type::Coercion, '$!constraint',
          $constraint // RakuAST::Type::Setting.new(
            RakuAST::Name.from-identifier("Any")
          )
        );
        $obj
    
    });
    add-method(RakuAST::Type::Coercion, 'PRODUCE-META-OBJECT', [RakuAST::Type::Coercion, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 137 src/Raku/ast/type.rakumod
        
        Perl6::Metamodel::CoercionHOW.new_type(
            $SELF.base-type.compile-time-value,
            nqp::getattr($SELF, RakuAST::Type::Coercion, '$!constraint').meta-object,
        );
    
    });
    add-method(RakuAST::Type::Coercion, 'IMPL-EXPR-QAST', [RakuAST::Type::Coercion, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 144 src/Raku/ast/type.rakumod
        
        my $value := $SELF.meta-object;
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
    add-method(RakuAST::Type::Coercion, 'IMPL-CAN-INTERPRET', [RakuAST::Type::Coercion, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 150 src/Raku/ast/type.rakumod
        
        nqp::istype($SELF.base-type, RakuAST::CompileTimeValue)
        && nqp::istype(nqp::getattr($SELF, RakuAST::Type::Coercion, '$!constraint'), RakuAST::CompileTimeValue)
    
    });
    add-method(RakuAST::Type::Coercion, 'IMPL-INTERPRET', [RakuAST::Type::Coercion, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 155 src/Raku/ast/type.rakumod
        
        $SELF.meta-object
    
    });
    add-method(RakuAST::Type::Coercion, 'visit-children', [RakuAST::Type::Coercion, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 159 src/Raku/ast/type.rakumod
        
        $visitor($SELF.base-type);
        $visitor(nqp::getattr($SELF, RakuAST::Type::Coercion, '$!constraint'));
    
    });
    add-method(RakuAST::Type::Coercion, 'is-simple-lexical-declaration', [RakuAST::Type::Coercion, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 164 src/Raku/ast/type.rakumod
        
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Type::Coercion, 'IMPL-TARGET-TYPE', [RakuAST::Type::Coercion, '', 0, 0], anon sub IMPL-TARGET-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 168 src/Raku/ast/type.rakumod
        
        my $base-type := $SELF.base-type;
        nqp::istype($base-type, RakuAST::Type::Coercion) ?? $base-type.IMPL-TARGET-TYPE !! $base-type
    
    });
#line 124 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Coercion, 'constraint', [], anon sub constraint ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Coercion, '$!constraint') });
    compose(RakuAST::Type::Coercion);
    parent(RakuAST::Type::Definedness, RakuAST::Type::Derived);
    parent(RakuAST::Type::Definedness, RakuAST::Declaration);
    add-attribute(RakuAST::Type::Definedness, Bool, '$!definite');
    add-method(RakuAST::Type::Definedness, 'new', [RakuAST::Type::Definedness, '', 0, 0, RakuAST::Type, '$base-type', 1, 0, Bool, '$definite', 1, 0], anon sub new ($SELF_CONT, :$base-type!, :$definite!) {
        my $SELF := nqp::decont($SELF_CONT);
        $base-type := nqp::decont($base-type);
        $definite := nqp::decont($definite);
#line 180 src/Raku/ast/type.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Type::Derived, '$!base-type', $base-type);
        nqp::bindattr($obj, RakuAST::Type::Definedness, '$!definite', $definite ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Type::Definedness, 'PRODUCE-META-OBJECT', [RakuAST::Type::Definedness, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 187 src/Raku/ast/type.rakumod
        
        Perl6::Metamodel::DefiniteHOW.new_type(
            :base_type($SELF.base-type.compile-time-value),
            :definite(nqp::getattr($SELF, RakuAST::Type::Definedness, '$!definite')),
        );
    
    });
    add-method(RakuAST::Type::Definedness, 'IMPL-EXPR-QAST', [RakuAST::Type::Definedness, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 194 src/Raku/ast/type.rakumod
        
        my $value := $SELF.meta-object;
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
    add-method(RakuAST::Type::Definedness, 'IMPL-CAN-INTERPRET', [RakuAST::Type::Definedness, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 200 src/Raku/ast/type.rakumod
        
        nqp::istype($SELF.base-type, RakuAST::CompileTimeValue)
    
    });
    add-method(RakuAST::Type::Definedness, 'IMPL-INTERPRET', [RakuAST::Type::Definedness, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 204 src/Raku/ast/type.rakumod
        
        $SELF.meta-object
    
    });
    add-method(RakuAST::Type::Definedness, 'is-simple-lexical-declaration', [RakuAST::Type::Definedness, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 208 src/Raku/ast/type.rakumod
        
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Type::Definedness, 'visit-children', [RakuAST::Type::Definedness, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 212 src/Raku/ast/type.rakumod
        
        $visitor($SELF.base-type);
    
    });
#line 178 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Definedness, 'definite', [], anon sub definite ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Definedness, '$!definite') });
    compose(RakuAST::Type::Definedness);
    parent(RakuAST::Type::Capture, RakuAST::Type);
    parent(RakuAST::Type::Capture, RakuAST::Declaration);
    add-attribute(RakuAST::Type::Capture, RakuAST::Name, '$!name');
    add-method(RakuAST::Type::Capture, 'new', [RakuAST::Type::Capture, '', 0, 0, RakuAST::Name, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 223 src/Raku/ast/type.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Type::Capture, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Type::Capture, 'lexical-name', [RakuAST::Type::Capture, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 229 src/Raku/ast/type.rakumod
        
        nqp::getattr($SELF, RakuAST::Type::Capture, '$!name').canonicalize
    
    });
    add-method(RakuAST::Type::Capture, 'generate-lookup', [RakuAST::Type::Capture, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 233 src/Raku/ast/type.rakumod
        
        my $lookup := RakuAST::Term::Name.new(nqp::getattr($SELF, RakuAST::Type::Capture, '$!name'));
        $lookup.set-resolution($SELF);
        $lookup
    
    });
    add-method(RakuAST::Type::Capture, 'default-scope', [RakuAST::Type::Capture, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 239 src/Raku/ast/type.rakumod
         'my' 
    });
    add-method(RakuAST::Type::Capture, 'allowed-scopes', [RakuAST::Type::Capture, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 241 src/Raku/ast/type.rakumod
         $SELF.IMPL-WRAP-LIST(['my']) 
    });
    add-method(RakuAST::Type::Capture, 'PRODUCE-META-OBJECT', [RakuAST::Type::Capture, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 243 src/Raku/ast/type.rakumod
        
        Perl6::Metamodel::GenericHOW.new_type(
            :name(nqp::getattr($SELF, RakuAST::Type::Capture, '$!name').canonicalize),
        );
    
    });
    add-method(RakuAST::Type::Capture, 'IMPL-EXPR-QAST', [RakuAST::Type::Capture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 249 src/Raku/ast/type.rakumod
        
        $SELF.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::Type::Capture, 'IMPL-QAST-DECL', [RakuAST::Type::Capture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 253 src/Raku/ast/type.rakumod
        
        QAST::Var.new( :decl('var'), :scope('lexical'), :name(nqp::getattr($SELF, RakuAST::Type::Capture, '$!name').canonicalize) )
    
    });
    add-method(RakuAST::Type::Capture, 'IMPL-BIND-QAST', [RakuAST::Type::Capture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 257 src/Raku/ast/type.rakumod
        
        QAST::Op.new(
            :op('bind'),
            QAST::Var.new( :scope('lexical'), :name(nqp::getattr($SELF, RakuAST::Type::Capture, '$!name').canonicalize) ),
            QAST::Op.new(:op('what'), $source-qast)
        )
    
    });
    add-method(RakuAST::Type::Capture, 'IMPL-LOOKUP-QAST', [RakuAST::Type::Capture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 265 src/Raku/ast/type.rakumod
        
        QAST::Var.new( :name(nqp::getattr($SELF, RakuAST::Type::Capture, '$!name').canonicalize), :scope('lexical') )
    
    });
    add-method(RakuAST::Type::Capture, 'IMPL-CAN-INTERPRET', [RakuAST::Type::Capture, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 269 src/Raku/ast/type.rakumod
        
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Type::Capture, 'IMPL-INTERPRET', [RakuAST::Type::Capture, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 273 src/Raku/ast/type.rakumod
        
        $SELF.meta-object
    
    });
    add-method(RakuAST::Type::Capture, 'visit-children', [RakuAST::Type::Capture, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 277 src/Raku/ast/type.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Type::Capture, '$!name'));
    
    });
#line 221 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Capture, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Capture, '$!name') });
    compose(RakuAST::Type::Capture);
    parent(RakuAST::Type::Parameterized, RakuAST::Type::Derived);
    parent(RakuAST::Type::Parameterized, RakuAST::Declaration);
    add-attribute(RakuAST::Type::Parameterized, RakuAST::ArgList, '$!args');
    add-method(RakuAST::Type::Parameterized, 'new', [RakuAST::Type::Parameterized, '', 0, 0, RakuAST::Type, '$base-type', 1, 0, RakuAST::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$base-type!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $base-type := nqp::decont($base-type);
        $args := nqp::decont($args);
#line 288 src/Raku/ast/type.rakumod
        
        nqp::die('need a base-type, not ' ~ $base-type.dump) if !nqp::istype($base-type, RakuAST::Type);
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Type::Derived, '$!base-type', $base-type);
        nqp::bindattr($obj, RakuAST::Type::Parameterized, '$!args',
          $args // RakuAST::ArgList.new);
        $obj
    
    });
    add-method(RakuAST::Type::Parameterized, 'visit-children', [RakuAST::Type::Parameterized, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 297 src/Raku/ast/type.rakumod
        
        $visitor($SELF.base-type);
        $visitor(nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args'));
    
    });
    add-method(RakuAST::Type::Parameterized, 'PRODUCE-META-OBJECT', [RakuAST::Type::Parameterized, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 302 src/Raku/ast/type.rakumod
        
        if !nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args').args {
            $SELF.base-type.compile-time-value
        }
        elsif nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args').IMPL-HAS-ONLY-COMPILE-TIME-VALUES {
            my $args := nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args').IMPL-COMPILE-TIME-VALUES;
            my @pos := $args[0];
            my %named := $args[1];
            my $ptype := $SELF.IMPL-BASE-TYPE.compile-time-value;
            $ptype.HOW.parameterize($ptype, |@pos, |%named)
        }
        else {
            my $args := nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args').args;
            if nqp::istype($args.AT-POS(0), RakuAST::QuotedString) {
                my $is-only-quoted-string := 0;
                my $arg-count := 0;
                for $SELF.IMPL-UNWRAP-LIST($args) {
                    $is-only-quoted-string := nqp::istype($_, RakuAST::QuotedString) ?? 1 !! 0;
                    $arg-count++;
                    last unless $is-only-quoted-string;
                }
                if $is-only-quoted-string {
                    my @literals;
                    for $SELF.IMPL-UNWRAP-LIST($args) {
                        my $literal := $_.literal-value;
                        if nqp::isconcrete($literal) {
                            @literals.push: $literal;
                        }
                    }
                    unless nqp::elems(@literals) == $arg-count {
                        nqp::die('Not all RakuAST::QuotedString objects have literal values');
                    }
                    my $ptype := $SELF.IMPL-BASE-TYPE.compile-time-value;
                    $ptype.HOW.parameterize($ptype, |@literals);
                }
            }
            else {
                nqp::die('Cannot do compile time parameterization with these args');
            }
        }
    
    });
    add-method(RakuAST::Type::Parameterized, 'IMPL-EXPR-QAST', [RakuAST::Type::Parameterized, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 344 src/Raku/ast/type.rakumod
        
        if !nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args').args {
            QAST::WVal.new( :value($SELF.base-type.compile-time-value) )
        }
        elsif nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args').IMPL-HAS-ONLY-COMPILE-TIME-VALUES {
            my $value := $SELF.meta-object;
            $context.ensure-sc($value);
            QAST::WVal.new( :$value )
        }
        else {
            my $ptype := $SELF.base-type.compile-time-value;
            my $ptref := QAST::WVal.new( :value($ptype) );
            my $qast := QAST::Op.new(:op<callmethod>, :name<parameterize>, QAST::Op.new(:op<how>, $ptref), $ptref);
            nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args').IMPL-ADD-QAST-ARGS($context, $qast);
            $qast
        }
    
    });
    add-method(RakuAST::Type::Parameterized, 'IMPL-CAN-INTERPRET', [RakuAST::Type::Parameterized, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 362 src/Raku/ast/type.rakumod
        
        nqp::istype($SELF.base-type, RakuAST::CompileTimeValue)
        && nqp::getattr($SELF, RakuAST::Type::Parameterized, '$!args').IMPL-CAN-INTERPRET
    
    });
    add-method(RakuAST::Type::Parameterized, 'IMPL-INTERPRET', [RakuAST::Type::Parameterized, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 367 src/Raku/ast/type.rakumod
        
        $SELF.meta-object
    
    });
    add-method(RakuAST::Type::Parameterized, 'is-simple-lexical-declaration', [RakuAST::Type::Parameterized, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 371 src/Raku/ast/type.rakumod
        
        (Bool.WHO)<False>
    
    });
#line 286 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Parameterized, 'args', [], anon sub args ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Parameterized, '$!args') });
    compose(RakuAST::Type::Parameterized);
    parent(RakuAST::Type::Enum, RakuAST::Type);
    parent(RakuAST::Type::Enum, RakuAST::Declaration);
    parent(RakuAST::Type::Enum, RakuAST::BeginTime);
    parent(RakuAST::Type::Enum, RakuAST::TraitTarget);
    parent(RakuAST::Type::Enum, RakuAST::Attaching);
    parent(RakuAST::Type::Enum, RakuAST::PackageInstaller);
    parent(RakuAST::Type::Enum, RakuAST::ImplicitLookups);
    parent(RakuAST::Type::Enum, RakuAST::Doc::DeclaratorTarget);
    add-attribute(RakuAST::Type::Enum, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Type::Enum, RakuAST::Expression, '$!term');
    add-attribute(RakuAST::Type::Enum, RakuAST::Type, '$!of');
    add-attribute(RakuAST::Type::Enum, Mu, '$!current-package');
    add-attribute(RakuAST::Type::Enum, Mu, '$!base-type');
    add-method(RakuAST::Type::Enum, 'new', [RakuAST::Type::Enum, '', 0, 0, str, '$scope', 1, 1, RakuAST::Name, '$name', 1, 1, RakuAST::Type, '$of', 1, 1, List, '$traits', 1, 1, RakuAST::Expression, '$term', 1, 0, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$scope?, :$name?, :$of?, :$traits?, :$term!, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $name := nqp::decont($name);
        $of := nqp::decont($of);
        $traits := nqp::decont($traits);
        $term := nqp::decont($term);
        $WHY := nqp::decont($WHY);
#line 400 src/Raku/ast/type.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::Type::Enum, '$!name',
          $name // RakuAST::Name.from-identifier(''));
        nqp::bindattr($obj, RakuAST::Type::Enum, '$!of', $of);
        $obj.set-traits($traits);
        nqp::bindattr($obj, RakuAST::Type::Enum, '$!term', $term);
        $obj.set-WHY($WHY);
        $obj
    
    });
    add-method(RakuAST::Type::Enum, 'default-scope', [RakuAST::Type::Enum, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 412 src/Raku/ast/type.rakumod
         'our' 
    });
    add-method(RakuAST::Type::Enum, 'allowed-scopes', [RakuAST::Type::Enum, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 414 src/Raku/ast/type.rakumod
         $SELF.IMPL-WRAP-LIST(['my', 'our']) 
    });
    add-method(RakuAST::Type::Enum, 'dba', [RakuAST::Type::Enum, '', 0, 0], anon sub dba ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 416 src/Raku/ast/type.rakumod
         'enum' 
    });
    add-method(RakuAST::Type::Enum, 'lexical-name', [RakuAST::Type::Enum, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 418 src/Raku/ast/type.rakumod
         nqp::getattr($SELF, RakuAST::Type::Enum, '$!name').canonicalize 
    });
    add-method(RakuAST::Type::Enum, 'generate-lookup', [RakuAST::Type::Enum, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 420 src/Raku/ast/type.rakumod
        
        my $lookup := RakuAST::Term::Name.new(nqp::getattr($SELF, RakuAST::Type::Enum, '$!name'));
        $lookup.set-resolution($SELF);
        $lookup
    
    });
    add-method(RakuAST::Type::Enum, 'visit-children', [RakuAST::Type::Enum, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 426 src/Raku/ast/type.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Type::Enum, '$!name'));
        $visitor(nqp::getattr($SELF, RakuAST::Type::Enum, '$!term'));
        $visitor(nqp::getattr($SELF, RakuAST::Type::Enum, '$!of'))     if nqp::getattr($SELF, RakuAST::Type::Enum, '$!of');
        $visitor($SELF.WHY) if $SELF.WHY;
    
    });
    add-method(RakuAST::Type::Enum, 'attach', [RakuAST::Type::Enum, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 433 src/Raku/ast/type.rakumod
        
        nqp::bindattr($SELF, RakuAST::Type::Enum, '$!current-package', $resolver.current-package);
    
    });
    add-method(RakuAST::Type::Enum, 'is-lexical', [RakuAST::Type::Enum, '', 0, 0], anon sub is-lexical ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 437 src/Raku/ast/type.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Type::Enum, 'is-simple-lexical-declaration', [RakuAST::Type::Enum, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 438 src/Raku/ast/type.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Type::Enum, 'IMPL-EXPR-QAST', [RakuAST::Type::Enum, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 440 src/Raku/ast/type.rakumod
        
        my $qast := QAST::Op.new(:op('call'), :name('&ENUM_VALUES'), nqp::getattr($SELF, RakuAST::Type::Enum, '$!term').IMPL-EXPR-QAST($context));
        QAST::Want.new(
            $qast,
            'v',
            QAST::Op.new(:op('null'))
        )
    
    });
    add-method(RakuAST::Type::Enum, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Type::Enum, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 449 src/Raku/ast/type.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Pair')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('List')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Stringy')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Numeric'))
        ])
    
    });
    add-method(RakuAST::Type::Enum, 'IMPL-GENERATE-LEXICAL-DECLARATION', [RakuAST::Type::Enum, '', 0, 0, RakuAST::Name, '$name', 0, 0, Mu, '$type-object', 0, 0], anon sub IMPL-GENERATE-LEXICAL-DECLARATION ($SELF_CONT, $name!, $type-object!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $type-object := nqp::decont($type-object);
#line 458 src/Raku/ast/type.rakumod
        
        RakuAST::VarDeclaration::Implicit::Constant.new:
            :name($name),
            :value($type-object),
            :scope($SELF.scope);
    
    });
    add-method(RakuAST::Type::Enum, 'PERFORM-BEGIN', [RakuAST::Type::Enum, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 465 src/Raku/ast/type.rakumod
        
        my $lookups := $SELF.get-implicit-lookups;
        my $Pair    := $lookups.AT-POS(0).resolution.compile-time-value;
        my $List    := $lookups.AT-POS(1).resolution.compile-time-value;
        my $Stringy := $lookups.AT-POS(2).resolution.compile-time-value;
        my $Numeric := $lookups.AT-POS(3).resolution.compile-time-value;

        my $base-type;
        my $has-base-type := (Bool.WHO)<False>;
        if nqp::getattr($SELF, RakuAST::Type::Enum, '$!of') {
            $base-type := nqp::getattr($SELF, RakuAST::Type::Enum, '$!of').compile-time-value;
            $has-base-type := (Bool.WHO)<True>;
        }
        my %values := nqp::hash;
        my $cur-val := nqp::box_i(-1, Int); # Boxed to support .succ
        my $evaluated := $SELF.IMPL-BEGIN-TIME-EVALUATE(nqp::getattr($SELF, RakuAST::Type::Enum, '$!term'), $resolver, $context);
        my $is-settings-list := nqp::istype($evaluated, $List);
        if nqp::istype($evaluated, $Pair) {
            if !$has-base-type {
                # No need for type checking when we are going to get the base-type from the value
                %values{$evaluated.key} := $evaluated.value;
                $base-type := $evaluated.value.WHAT;
            } else {
                unless nqp::istype($evaluated.value, nqp::getattr($SELF, RakuAST::Type::Enum, '$!base-type')) {
                    nqp::die("Incorrect value type provided. Expected '" ~ nqp::getattr($SELF, RakuAST::Type::Enum, '$!base-type').raku ~ "' but got '" ~ $evaluated.value.WHAT.raku ~ "'");
                }
                %values{$evaluated.key} := $evaluated.value;
            }
        } elsif nqp::istype($evaluated, Str) {
            # TODO: What do we actually want to do when base-type is defined but they only provide a single Str?
            #       Base just ignores and uses Int
            # A single string enum will always have 0, but we use $cur-val to keep it boxed
            %values{$evaluated} := $cur-val.succ;
            $base-type := Int;
        } elsif nqp::istype($evaluated, List) || $is-settings-list {
            my @items := $SELF.IMPL-UNWRAP-LIST($evaluated);
            if nqp::elems(@items) == 0 {
                # For empty enums, just default to Int
                $base-type := Int;
            } else {
                for @items {
                    if nqp::istype($_, $Pair) {
                        $cur-val := $_.value;
                        if !$has-base-type {
                            $base-type := $cur-val.WHAT;
                            $has-base-type := (Bool.WHO)<True>;
                        } else {
                            # Should be a panic or a throw, right?
                            unless nqp::istype($cur-val, nqp::getattr($SELF, RakuAST::Type::Enum, '$!base-type')) {
                                nqp::die("Incorrect value type provided. Expected '" ~ nqp::getattr($SELF, RakuAST::Type::Enum, '$!base-type').raku ~ "' but got '" ~ $cur-val.WHAT.raku ~ "'");
                            }
                        }
                        %values{$_.key} := $cur-val;
                    } elsif nqp::istype($_, Str) {
                        if !$has-base-type {
                            # TODO: Again, uncertain what to do when user provides a base type but then only hands a list of Str
                            $base-type := Int;
                            $has-base-type := (Bool.WHO)<True>;
                        }
                        %values{$_} := ($cur-val := $cur-val.succ);
                    }
                }
            }
        }

        # Make $!base-type available, then we can produce the meta-object and add and apply traits
        nqp::bindattr($SELF, RakuAST::Type::Enum, '$!base-type', $base-type);
        my $meta := $SELF.meta-object;
        my $enumeration-kind;
        if nqp::istype($meta, $Numeric) {
            $enumeration-kind := nqp::istype($meta, $Stringy)
                ?? 'NumericStringyEnumeration' # allomorphs
                !! 'NumericEnumeration';
        } elsif nqp::istype($meta, $Stringy) {
            $enumeration-kind := 'StringyEnumeration';
        }
        $SELF.add-trait(RakuAST::Trait::Does.new(
            RakuAST::Type::Simple.new(RakuAST::Name.from-identifier('Enumeration'))
        ));
        if $enumeration-kind {
            $SELF.add-trait(RakuAST::Trait::Does.new(
                RakuAST::Type::Simple.new(RakuAST::Name.from-identifier($enumeration-kind))
            ));
        }
        $SELF.apply-traits($resolver, $context, $SELF);
        $meta.HOW.compose($meta);

        # Don't install an anonymous enum
        my $anonymous := !nqp::getattr($SELF, RakuAST::Type::Enum, '$!name').canonicalize;
        if !$anonymous {
            $SELF.IMPL-INSTALL-PACKAGE(
                $resolver, $SELF.scope, nqp::getattr($SELF, RakuAST::Type::Enum, '$!name'), $meta, nqp::getattr($SELF, RakuAST::Type::Enum, '$!current-package')
            );
        }

        # Create type objects for each value and install into proper scop
        my %stash := $resolver.IMPL-STASH-HASH($anonymous ?? nqp::getattr($SELF, RakuAST::Type::Enum, '$!current-package') !! $meta);
        my $index := 0;
        for %values -> $pair {
            my $key     := $pair.key;
            my $value   := $pair.value;

            if !nqp::defined($value) {
                nqp::die("Using a type object as a value for an enum not yet implemented. Sorry.");
            }

            my $val-meta := nqp::rebless(nqp::clone($value), $meta);
            nqp::bindattr($val-meta, $meta, '$!key', $key);
            nqp::bindattr($val-meta, $meta, '$!value', $value);
            nqp::bindattr_i($val-meta, $meta, '$!index', $index++);
            $context.ensure-sc($val-meta);
            $meta.HOW.add_enum_value($meta, $val-meta);

            # Make sure it is not already defined, eg 'enum Day<Mon Mon>' or 'class Day::Foo {}; enum Day<Mon Foo>'
            # TODO: Base allows both. First raises a 'Potential Difficulties', second succeeds silently.
            #   But perhaps 6.e and moving forward, we could make the logic below the default behavior.
#            if nqp::existskey(%stash, $key) {
#                nqp::die("Redeclaration of symbol '" ~ $key ~ "'.");
#            }
            unless $anonymous && $SELF.scope eq 'my' {
                %stash{$key} := $val-meta;
            }

            # Declare these values into the lexical scope
            # TODO: Bind an X::PoisonedAlias when a lexical already exists
            #   (Which is tricky, because base only does it when there is a clash in the current lexpad...)
            $resolver.current-scope.add-generated-lexical-declaration:
                RakuAST::VarDeclaration::Implicit::Constant.new(
                    :name($key),
                    :scope($SELF.scope),
                    :value($val-meta)
                );
        }
        $meta.HOW.compose_values($meta);
    
    });
    add-method(RakuAST::Type::Enum, 'PRODUCE-META-OBJECT', [RakuAST::Type::Enum, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 601 src/Raku/ast/type.rakumod
        
        Perl6::Metamodel::EnumHOW.new_type(
            :name(nqp::getattr($SELF, RakuAST::Type::Enum, '$!name').canonicalize),
            :base_type(nqp::getattr($SELF, RakuAST::Type::Enum, '$!base-type'))
        )
    
    });
#line 387 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Enum, 'term', [], anon sub term ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Enum, '$!term') });
#line 388 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Enum, 'of', [], anon sub of ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Enum, '$!of') });
#line 386 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Enum, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Enum, '$!name') });
    compose(RakuAST::Type::Enum);
    parent(RakuAST::Type::Subset, RakuAST::Type);
    parent(RakuAST::Type::Subset, RakuAST::Declaration);
    parent(RakuAST::Type::Subset, RakuAST::BeginTime);
    parent(RakuAST::Type::Subset, RakuAST::TraitTarget);
    parent(RakuAST::Type::Subset, RakuAST::StubbyMeta);
    parent(RakuAST::Type::Subset, RakuAST::Attaching);
    parent(RakuAST::Type::Subset, RakuAST::PackageInstaller);
    parent(RakuAST::Type::Subset, RakuAST::Doc::DeclaratorTarget);
    add-attribute(RakuAST::Type::Subset, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Type::Subset, RakuAST::Trait::Of, '$!of');
    add-attribute(RakuAST::Type::Subset, RakuAST::Expression, '$!where');
    add-attribute(RakuAST::Type::Subset, Mu, '$!current-package');
    add-attribute(RakuAST::Type::Subset, Mu, '$!block');
    add-method(RakuAST::Type::Subset, 'new', [RakuAST::Type::Subset, '', 0, 0, str, '$scope', 1, 1, RakuAST::Name, '$name', 1, 0, RakuAST::Trait::Of, '$of', 1, 1, RakuAST::Expression, '$where', 1, 1, List, '$traits', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$scope?, :$name!, :$of?, :$where?, :$traits?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $name := nqp::decont($name);
        $of := nqp::decont($of);
        $where := nqp::decont($where);
        $traits := nqp::decont($traits);
        $WHY := nqp::decont($WHY);
#line 632 src/Raku/ast/type.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::Type::Subset, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Type::Subset, '$!of', $of) if $of;
        if $where {
            # The $!where attribute is for deparsing, the $!block attribute
            # is for the actual action.
            nqp::bindattr($obj, RakuAST::Type::Subset, '$!where', $where);
            nqp::bindattr($obj, RakuAST::Type::Subset, '$!block', $where);
        }
        $obj.set-traits($traits) if $traits;
        $obj.set-WHY($WHY);
        $obj
    
    });
    add-method(RakuAST::Type::Subset, 'set-traits', [RakuAST::Type::Subset, '', 0, 0, Any, '$traits', 0, 0], anon sub set-traits ($SELF_CONT, $traits!) {
        my $SELF := nqp::decont($SELF_CONT);
        $traits := nqp::decont($traits);
#line 648 src/Raku/ast/type.rakumod
        
        for $SELF.IMPL-UNWRAP-LIST($traits) {
            nqp::istype($_, RakuAST::Trait::Of)
              ?? nqp::getattr($SELF, RakuAST::Type::Subset, '$!of')
                ?? nqp::die("Cannot declare more than one 'of' trait per subset")
                !! nqp::bindattr($SELF, RakuAST::Type::Subset, '$!of', $_)
              !! $SELF.add-trait($_);
        }
    
    });
    add-method(RakuAST::Type::Subset, 'default-scope', [RakuAST::Type::Subset, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 658 src/Raku/ast/type.rakumod
         'our' 
    });
    add-method(RakuAST::Type::Subset, 'allowed-scopes', [RakuAST::Type::Subset, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 660 src/Raku/ast/type.rakumod
         $SELF.IMPL-WRAP-LIST(['my', 'our']) 
    });
    add-method(RakuAST::Type::Subset, 'dba', [RakuAST::Type::Subset, '', 0, 0], anon sub dba ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 662 src/Raku/ast/type.rakumod
         'subset' 
    });
    add-method(RakuAST::Type::Subset, 'lexical-name', [RakuAST::Type::Subset, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 664 src/Raku/ast/type.rakumod
         nqp::getattr($SELF, RakuAST::Type::Subset, '$!name').canonicalize 
    });
    add-method(RakuAST::Type::Subset, 'generate-lookup', [RakuAST::Type::Subset, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 666 src/Raku/ast/type.rakumod
        
        my $lookup := RakuAST::Term::Name.new(nqp::getattr($SELF, RakuAST::Type::Subset, '$!name'));
        $lookup.set-resolution($SELF);
        $lookup
    
    });
    add-method(RakuAST::Type::Subset, 'attach', [RakuAST::Type::Subset, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 672 src/Raku/ast/type.rakumod
        
        nqp::bindattr($SELF, RakuAST::Type::Subset, '$!current-package', $resolver.current-package);
    
    });
    add-method(RakuAST::Type::Subset, 'visit-children', [RakuAST::Type::Subset, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 676 src/Raku/ast/type.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Type::Subset, '$!name'));
        $visitor(nqp::getattr($SELF, RakuAST::Type::Subset, '$!block')) if nqp::getattr($SELF, RakuAST::Type::Subset, '$!block');
        # External constants break if visited with missing IMPL-QAST-DECL.
        # Adding a sensible IMPL-QAST-DECL results in lexical declarations
        # for things like Int, which will break if added more than once.
        $visitor(nqp::getattr($SELF, RakuAST::Type::Subset, '$!of'))
          if nqp::getattr($SELF, RakuAST::Type::Subset, '$!of')
          && !nqp::istype(nqp::getattr($SELF, RakuAST::Type::Subset, '$!of'), RakuAST::Declaration::External::Constant);
        $visitor($SELF.WHY) if $SELF.WHY;
    
    });
    add-method(RakuAST::Type::Subset, 'is-lexical', [RakuAST::Type::Subset, '', 0, 0], anon sub is-lexical ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 688 src/Raku/ast/type.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Type::Subset, 'is-simple-lexical-declaration', [RakuAST::Type::Subset, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 689 src/Raku/ast/type.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Type::Subset, 'IMPL-EXPR-QAST', [RakuAST::Type::Subset, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 691 src/Raku/ast/type.rakumod
        
        my $value := $SELF.meta-object;
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
    add-method(RakuAST::Type::Subset, 'IMPL-GENERATE-LEXICAL-DECLARATION', [RakuAST::Type::Subset, '', 0, 0, RakuAST::Name, '$name', 0, 0, Mu, '$type-object', 0, 0], anon sub IMPL-GENERATE-LEXICAL-DECLARATION ($SELF_CONT, $name!, $type-object!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $type-object := nqp::decont($type-object);
#line 697 src/Raku/ast/type.rakumod
        
        RakuAST::VarDeclaration::Implicit::Constant.new:
            :name($name),
            :value($type-object),
            :scope($SELF.scope);
    
    });
    add-method(RakuAST::Type::Subset, 'is-begin-performed-after-children', [RakuAST::Type::Subset, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 704 src/Raku/ast/type.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Type::Subset, 'PERFORM-BEGIN-AFTER-CHILDREN', [RakuAST::Type::Subset, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-AFTER-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 706 src/Raku/ast/type.rakumod
        
        $SELF.apply-traits($resolver, $context, $SELF);

        my $block := nqp::getattr($SELF, RakuAST::Type::Subset, '$!block');
        if $block
          && !$block.IMPL-CURRIED
          && (!nqp::istype($block, RakuAST::Code)
               || nqp::istype($block, RakuAST::RegexThunk
             )
        ) {
            $block := RakuAST::Block.new(
                body => RakuAST::Blockoid.new(
                    RakuAST::StatementList.new(
                        RakuAST::Statement::Expression.new(
                            expression => RakuAST::ApplyPostfix.new(
                                operand => RakuAST::ApplyPostfix.new(
                                    operand => nqp::getattr($SELF, RakuAST::Type::Subset, '$!block'),
                                    postfix => RakuAST::Call::Method.new(
                                        name => RakuAST::Name.from-identifier('ACCEPTS'),
                                        args => RakuAST::ArgList.new(
                                            RakuAST::Var::Lexical.new('$_'),
                                        ),
                                    ),
                                ),
                                postfix => RakuAST::Call::Method.new(
                                    name => RakuAST::Name.from-identifier('Bool'),
                                ),
                            ),
                        ),
                    ),
                ),
            );
            nqp::bindattr($SELF, RakuAST::Type::Subset, '$!block', $block);
            $block.IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);
        }

        # set up the meta object
        my $package := nqp::getattr($SELF, RakuAST::Type::Subset, '$!current-package');
        my $type    := $SELF.stubbed-meta-object;
        $type.HOW.set_name(
          $type,
          nqp::getattr($SELF, RakuAST::Type::Subset, '$!name').qualified-with(
            RakuAST::Name.from-identifier-parts(
              |nqp::split('::', $package.HOW.name($package))
            )
          ).canonicalize(:colonpairs(0))
        ) unless nqp::eqaddr($package, $resolver.get-global);
        # Update the Stash's name, too.
        nqp::bindattr_s($type.WHO, Stash, '$!longname', $type.HOW.name($type));

        $SELF.IMPL-INSTALL-PACKAGE(
          $resolver, $SELF.scope, nqp::getattr($SELF, RakuAST::Type::Subset, '$!name'), $type, $package
        );
    
    });
    add-method(RakuAST::Type::Subset, 'PRODUCE-STUBBED-META-OBJECT', [RakuAST::Type::Subset, '', 0, 0], anon sub PRODUCE-STUBBED-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 761 src/Raku/ast/type.rakumod
        
        Perl6::Metamodel::SubsetHOW.new_type(
            :name(nqp::getattr($SELF, RakuAST::Type::Subset, '$!name').canonicalize),
            :refinee(Any),
            :refinement(Any)
        )
    
    });
    add-method(RakuAST::Type::Subset, 'PRODUCE-META-OBJECT', [RakuAST::Type::Subset, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 769 src/Raku/ast/type.rakumod
        
        my $type  := $SELF.stubbed-meta-object;
        my $block := nqp::getattr($SELF, RakuAST::Type::Subset, '$!block');

        $type.HOW.set_of($type, nqp::getattr($SELF, RakuAST::Type::Subset, '$!of').type.meta-object)
          if nqp::getattr($SELF, RakuAST::Type::Subset, '$!of');
        $type.HOW.set_where($type, $block
          ?? $block.IMPL-CURRIED
            ?? $block.IMPL-CURRIED.meta-object
            !! $block.compile-time-value
          !! Mu
        );

        $type
    
    });
#line 621 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Subset, 'where', [], anon sub where ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Subset, '$!where') });
#line 620 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Subset, 'of', [], anon sub of ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Subset, '$!of') });
#line 619 src/Raku/ast/type.rakumod
    add-method(RakuAST::Type::Subset, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Type::Subset, '$!name') });
    compose(RakuAST::Type::Subset);
    parent(RakuAST::Initializer, RakuAST::Node);
    add-attribute(RakuAST::Initializer, RakuAST::ExpressionThunk, '$!thunk');
    add-method(RakuAST::Initializer, 'is-binding', [RakuAST::Initializer, '', 0, 0], anon sub is-binding ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 8 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Initializer, 'IMPL-COMPILE-TIME-VALUE', [RakuAST::Initializer, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-compiler', 1, 1], anon sub IMPL-COMPILE-TIME-VALUE ($SELF_CONT, $resolver!, $context!, :$invocant-compiler?) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $invocant-compiler := nqp::decont($invocant-compiler);
#line 12 src/Raku/ast/variable-declaration.rakumod
        
        RakuAST::BeginTime.IMPL-BEGIN-TIME-EVALUATE($SELF.expression, $resolver, $context);
    
    });
    add-method(RakuAST::Initializer, 'IMPL-THUNK-EXPRESSION', [RakuAST::Initializer, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-THUNK-EXPRESSION ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 16 src/Raku/ast/variable-declaration.rakumod
        
        my $expression := $SELF.expression;
        my $thunk := Nil;
        unless (nqp::istype($expression, RakuAST::Code)) {
            $thunk := $expression.outer-most-thunk;
            unless ($thunk) {
                $thunk := RakuAST::ExpressionThunk.new;
                $expression.wrap-with-thunk($thunk);
                $thunk.IMPL-STUB-CODE($resolver, $context);
            }
            nqp::bindattr($SELF, RakuAST::Initializer, '$!thunk', $thunk);
        }
    
    });
    add-method(RakuAST::Initializer, 'IMPL-QAST-DECL', [RakuAST::Initializer, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 30 src/Raku/ast/variable-declaration.rakumod
        
        my $expression := $SELF.expression;
        nqp::istype($expression, RakuAST::Code)
            ?? $expression.IMPL-TO-QAST($context)
            !! nqp::getattr($SELF, RakuAST::Initializer, '$!thunk').IMPL-QAST-BLOCK($context, :expression($expression))
    
    });
    compose(RakuAST::Initializer);
    parent(RakuAST::Initializer::Assign, RakuAST::Initializer);
    add-attribute(RakuAST::Initializer::Assign, RakuAST::Expression, '$!expression');
    add-method(RakuAST::Initializer::Assign, 'new', [RakuAST::Initializer::Assign, '', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub new ($SELF_CONT, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 44 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        $obj.set-expression($expression);
        $obj
    
    });
    add-method(RakuAST::Initializer::Assign, 'set-expression', [RakuAST::Initializer::Assign, '', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub set-expression ($SELF_CONT, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 50 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::Initializer::Assign, '$!expression',
          $expression // RakuAST::Expression);
    
    });
    add-method(RakuAST::Initializer::Assign, 'visit-children', [RakuAST::Initializer::Assign, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 55 src/Raku/ast/variable-declaration.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Initializer::Assign, '$!expression'));
    
    });
    add-method(RakuAST::Initializer::Assign, 'IMPL-TO-QAST', [RakuAST::Initializer::Assign, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 1, 1], anon sub IMPL-TO-QAST ($SELF_CONT, $context!, :$invocant-qast?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 59 src/Raku/ast/variable-declaration.rakumod
        
        nqp::getattr($SELF, RakuAST::Initializer::Assign, '$!expression').IMPL-TO-QAST($context)
    
    });
#line 42 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::Initializer::Assign, 'expression', [], anon sub expression ($self) { nqp::getattr(nqp::decont($self), RakuAST::Initializer::Assign, '$!expression') });
    compose(RakuAST::Initializer::Assign);
    parent(RakuAST::Initializer::Bind, RakuAST::Initializer);
    add-attribute(RakuAST::Initializer::Bind, RakuAST::Expression, '$!expression');
    add-method(RakuAST::Initializer::Bind, 'new', [RakuAST::Initializer::Bind, '', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub new ($SELF_CONT, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 70 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        $obj.set-expression($expression);
        $obj
    
    });
    add-method(RakuAST::Initializer::Bind, 'set-expression', [RakuAST::Initializer::Bind, '', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub set-expression ($SELF_CONT, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 76 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::Initializer::Bind, '$!expression',
            $expression // RakuAST::Expression);
        Nil
    
    });
    add-method(RakuAST::Initializer::Bind, 'is-binding', [RakuAST::Initializer::Bind, '', 0, 0], anon sub is-binding ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 82 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Initializer::Bind, 'visit-children', [RakuAST::Initializer::Bind, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 84 src/Raku/ast/variable-declaration.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Initializer::Bind, '$!expression'));
    
    });
    add-method(RakuAST::Initializer::Bind, 'IMPL-TO-QAST', [RakuAST::Initializer::Bind, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 1, 1], anon sub IMPL-TO-QAST ($SELF_CONT, $context!, :$invocant-qast?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 88 src/Raku/ast/variable-declaration.rakumod
        
        nqp::getattr($SELF, RakuAST::Initializer::Bind, '$!expression').IMPL-TO-QAST($context)
    
    });
#line 68 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::Initializer::Bind, 'expression', [], anon sub expression ($self) { nqp::getattr(nqp::decont($self), RakuAST::Initializer::Bind, '$!expression') });
    compose(RakuAST::Initializer::Bind);
    parent(RakuAST::Initializer::CallAssign, RakuAST::Initializer);
    add-attribute(RakuAST::Initializer::CallAssign, RakuAST::Postfixish, '$!postfixish');
    add-method(RakuAST::Initializer::CallAssign, 'new', [RakuAST::Initializer::CallAssign, '', 0, 0, RakuAST::Postfixish, '$postfixish', 0, 0], anon sub new ($SELF_CONT, $postfixish!) {
        my $SELF := nqp::decont($SELF_CONT);
        $postfixish := nqp::decont($postfixish);
#line 99 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Initializer::CallAssign, '$!postfixish', $postfixish);
        $obj
    
    });
    add-method(RakuAST::Initializer::CallAssign, 'visit-children', [RakuAST::Initializer::CallAssign, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 105 src/Raku/ast/variable-declaration.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Initializer::CallAssign, '$!postfixish'));
    
    });
    add-method(RakuAST::Initializer::CallAssign, 'IMPL-TO-QAST', [RakuAST::Initializer::CallAssign, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-qast', 1, 1], anon sub IMPL-TO-QAST ($SELF_CONT, $context!, :$invocant-qast?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $invocant-qast := nqp::decont($invocant-qast);
#line 109 src/Raku/ast/variable-declaration.rakumod
        
        nqp::getattr($SELF, RakuAST::Initializer::CallAssign, '$!postfixish').IMPL-POSTFIX-QAST($context, $invocant-qast)
    
    });
    add-method(RakuAST::Initializer::CallAssign, 'IMPL-COMPILE-TIME-VALUE', [RakuAST::Initializer::CallAssign, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$invocant-compiler', 1, 1], anon sub IMPL-COMPILE-TIME-VALUE ($SELF_CONT, $resolver!, $context!, :$invocant-compiler?) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $invocant-compiler := nqp::decont($invocant-compiler);
#line 115 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.postfixish.IMPL-INTERPRET(RakuAST::IMPL::InterpContext.new, $invocant-compiler)
    
    });
    add-method(RakuAST::Initializer::CallAssign, 'IMPL-THUNK-EXPRESSION', [RakuAST::Initializer::CallAssign, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-THUNK-EXPRESSION ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 119 src/Raku/ast/variable-declaration.rakumod
        
        Nil
    
    });
    add-method(RakuAST::Initializer::CallAssign, 'IMPL-QAST-DECL', [RakuAST::Initializer::CallAssign, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 123 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Op.new(:op<null>)
    
    });
#line 97 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::Initializer::CallAssign, 'postfixish', [], anon sub postfixish ($self) { nqp::getattr(nqp::decont($self), RakuAST::Initializer::CallAssign, '$!postfixish') });
    compose(RakuAST::Initializer::CallAssign);
    parent(RakuAST::ContainerCreator, Any);
    add-attribute(RakuAST::ContainerCreator, Mu, '$!container-base-type');
    add-attribute(RakuAST::ContainerCreator, Bool, '$!forced-dynamic');
    add-method(RakuAST::ContainerCreator, 'IMPL-SET-CONTAINER-BASE-TYPE', [RakuAST::ContainerCreator, '', 0, 0, Mu, '$type', 0, 0], anon sub IMPL-SET-CONTAINER-BASE-TYPE ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 132 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::ContainerCreator, '$!container-base-type', $type);
    
    });
    add-method(RakuAST::ContainerCreator, 'IMPL-HAS-CONTAINER-BASE-TYPE', [RakuAST::ContainerCreator, '', 0, 0], anon sub IMPL-HAS-CONTAINER-BASE-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 136 src/Raku/ast/variable-declaration.rakumod
        
        !nqp::eqaddr(nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type'), Mu)
    
    });
    add-method(RakuAST::ContainerCreator, 'IMPL-CONTAINER-BASE-TYPE', [RakuAST::ContainerCreator, '', 0, 0], anon sub IMPL-CONTAINER-BASE-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 140 src/Raku/ast/variable-declaration.rakumod
        
        nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type')
    
    });
    add-method(RakuAST::ContainerCreator, 'IMPL-CONTAINER-DESCRIPTOR', [RakuAST::ContainerCreator, '', 0, 0, Mu, '$of', 0, 0], anon sub IMPL-CONTAINER-DESCRIPTOR ($SELF_CONT, $of!) {
        my $SELF := nqp::decont($SELF_CONT);
        $of := nqp::decont($of);
#line 144 src/Raku/ast/variable-declaration.rakumod
        
        # If it's a natively typed scalar, no container.
        my str $sigil := $SELF.sigil;
        my int $is-native := nqp::objprimspec($of);
        if $sigil eq '$' && $is-native {
            return Nil;
        }

        # Form container descriptor.
        my $default := $SELF.type ?? $of !! Any;
        my int $dynamic := $SELF.twigil eq '*' ?? 1 !! $SELF.forced-dynamic ?? 1 !! 0;
        (
            nqp::eqaddr($of, Mu)
            ?? ContainerDescriptor::Untyped
            !! ContainerDescriptor
        ).new(:$of, :$default, :$dynamic, :name($SELF.lexical-name))
    
    });
    add-method(RakuAST::ContainerCreator, 'IMPL-CONTAINER-TYPE', [RakuAST::ContainerCreator, '', 0, 0, Mu, '$of', 0, 0, Mu, '$key-type', 1, 1], anon sub IMPL-CONTAINER-TYPE ($SELF_CONT, $of!, :$key-type?) {
        my $SELF := nqp::decont($SELF_CONT);
        $of := nqp::decont($of);
        $key-type := nqp::decont($key-type);
#line 162 src/Raku/ast/variable-declaration.rakumod
        
        # Form the container type.
        my str $sigil := $SELF.sigil;
        my $container-type;
        if nqp::eqaddr(nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type'), Mu) {
            if $sigil eq '@' {
                my $container-base-type := nqp::objprimspec($of) ?? array !! Array;
                $container-type := $SELF.type
                    ?? $container-base-type.HOW.parameterize($container-base-type, $of)
                    !! Array;
            }
            elsif $sigil eq '%' {
                $container-type := $key-type =:= NQPMu
                  ?? $SELF.type
                    ?? Hash.HOW.parameterize(Hash, $of)
                    !! Hash
                  !! Hash.HOW.parameterize(
                       Hash,
                       $SELF.type ?? $of !! nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type'),
                       $key-type
                     )
            }
            else {
                $container-type := $of
            }
            $container-type
        }
        else {
            $SELF.type
                ?? nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type').HOW.parameterize(nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type'), $of)
                !! nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type')
        }
    
    });
    add-method(RakuAST::ContainerCreator, 'IMPL-CONTAINER', [RakuAST::ContainerCreator, '', 0, 0, Mu, '$of', 0, 0, Mu, '$cont-desc', 0, 0], anon sub IMPL-CONTAINER ($SELF_CONT, $of!, $cont-desc!) {
        my $SELF := nqp::decont($SELF_CONT);
        $of := nqp::decont($of);
        $cont-desc := nqp::decont($cont-desc);
#line 196 src/Raku/ast/variable-declaration.rakumod
        
        # Form the container.
        my $default := $SELF.type ?? $of !! Any;
        my str $sigil := $SELF.sigil;
        my $container-base-type;
        my $container-type;
        if nqp::eqaddr(nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type'), Mu) {
            if $sigil eq '@' {
                $container-base-type := nqp::objprimspec($of) ?? array !! Array;
                $container-type := $SELF.type
                    ?? $container-base-type.HOW.parameterize($container-base-type, $of)
                    !! Array;
            }
            elsif $sigil eq '%' {
                $container-base-type := Hash;
                $container-type := $SELF.type
                    ?? Hash.HOW.parameterize(Hash, $of)
                    !! Hash;
            }
            else {
                if nqp::objprimspec($of) {
                    nqp::die("Natively typed state variables not yet implemented") if $SELF.scope eq 'state';
                    return nqp::null;
                }

                $container-base-type := Scalar;
                $container-type := Scalar;
            }
            my $container := nqp::create($container-type);
            try nqp::bindattr($container, $container-base-type, '$!descriptor', $cont-desc);
            unless $sigil eq '@' || $sigil eq '%' {
                nqp::bindattr($container, $container-base-type, '$!value', $default);
            }
            $container
        }
        else {
            nqp::getattr($SELF, RakuAST::ContainerCreator, '$!container-base-type')
        }
    
    });
#line 130 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::ContainerCreator, 'forced-dynamic', [], anon sub forced-dynamic ($self) { nqp::getattr(nqp::decont($self), RakuAST::ContainerCreator, '$!forced-dynamic') });
    compose(RakuAST::ContainerCreator);
    parent(RakuAST::TraitTarget::Variable, RakuAST::TraitTarget);
    parent(RakuAST::TraitTarget::Variable, RakuAST::Meta);
    parent(RakuAST::TraitTarget::Variable, RakuAST::ImplicitLookups);
    parent(RakuAST::TraitTarget::Variable, RakuAST::BeginTime);
    add-attribute(RakuAST::TraitTarget::Variable, str, '$!name');
    add-attribute(RakuAST::TraitTarget::Variable, str, '$!scope');
    add-attribute(RakuAST::TraitTarget::Variable, Mu, '$!cont');
    add-attribute(RakuAST::TraitTarget::Variable, Mu, '$!code-object');
    add-attribute(RakuAST::TraitTarget::Variable, Mu, '$!slash');
    add-method(RakuAST::TraitTarget::Variable, 'new', [RakuAST::TraitTarget::Variable, '', 0, 0, str, '$name', 0, 0, str, '$scope', 0, 0, Mu, '$cont', 0, 0, Mu, '$code-object', 0, 0, Mu, '$slash', 0, 0], anon sub new ($SELF_CONT, $name!, $scope!, $cont!, $code-object!, $slash!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $scope := nqp::decont($scope);
        $cont := nqp::decont($cont);
        $code-object := nqp::decont($code-object);
        $slash := nqp::decont($slash);
#line 249 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::TraitTarget::Variable, '$!name', $name);
        nqp::bindattr_s($obj, RakuAST::TraitTarget::Variable, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::TraitTarget::Variable, '$!cont', $cont);
        nqp::bindattr($obj, RakuAST::TraitTarget::Variable, '$!code-object', $code-object);
        nqp::bindattr($obj, RakuAST::TraitTarget::Variable, '$!slash', $slash);
        $obj
    
    });
    add-method(RakuAST::TraitTarget::Variable, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::TraitTarget::Variable, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 259 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Variable')),
        ])
    
    });
    add-method(RakuAST::TraitTarget::Variable, 'PERFORM-BEGIN', [RakuAST::TraitTarget::Variable, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 265 src/Raku/ast/variable-declaration.rakumod
        
    
    });
    add-method(RakuAST::TraitTarget::Variable, 'PRODUCE-META-OBJECT', [RakuAST::TraitTarget::Variable, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 268 src/Raku/ast/variable-declaration.rakumod
        
        my $Variable  := $SELF.get-implicit-lookups.AT-POS(0).compile-time-value;
        my $varvar := nqp::create($Variable);
        nqp::bindattr_s($varvar, $Variable, '$!name', nqp::getattr_s($SELF, RakuAST::TraitTarget::Variable, '$!name'));
        nqp::bindattr_s($varvar, $Variable, '$!scope', nqp::getattr_s($SELF, RakuAST::TraitTarget::Variable, '$!scope'));
        nqp::bindattr($varvar, $Variable, '$!var', nqp::getattr($SELF, RakuAST::TraitTarget::Variable, '$!cont'));
        nqp::bindattr($varvar, $Variable, '$!block', nqp::getattr($SELF, RakuAST::TraitTarget::Variable, '$!code-object'));
        nqp::bindattr($varvar, $Variable, '$!slash', nqp::getattr($SELF, RakuAST::TraitTarget::Variable, '$!slash'));
        nqp::assign(
            nqp::getattr($varvar, $Variable, '$!implicit-lexical-usage'),
            (Bool.WHO)<True>);
        $varvar
    
    });
    compose(RakuAST::TraitTarget::Variable);
    parent(RakuAST::VarDeclaration::Constant, RakuAST::Declaration);
    parent(RakuAST::VarDeclaration::Constant, RakuAST::TraitTarget);
    parent(RakuAST::VarDeclaration::Constant, RakuAST::Attaching);
    parent(RakuAST::VarDeclaration::Constant, RakuAST::BeginTime);
    parent(RakuAST::VarDeclaration::Constant, RakuAST::CheckTime);
    parent(RakuAST::VarDeclaration::Constant, RakuAST::CompileTimeValue);
    parent(RakuAST::VarDeclaration::Constant, RakuAST::ImplicitLookups);
    parent(RakuAST::VarDeclaration::Constant, RakuAST::Term);
    add-attribute(RakuAST::VarDeclaration::Constant, str, '$!name');
    add-attribute(RakuAST::VarDeclaration::Constant, RakuAST::Initializer, '$!initializer');
    add-attribute(RakuAST::VarDeclaration::Constant, RakuAST::Type, '$!type');
    add-attribute(RakuAST::VarDeclaration::Constant, Mu, '$!value');
    add-attribute(RakuAST::VarDeclaration::Constant, Mu, '$!package');
    add-method(RakuAST::VarDeclaration::Constant, 'new', [RakuAST::VarDeclaration::Constant, '', 0, 0, str, '$scope', 1, 1, RakuAST::Type, '$type', 1, 1, str, '$name', 1, 0, RakuAST::Initializer, '$initializer', 1, 0, List, '$traits', 1, 1], anon sub new ($SELF_CONT, :$scope?, :$type?, :$name!, :$initializer!, :$traits?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $type := nqp::decont($type);
        $name := nqp::decont($name);
        $initializer := nqp::decont($initializer);
        $traits := nqp::decont($traits);
#line 306 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Constant,'$!name',$name);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Constant, '$!initializer',
            $initializer // RakuAST::Initializer);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Constant, '$!type',
          $type // RakuAST::Type);
        $obj.set-traits($traits) if $traits;
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'lexical-name', [RakuAST::VarDeclaration::Constant, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 318 src/Raku/ast/variable-declaration.rakumod
         nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name') 
    });
    add-method(RakuAST::VarDeclaration::Constant, 'default-scope', [RakuAST::VarDeclaration::Constant, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 319 src/Raku/ast/variable-declaration.rakumod
         'our'   
    });
    add-method(RakuAST::VarDeclaration::Constant, 'allowed-scopes', [RakuAST::VarDeclaration::Constant, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 320 src/Raku/ast/variable-declaration.rakumod
         $SELF.IMPL-WRAP-LIST(['my', 'our']) 
    });
    add-method(RakuAST::VarDeclaration::Constant, 'is-simple-lexical-declaration', [RakuAST::VarDeclaration::Constant, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 321 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::VarDeclaration::Constant, 'needs-sink-call', [RakuAST::VarDeclaration::Constant, '', 0, 0], anon sub needs-sink-call ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 322 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::VarDeclaration::Constant, 'attach', [RakuAST::VarDeclaration::Constant, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 324 src/Raku/ast/variable-declaration.rakumod
        
        if $SELF.scope eq 'our' {
            # There is always a package, even if it's just GLOBALish
            nqp::bindattr(
              $SELF, RakuAST::VarDeclaration::Constant, '$!package',
              $resolver.current-package
            );
        }
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::VarDeclaration::Constant, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 334 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!type') ?? [nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!type')] !! [])
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'visit-children', [RakuAST::VarDeclaration::Constant, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 338 src/Raku/ast/variable-declaration.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!type')) if nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!type');
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!initializer')) if nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!initializer');
        $SELF.visit-traits($visitor);
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'PERFORM-BEGIN', [RakuAST::VarDeclaration::Constant, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 347 src/Raku/ast/variable-declaration.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!initializer').IMPL-COMPILE-TIME-VALUE(
            $resolver, $context, :invocant-compiler(-> { nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!type').IMPL-BASE-TYPE.meta-object }));
        $value := Map.new($value)
          if nqp::eqat(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name'),'%',0)
          && nqp::istype($value,List);
        nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!initializer').IMPL-THUNK-EXPRESSION($resolver, $context);
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Constant, '$!value', $value);

        if $SELF.scope eq 'our' {
            my $name := nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name');
            if nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!package').WHO.EXISTS-KEY($name) {
                nqp::die("already have an 'our constant $name' in the package");
            }
        }

        $SELF.apply-traits(
          $resolver, $context, $SELF, :SYMBOL(RakuAST::StrLiteral.new(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name')))
        );
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'PERFORM-CHECK', [RakuAST::VarDeclaration::Constant, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 371 src/Raku/ast/variable-declaration.rakumod
        
        if nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!type') {
            my $type :=
              $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;

            unless nqp::istype(nqp::what(nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!value')), $type) {
                my $name := nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name');
                $SELF.add-sorry:
                  $resolver.build-exception: 'X::Comp::TypeCheck',
                    operation => 'constant declaration of ' ~ ($name || '<anon>'),
                    expected  => $type,
                    got       => nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!value');
                return (Bool.WHO)<False>;
            }
        }
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Constant, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 389 src/Raku/ast/variable-declaration.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!value');
        $context.ensure-sc($value);
        my $constant := QAST::Stmts.new(
            nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!initializer').IMPL-QAST-DECL($context),
            QAST::Var.new(
              :decl('static'), :scope('lexical'), :name(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name')), :value(nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!value'))
            )
        );
        if $SELF.scope eq 'our' {
            $context.ensure-sc(nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!package'));
            QAST::Op.new(
                :op('callmethod'), :name('BIND-KEY'),
                QAST::Op.new(:op('who'), QAST::WVal.new(:value(nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!package')))),
                QAST::SVal.new(:value(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name'))),
                $constant
            )
        }
        else {
            $constant
        }
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'compile-time-value', [RakuAST::VarDeclaration::Constant, '', 0, 0], anon sub compile-time-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 412 src/Raku/ast/variable-declaration.rakumod
         nqp::getattr($SELF, RakuAST::VarDeclaration::Constant, '$!value') 
    });
    add-method(RakuAST::VarDeclaration::Constant, 'IMPL-LOOKUP-QAST', [RakuAST::VarDeclaration::Constant, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 414 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new(:name(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name')), :scope<lexical>)
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'IMPL-EXPR-QAST', [RakuAST::VarDeclaration::Constant, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 418 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::VarDeclaration::Constant, 'IMPL-TO-QAST', [RakuAST::VarDeclaration::Constant, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 422 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new(:name(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Constant, '$!name')), :scope<lexical>);
    
    });
#line 296 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Constant, 'type', [], anon sub type ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Constant, '$!type') });
#line 294 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Constant, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::VarDeclaration::Constant, '$!name') });
#line 295 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Constant, 'initializer', [], anon sub initializer ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Constant, '$!initializer') });
    compose(RakuAST::VarDeclaration::Constant);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::Declaration);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::ImplicitLookups);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::TraitTarget);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::ContainerCreator);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::Meta);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::Attaching);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::BeginTime);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::CheckTime);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::Term);
    parent(RakuAST::VarDeclaration::Simple, RakuAST::Doc::DeclaratorTarget);
    add-attribute(RakuAST::VarDeclaration::Simple, RakuAST::Type, '$!type');
    add-attribute(RakuAST::VarDeclaration::Simple, RakuAST::Name, '$!desigilname');
    add-attribute(RakuAST::VarDeclaration::Simple, str, '$!sigil');
    add-attribute(RakuAST::VarDeclaration::Simple, str, '$!twigil');
    add-attribute(RakuAST::VarDeclaration::Simple, str, '$!storage-name');
    add-attribute(RakuAST::VarDeclaration::Simple, RakuAST::Initializer, '$!initializer');
    add-attribute(RakuAST::VarDeclaration::Simple, RakuAST::SemiList, '$!shape');
    add-attribute(RakuAST::VarDeclaration::Simple, RakuAST::Package, '$!attribute-package');
    add-attribute(RakuAST::VarDeclaration::Simple, RakuAST::Method, '$!accessor');
    add-attribute(RakuAST::VarDeclaration::Simple, RakuAST::Type, '$!conflicting-type');
    add-attribute(RakuAST::VarDeclaration::Simple, Mu, '$!container-initializer');
    add-attribute(RakuAST::VarDeclaration::Simple, Mu, '$!package');
    add-method(RakuAST::VarDeclaration::Simple, 'new', [RakuAST::VarDeclaration::Simple, '', 0, 0, str, '$scope', 1, 1, RakuAST::Name, '$desigilname', 1, 0, str, '$sigil', 1, 1, str, '$twigil', 1, 1, RakuAST::Type, '$type', 1, 1, List, '$traits', 1, 1, RakuAST::Initializer, '$initializer', 1, 1, RakuAST::SemiList, '$shape', 1, 1, Bool, '$forced-dynamic', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$scope?, :$desigilname!, :$sigil?, :$twigil?, :$type?, :$traits?, :$initializer?, :$shape?, :$forced-dynamic?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $desigilname := nqp::decont($desigilname);
        $sigil := nqp::decont($sigil);
        $twigil := nqp::decont($twigil);
        $type := nqp::decont($type);
        $traits := nqp::decont($traits);
        $initializer := nqp::decont($initializer);
        $shape := nqp::decont($shape);
        $forced-dynamic := nqp::decont($forced-dynamic);
        $WHY := nqp::decont($WHY);
#line 465 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        if $desigilname.is-empty {
            nqp::die('Cannot use RakuAST::VarDeclaration::Simple to declare an anonymous variable; use RakuAST::VarDeclaration::Anonymous');
        }

        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Simple, '$!desigilname', $desigilname);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Simple, '$!sigil', $sigil);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Simple, '$!twigil', $twigil || '');

        nqp::bindattr($obj, RakuAST::VarDeclaration::Simple, '$!type',
          $type // RakuAST::Type);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Simple, '$!shape',
          $shape // RakuAST::SemiList);
        $obj.set-traits($traits);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Simple, '$!initializer',
            $initializer // RakuAST::Initializer);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Simple, '$!accessor',
          RakuAST::Method);
        nqp::bindattr($obj, RakuAST::ContainerCreator, '$!forced-dynamic',
          $forced-dynamic ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);

        if $WHY {
            $scope && $scope eq 'has'
              ?? $obj.set-WHY($WHY)
              !! nqp::die("Declarator doc only supported on scope 'has'");
        }

        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'set-initializer', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::Initializer, '$initializer', 0, 0], anon sub set-initializer ($SELF_CONT, $initializer!) {
        my $SELF := nqp::decont($SELF_CONT);
        $initializer := nqp::decont($initializer);
#line 497 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer',
            $initializer // RakuAST::Initializer);
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'name', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 502 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.sigil ~ $SELF.twigil ~ nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!desigilname').canonicalize;
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'lexical-name', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 506 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.twigil eq '.' ?? $SELF.sigil ~ '!' ~ $SELF.desigilname.canonicalize !! $SELF.name
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'set-type', [RakuAST::VarDeclaration::Simple, '', 0, 0, Any, '$type', 0, 0], anon sub set-type ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 510 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Simple, '$!type', $type);
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'generate-lookup', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 515 src/Raku/ast/variable-declaration.rakumod
        
        if $SELF.is-lexical {
            my $lookup := RakuAST::Var::Lexical.new($SELF.name);
            $lookup.set-resolution($SELF);
            $lookup
        }
        else {
            nqp::die('Cannot generate lookup of simple var for scope ' ~ $SELF.scope);
        }
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'can-be-bound-to', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 526 src/Raku/ast/variable-declaration.rakumod
        
        # Must be lexical and non-native.
        if $SELF.scope eq 'my' || $SELF.scope eq 'state' {
            my str $sigil := $SELF.sigil;
            return (Bool.WHO)<True> if $sigil eq '@' || $sigil eq '%';
            return (Bool.WHO)<True> unless nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type');
            return (Bool.WHO)<True> unless nqp::objprimspec(
              $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value
            );
        }
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'visit-children', [RakuAST::VarDeclaration::Simple, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 539 src/Raku/ast/variable-declaration.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type'))        if nqp::isconcrete(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type'));
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer')) if nqp::isconcrete(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer'));
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape'))       if nqp::isconcrete(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape'));
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!accessor'))    if nqp::isconcrete(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!accessor'));
        $SELF.visit-traits($visitor);
        $visitor($SELF.WHY) if $SELF.WHY;
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'default-scope', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 548 src/Raku/ast/variable-declaration.rakumod
        
        'my'
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'allowed-scopes', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 552 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-WRAP-LIST(['my', 'state', 'our', 'has', 'HAS'])
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'is-lexical', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub is-lexical ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 556 src/Raku/ast/variable-declaration.rakumod
        
        # Overridden here because our-scoped variables are really lexical aliases.
        my str $scope := $SELF.scope;
        $scope eq 'my' || $scope eq 'state' || $scope eq 'our'
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'attach', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 562 src/Raku/ast/variable-declaration.rakumod
        
        my str $scope := $SELF.scope;
        if $scope eq 'has' || $scope eq 'HAS' || $SELF.twigil eq '.' {
            my $attribute-package := $resolver.find-attach-target('package');
            if $attribute-package {
                nqp::bindattr($SELF, RakuAST::VarDeclaration::Simple, '$!attribute-package',
                    $attribute-package);
            }
            else {
                # TODO check-time error
            }
        }
        elsif $scope eq 'our' || nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!desigilname').is-multi-part {
            my $package := $resolver.current-package;
            # There is always a package, even if it's just GLOBALish
            nqp::bindattr($SELF, RakuAST::VarDeclaration::Simple, '$!package',
                $package);
        }
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'PERFORM-BEGIN', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 582 src/Raku/ast/variable-declaration.rakumod
        
        my str $scope := $SELF.scope;
        if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!attribute-package') && ($scope eq 'has' || $scope eq 'HAS') {
            nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!attribute-package').ATTACH-ATTRIBUTE($SELF);
        }

        # Process traits for `is Type` and `of Type`, which get special
        # handling by the compiler.
        my @late-traits;
        my @traits := $SELF.IMPL-UNWRAP-LIST($SELF.traits);

        for @traits {
            if nqp::istype($_, RakuAST::Trait::Of) {
                nqp::bindattr($SELF, RakuAST::VarDeclaration::Simple, '$!conflicting-type', nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type')) if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type');
                nqp::bindattr($SELF, RakuAST::VarDeclaration::Simple, '$!type', $_.type);
                next;
            }
            elsif nqp::istype($_, RakuAST::Trait::Is) {
                my $type := $_.resolved-name;

                # an actual type
                if nqp::isconcrete($type) && !$_.argument && $type.is-resolved {
                    $SELF.IMPL-SET-CONTAINER-BASE-TYPE($type.resolution.compile-time-value);
                    next;
                }
            }
            nqp::push(@late-traits, $_);
        }

        # Apply any traits.
        $SELF.set-traits($SELF.IMPL-WRAP-LIST(@late-traits));

        if $scope eq 'has' || $scope eq 'HAS' {
            if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape') || $SELF.IMPL-HAS-CONTAINER-BASE-TYPE {
                my $args := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape')
                    ?? RakuAST::ArgList.new(
                        RakuAST::ColonPair::Value.new(:key<shape>, :value(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape')))
                    )
                    !! RakuAST::ArgList.new;
                my $of := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type')
                  ?? $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value
                  !! Mu;
                my $container-initializer-ast := RakuAST::ApplyPostfix.new(
                    operand => RakuAST::Declaration::ResolvedConstant.new(
                        :compile-time-value(
                            nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape') && $SELF.sigil eq '%'
                                ?? $SELF.IMPL-CONTAINER-TYPE($of, :key-type(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape').code-statements[0].expression.compile-time-value))
                                !! $SELF.IMPL-CONTAINER-TYPE($of)
                        )
                    ),
                    postfix => RakuAST::Call::Method.new(
                        name => RakuAST::Name.from-identifier('new'),
                        :$args
                    )
                );
                my $thunk := RakuAST::BlockThunk.new(:expression($container-initializer-ast));
                $container-initializer-ast.wrap-with-thunk($thunk);
                $thunk.ensure-begin-performed($resolver, $context);
                $resolver.current-scope.add-generated-lexical-declaration(
                    RakuAST::VarDeclaration::Implicit::Block.new(:block($thunk))
                );
                nqp::bindattr($SELF, RakuAST::VarDeclaration::Simple, '$!container-initializer',
                    $thunk.meta-object);
            }

            if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer') {
                my $initializer := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer');
                my $method := RakuAST::Method.new(
                    :signature(RakuAST::Signature.new(
                        :parameters([
                            RakuAST::Parameter.new(
                                target => RakuAST::ParameterTarget::Var.new('$_')
                            )
                        ])
                    )),
                    :body(RakuAST::Blockoid.new(
                        RakuAST::StatementList.new(
                            !nqp::istype($initializer,RakuAST::Initializer::CallAssign)
                                ?? RakuAST::Statement::Expression.new(:expression($initializer.expression))
                                !! RakuAST::Statement::Expression.new(:expression(
                                    RakuAST::ApplyPostfix.new(
                                        operand => nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type'),
                                        postfix => $initializer.postfixish
                                    )
                                ))
                            )
                        )
                    ),
                );
                nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!attribute-package').add-generated-lexical-declaration($method);
                $SELF.add-trait(RakuAST::Trait::Will.new('build', $method));
            }

            # For attributes our meta-object is an appropriate Attribute instance
            $SELF.apply-traits($resolver, $context, $SELF);

            my $meta-object := $SELF.meta-object;
            if $SELF.scope eq 'HAS' && $meta-object.type.REPR eq 'CArray' && nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape') {
                my @dimensions := nqp::list_i();
                my $shape := $SELF.IMPL-BEGIN-TIME-EVALUATE(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape'), $resolver, $context);
                my $elems := nqp::unbox_i($SELF.IMPL-BEGIN-TIME-EVALUATE(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape'), $resolver, $context));
                nqp::push_i(@dimensions, $elems);
                nqp::bindattr($meta-object, $meta-object.WHAT, '$!dimensions', @dimensions);
            }
        }
        else {
            # For other variables the meta-object is just the container, but we
            # need instances of Variable
            my $meta := $SELF.meta-object;
            my $target := RakuAST::TraitTarget::Variable.new($SELF.name, nqp::getattr($SELF, RakuAST::Declaration, '$!scope'), $meta, Mu, Mu);
            # Get around RakuAST compiler deconting all arguments:
            nqp::bindattr($target, RakuAST::TraitTarget::Variable, '$!cont', $meta);
            $target.IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);

            if $SELF.twigil eq '.' {
                my $variable-access := RakuAST::Var::Lexical.new($SELF.name);
                $variable-access.set-resolution($SELF);
                my $accessor := RakuAST::Method.new(
                    :scope<has>,
                    :name(RakuAST::Name.from-identifier($SELF.desigilname.canonicalize)),
                    :body(RakuAST::Blockoid.new(
                        RakuAST::StatementList.new(
                            RakuAST::Statement::Expression.new(:expression($variable-access)),
                        ),
                    )),
                );
                nqp::bindattr($SELF, RakuAST::VarDeclaration::Simple, '$!accessor', $accessor);
                $accessor.IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);
            }

            $SELF.apply-traits($resolver, $context, $target);
        }
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'PERFORM-CHECK', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 716 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.add-sorry(
          $resolver.build-exception: 'X::Dynamic::Package',
            :symbol($SELF.name)
        ) if $SELF.twigil eq '*' && $SELF.desigilname.is-multi-part;

        $SELF.add-sorry(
          $resolver.build-exception: 'X::Syntax::Variable::ConflictingTypes',
            :outer(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!conflicting-type').compile-time-value), :inner(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type').compile-time-value)
        ) if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!conflicting-type');

        my $type := $SELF.type;
        if nqp::istype($type,RakuAST::Type::Simple) {
            my $initializer := $SELF.initializer;
            if nqp::istype($initializer,RakuAST::Initializer::Assign)
                 || nqp::istype($initializer,RakuAST::Initializer::Bind) {
                my $expression := $initializer.expression;
                if nqp::istype($expression,RakuAST::Literal) {
                    my $vartype := $type.PRODUCE-META-OBJECT;
                    if nqp::objprimspec($vartype) {
                        $vartype := $vartype.HOW.mro($vartype)[1];
                    }

                    my $value := $expression.compile-time-value;
                    if !nqp::istype($value,$vartype)
                        && nqp::istype($vartype,$resolver.resolve-name-constant-in-setting(RakuAST::Name.from-identifier('Numeric')).compile-time-value)
                    {
                        $SELF.add-sorry:
                          $resolver.build-exception: 'X::Syntax::Number::LiteralType',
                            :varname($SELF.name), :$vartype, :$value;
                    }
                }
            }
        }
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 752 src/Raku/ast/variable-declaration.rakumod
        
        my @lookups;
        my str $scope := $SELF.scope;
        # If we have a type, we need to resolve that.  Otherwise assume Mu
        @lookups.push(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type') || nqp::null);

        # If we're has/HAS scope, we need Nil to evaluate to.
        @lookups.push($scope eq 'has' || $scope eq 'HAS'
          ?? RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Nil'))
          !! nqp::null
        );

        $SELF.IMPL-WRAP-LIST(@lookups)
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'PRODUCE-META-OBJECT', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 767 src/Raku/ast/variable-declaration.rakumod
        
        # If it's our-scoped, then container is vivified via. package access.
        my str $scope := $SELF.scope;

        # Calculate the type.
        my $of := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type')
          ?? (nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type').is-resolved
               ?? nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type')
               !! $SELF.get-implicit-lookups.AT-POS(0)
             ).resolution.compile-time-value
          !! Mu;
        my $descriptor := $SELF.IMPL-CONTAINER-DESCRIPTOR($of);

        # `my %h{Any}` creates this shape declaration:
        #
        # shape => RakuAST::SemiList.new(
        #   RakuAST::Statement::Expression.new(
        #     expression => RakuAST::Type::Simple.new(   <-- shape type
        #       RakuAST::Name.from-identifier("Any")
        #     )
        #   )
        # )
        my $object-hash := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape') && $SELF.sigil eq '%';
        my $type        := $SELF.IMPL-CONTAINER-TYPE(
          $of,
          :key-type($object-hash
            ?? nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape').code-statements[0].expression.compile-time-value
            !! NQPMu
          )
        );

        # If it's has scoped, we'll need to build an attribute.
        if $scope eq 'has' || $scope eq 'HAS' {
            my $meta-object := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!attribute-package').attribute-type.new(
              name => $SELF.sigil ~ '!' ~ $SELF.desigilname.canonicalize,
              type => $type,
              has_accessor          => $SELF.twigil eq '.',
              container_descriptor  => $descriptor,
              auto_viv_container    => $SELF.IMPL-CONTAINER($of, $descriptor),
              package               => nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!attribute-package').compile-time-value,
              container_initializer => nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!container-initializer'),
            );
            nqp::bindattr_i($meta-object,$meta-object.WHAT,'$!inlined',1)
              if $scope eq 'HAS';
            $meta-object
        }

        # An "our" that is already installed
        elsif $scope eq 'our' && nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!package').WHO.EXISTS-KEY($SELF.name) {
            nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!package').WHO.AT-KEY($SELF.name)
        }

        # An object hash, type is ok already
        elsif $object-hash {
            nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!package').WHO.BIND-KEY($SELF.name, $type) if $scope eq 'our';
            $type
        }

        # Otherwise, it's lexically scoped, so the meta-object is just the
        # container, if any.
        else {
            my $container := $SELF.IMPL-CONTAINER($of, $descriptor);
            nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!package').WHO.BIND-KEY($SELF.name, $container) if $scope eq 'our';
            $container
        }
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 834 src/Raku/ast/variable-declaration.rakumod
        
        my str $scope := $SELF.scope;
        my $of :=
          $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;

        if $scope eq 'my' && !nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!desigilname').is-multi-part {
            # Lexically scoped
            my str $sigil := $SELF.sigil;
            if $sigil eq '$' && nqp::objprimspec($of) {
                # Natively typed; just declare it.
                QAST::Var.new(
                    :scope('lexical'), :decl('var'), :name($SELF.name),
                    :returns($of)
                )
            }
            elsif nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer') && nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer').is-binding {
                # Will be bound on first use, so just a declaration.
                QAST::Var.new( :scope('lexical'), :decl('var'), :name($SELF.name) )
            }
            else {
                # Need to vivify the object. Note: maybe we want to drop the
                # contvar, though we'll need an alternative for BEGIN.
                my $container := $SELF.meta-object;
                $context.ensure-sc($container);
                my $qast := QAST::Var.new(
                    :scope('lexical'), :decl('contvar'), :name($SELF.name),
                    :value($container)
                );
                if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape') || $SELF.IMPL-HAS-CONTAINER-BASE-TYPE {
                    my $value := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape') && $SELF.sigil eq '%'
                        ?? $SELF.IMPL-CONTAINER-TYPE($of, :key-type(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape').code-statements[0].expression.compile-time-value))
                        !! $SELF.IMPL-CONTAINER-TYPE($of);
                    $context.ensure-sc($value);
                    $qast := QAST::Op.new( :op('bind'), $qast, QAST::Op.new(
                        :op('callmethod'), :name('new'),
                        QAST::WVal.new( :$value )
                    ) );
                    if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape') {
                        my $shape_ast := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!shape').IMPL-TO-QAST($context);
                        $shape_ast.named('shape');
                        $qast[1].push($shape_ast);
                    }
                }
                $qast
            }
        }
        elsif $scope eq 'our' || nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!desigilname').is-multi-part {
            # Package scoped lexical alias. We want to bind the lexical to
            # a lookup in the package.
            my $container := $SELF.meta-object;
            $context.ensure-sc($container);
            my $lookup := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!desigilname').IMPL-QAST-PACKAGE-LOOKUP($context, nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!package'), :sigil(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Simple, '$!sigil')), :global-fallback);
            $lookup.name('VIVIFY-KEY');
            QAST::Op.new(
              :op('bind'),
              QAST::Var.new( :scope('lexical'), :decl('contvar'), :name($SELF.name), :returns($of), :value($container) ),
              $lookup
            )
        }
        elsif $scope eq 'has' || $scope eq 'HAS' {
            # No declaration to install
            QAST::Op.new( :op('null') )
        }
        elsif $scope eq 'state' {
            # Lexically scoped state variable
            my str $sigil := $SELF.sigil;
            if $sigil eq '$' && nqp::objprimspec($of) {
                nqp::die("Natively typed state variables not yet implemented");
            }
            elsif nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer') && nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer').is-binding {
                # Will be bound on first use, so just a declaration.
                QAST::Var.new(:scope('lexical'), :decl('var'), :name($SELF.name))
            }
            else {
                # Need to vivify the object.
                my $container := $SELF.meta-object;
                $context.ensure-sc($container);
                QAST::Var.new(
                    :scope('lexical'), :decl('statevar'), :name($SELF.name),
                    :value($container)
                )
            }
        }
        else {
            nqp::die("Don't know how to compile $scope scope variable");
        }
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'IMPL-TO-QAST', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 922 src/Raku/ast/variable-declaration.rakumod
        
        my str $scope := $SELF.scope;
        my $lookups := $SELF.get-implicit-lookups;
        my str $name := $SELF.name;
        if $scope eq 'my' || $scope eq 'state' || $scope eq 'our' {
            my str $sigil := $SELF.sigil;
            my $var-access := QAST::Var.new( :$name, :scope<lexical> );
            my $of := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type')
              ?? $lookups.AT-POS(0).resolution.compile-time-value
              !! Mu;

            if $sigil eq '$' && (my int $prim-spec := nqp::objprimspec($of)) {
                # Natively typed value. Need to initialize it to a default
                # in the absence of an initializer.
                my $init;
                if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer') {
                    if nqp::istype(nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer'), RakuAST::Initializer::Assign) {
                        $init := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer').expression.IMPL-TO-QAST($context);
                    }
                    else {
                        nqp::die('Can only compile an assign initializer on a native');
                    }
                }
                elsif $prim-spec == 1 || ($prim-spec >= 4 && $prim-spec <= 10) {
                    $init := QAST::IVal.new( :value(0) );
                }
                elsif $prim-spec == 2 {
                    $init := QAST::NVal.new( :value(0e0) );
                }
                else {
                    $init := QAST::SVal.new( :value('') );
                }
                QAST::Op.new( :op('bind'), $var-access, $init )
            }

            # Reference type value with an initializer
            elsif nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer') {
                my $init-qast := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer').IMPL-TO-QAST($context, :invocant-qast($var-access));
                my $perform-init-qast;
                if nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!initializer').is-binding {
                    # TODO type checking of source
                    my $source := $sigil eq '@' || $sigil eq '%'
                      ?? QAST::Op.new( :op('decont'), $init-qast)
                      !! $init-qast;
                    $perform-init-qast := QAST::Op.new(
                      :op('bind'), $var-access, $source
                    );
                }
                else {
                    # Assignment. Case-analyze by sigil.
                    if $sigil eq '@' || $sigil eq '%' {
                        # Call STORE method, passing :INITIALIZE to indicate
                        # it's the initialization for immutable types.
                        $perform-init-qast := QAST::Op.new(
                          :op('callmethod'), :name('STORE'),
                          $var-access,
                          $init-qast,
                          QAST::WVal.new( :named('INITIALIZE'), :value((Bool.WHO)<True>) )
                        );
                    }
                    else {
                        # Scalar assignment.
                        $perform-init-qast := QAST::Op.new(
                          :op('p6assign'), $var-access, $init-qast );
                    }
                }
                if $scope eq 'state' {
                    QAST::Op.new(
                      :op('if'),
                      QAST::Op.new( :op('p6stateinit') ),
                      $perform-init-qast,
                      $var-access
                    )
                }
                else {
                    $perform-init-qast
                }
            }

            # Just a declaration; compile into an access to the variable.
            else {
                $var-access
            }
        }
        elsif $scope eq 'has' || $scope eq 'HAS' {
            # These just evaluate to Nil
            $lookups.AT-POS(1).IMPL-TO-QAST($context)
        }
        else {
            nqp::die("Don't know how to compile initialization for scope $scope");
        }
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'IMPL-LOOKUP-QAST', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 1015 src/Raku/ast/variable-declaration.rakumod
        
        my str $scope := $SELF.scope;
        if $scope eq 'my' || $scope eq 'state' || $scope eq 'our' {
            my str $scope := 'lexical';
            unless $rvalue {
                # Potentially l-value native lookups need a lexicalref.
                if $SELF.sigil eq '$' && $SELF.scope ne 'our' {
                    my $of := nqp::getattr($SELF, RakuAST::VarDeclaration::Simple, '$!type')
                      ?? $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value
                      !! Mu;
                    if nqp::objprimspec($of) {
                        $scope := 'lexicalref';
                    }
                    return QAST::Var.new( :name($SELF.name), :$scope, :returns($of) );
                }
            }
            QAST::Var.new( :name($SELF.name), :$scope )
        }
        elsif $scope eq 'has' || $scope eq 'HAS' {
            nqp::die('Cannot compile lookup of attributes yet')
        }
        else {
            nqp::die("Cannot compile lookup of scope $scope")
        }
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'IMPL-BIND-QAST', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 1041 src/Raku/ast/variable-declaration.rakumod
        
        my str $scope := $SELF.scope;
        nqp::die('Can only compile bind to my-scoped variables') unless $scope eq 'my' || $scope eq 'state';
        QAST::Op.new(
            :op('bind'),
            QAST::Var.new( :name($SELF.name), :scope('lexical') ),
            $source-qast
        )
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'IMPL-EXPR-QAST', [RakuAST::VarDeclaration::Simple, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1051 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::VarDeclaration::Simple, 'needs-sink-call', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub needs-sink-call ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1055 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::VarDeclaration::Simple, 'dump-markers', [RakuAST::VarDeclaration::Simple, '', 0, 0], anon sub dump-markers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1057 src/Raku/ast/variable-declaration.rakumod
        
        '【' ~ $SELF.name ~ '】'
    
    });
#line 441 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Simple, 'type', [], anon sub type ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Simple, '$!type') });
#line 444 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Simple, 'twigil', [], anon sub twigil ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::VarDeclaration::Simple, '$!twigil') });
#line 443 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Simple, 'sigil', [], anon sub sigil ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::VarDeclaration::Simple, '$!sigil') });
#line 447 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Simple, 'shape', [], anon sub shape ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Simple, '$!shape') });
#line 446 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Simple, 'initializer', [], anon sub initializer ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Simple, '$!initializer') });
#line 442 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Simple, 'desigilname', [], anon sub desigilname ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Simple, '$!desigilname') });
    compose(RakuAST::VarDeclaration::Simple);
    parent(RakuAST::VarDeclaration::Auto, RakuAST::VarDeclaration::Simple);
    compose(RakuAST::VarDeclaration::Auto);
    parent(RakuAST::VarDeclaration::Signature, RakuAST::Declaration);
    parent(RakuAST::VarDeclaration::Signature, RakuAST::ImplicitLookups);
    parent(RakuAST::VarDeclaration::Signature, RakuAST::TraitTarget);
    parent(RakuAST::VarDeclaration::Signature, RakuAST::CheckTime);
    parent(RakuAST::VarDeclaration::Signature, RakuAST::Attaching);
    parent(RakuAST::VarDeclaration::Signature, RakuAST::BeginTime);
    parent(RakuAST::VarDeclaration::Signature, RakuAST::Term);
    add-attribute(RakuAST::VarDeclaration::Signature, RakuAST::Signature, '$!signature');
    add-attribute(RakuAST::VarDeclaration::Signature, RakuAST::Type, '$!type');
    add-attribute(RakuAST::VarDeclaration::Signature, RakuAST::Initializer, '$!initializer');
    add-attribute(RakuAST::VarDeclaration::Signature, RakuAST::Package, '$!attribute-package');
    add-attribute(RakuAST::VarDeclaration::Signature, Mu, '$!package');
    add-method(RakuAST::VarDeclaration::Signature, 'new', [RakuAST::VarDeclaration::Signature, '', 0, 0, RakuAST::Signature, '$signature', 1, 0, RakuAST::Type, '$type', 1, 1, RakuAST::Initializer, '$initializer', 1, 1, str, '$scope', 1, 1], anon sub new ($SELF_CONT, :$signature!, :$type?, :$initializer?, :$scope?) {
        my $SELF := nqp::decont($SELF_CONT);
        $signature := nqp::decont($signature);
        $type := nqp::decont($type);
        $initializer := nqp::decont($initializer);
        $scope := nqp::decont($scope);
#line 1083 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Signature, '$!signature', $signature);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Signature, '$!type', $type // RakuAST::Type);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Signature, '$!initializer',
            $initializer // RakuAST::Initializer);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'visit-children', [RakuAST::VarDeclaration::Signature, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1093 src/Raku/ast/variable-declaration.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!signature'));
        my $type := nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!type');
        $visitor($type) if nqp::isconcrete($type);
        my $initializer := nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!initializer');
        $visitor($initializer) if nqp::isconcrete($initializer);
        $SELF.visit-traits($visitor);
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'default-scope', [RakuAST::VarDeclaration::Signature, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1102 src/Raku/ast/variable-declaration.rakumod
        
        'my'
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'allowed-scopes', [RakuAST::VarDeclaration::Signature, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1106 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-WRAP-LIST(['my', 'state', 'our', 'has', 'HAS'])
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'is-simple-lexical-declaration', [RakuAST::VarDeclaration::Signature, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1110 src/Raku/ast/variable-declaration.rakumod
        
        # The ParameterTargets in our signature will take care of declarations
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'is-lexical', [RakuAST::VarDeclaration::Signature, '', 0, 0], anon sub is-lexical ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1115 src/Raku/ast/variable-declaration.rakumod
        
        # Overridden here because our-scoped variables are really lexical aliases.
        my str $scope := $SELF.scope;
        $scope eq 'my' || $scope eq 'state' || $scope eq 'our'
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'attach', [RakuAST::VarDeclaration::Signature, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1121 src/Raku/ast/variable-declaration.rakumod
        
        my str $scope := $SELF.scope;
        if $scope eq 'has' || $scope eq 'HAS' {
            my $attribute-package := $resolver.find-attach-target('package');
            if $attribute-package {
                nqp::bindattr($SELF, RakuAST::VarDeclaration::Signature, '$!attribute-package',
                    $attribute-package);
                for $SELF.IMPL-UNWRAP-LIST($SELF.signature.parameters) {
                    #TODO this should probably live in the target's attach method
                    if $_.target && nqp::istype($_.target, RakuAST::ParameterTarget::Var) {
                        $_.target.replace-scope($scope);
                        nqp::bindattr($_.target, RakuAST::ParameterTarget::Var, '$!attribute-package',
                            $attribute-package);
                    }
                }
            }
            else {
                # TODO check-time error
            }
        }
        elsif $scope eq 'our' {
            my $package := $resolver.current-package;
            # There is always a package, even if it's just GLOBALish
            nqp::bindattr($SELF, RakuAST::VarDeclaration::Signature, '$!package',
                $package);
        }
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::VarDeclaration::Signature, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1149 src/Raku/ast/variable-declaration.rakumod
        
        my @lookups;
        # If it's our-scoped, we need the package to bind it from.
        my str $scope := $SELF.scope;
        if $scope eq 'our' {
            @lookups.push(RakuAST::Var::Compiler::Lookup.new('$?PACKAGE'));
        }
        # If we have a type, we need to resolve that.
        elsif nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!type') {
            @lookups.push(nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!type'));
        }
        # If we're has/HAS scope, we need Nil to evaluate to.
        if $scope eq 'has' || $scope eq 'HAS' {
            @lookups.push(RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Nil')));
        }
        $SELF.IMPL-WRAP-LIST(@lookups)
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'is-begin-performed-before-children', [RakuAST::VarDeclaration::Signature, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1167 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::VarDeclaration::Signature, 'PERFORM-BEGIN', [RakuAST::VarDeclaration::Signature, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1169 src/Raku/ast/variable-declaration.rakumod
        
        my $traits := $SELF.IMPL-UNWRAP-LIST($SELF.traits);
        my $scope := $SELF.scope;
        for $SELF.IMPL-UNWRAP-LIST($SELF.signature.parameters) -> $param {
            for $traits {
                $param.target.replace-scope($scope);
                $param.target.add-trait(nqp::clone($_)) if $param.target;
            }
        }
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'PERFORM-CHECK', [RakuAST::VarDeclaration::Signature, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1180 src/Raku/ast/variable-declaration.rakumod
        
        # tell the parameter targets to create containers
        my @params := $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!signature').parameters);

        my $type := nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!type');
        my $of := $type
          ?? $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value
          !! Mu;

        for @params {
            $_.target.set-container-type($type, $of) if $type;
        }
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'IMPL-TO-QAST', [RakuAST::VarDeclaration::Signature, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1194 src/Raku/ast/variable-declaration.rakumod
        
        if nqp::isconcrete(nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!initializer')) {
            if nqp::istype(nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!initializer'), RakuAST::Initializer::Assign) {
                my $list   := QAST::Op.new( :op('call'), :name('&infix:<,>') );
                my @params := $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!signature').parameters);

                for @params {
                    $list.push: $_.target.IMPL-LOOKUP-QAST($context);
                }
                my $init-qast := nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!initializer').IMPL-TO-QAST($context);
                $list := QAST::Op.new( :op('p6store'), $list, $init-qast);
                return $list;
            }
            elsif nqp::istype(nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!initializer'), RakuAST::Initializer::Bind) {
                my $signature := nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!signature').meta-object;
                $context.ensure-sc($signature);
                my $init-qast := nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!initializer').IMPL-TO-QAST($context);
                my $list := QAST::Op.new(
                    :op('p6bindcaptosig'),
                    QAST::WVal.new( :value($signature) ),
                    QAST::Op.new(
                        :op('callmethod'), :name('Capture'),
                        $init-qast
                    )
                );
                return $list;
            }
            else {
                nqp::die('Not yet supported signature initializer: ' ~ nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!initializer').HOW.name(nqp::getattr($SELF, RakuAST::VarDeclaration::Signature, '$!initializer')));
            }
        }

        QAST::Op.new(:op<null>);
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'IMPL-EXPR-QAST', [RakuAST::VarDeclaration::Signature, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1229 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::VarDeclaration::Signature, 'needs-sink-call', [RakuAST::VarDeclaration::Signature, '', 0, 0], anon sub needs-sink-call ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1233 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<False> 
    });
#line 1077 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Signature, 'type', [], anon sub type ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Signature, '$!type') });
#line 1076 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Signature, 'signature', [], anon sub signature ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Signature, '$!signature') });
#line 1078 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Signature, 'initializer', [], anon sub initializer ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Signature, '$!initializer') });
    compose(RakuAST::VarDeclaration::Signature);
    parent(RakuAST::VarDeclaration::Anonymous, RakuAST::VarDeclaration::Simple);
    add-method(RakuAST::VarDeclaration::Anonymous, 'new', [RakuAST::VarDeclaration::Anonymous, '', 0, 0, str, '$sigil', 1, 0, RakuAST::Type, '$type', 1, 1, RakuAST::Initializer, '$initializer', 1, 1, str, '$scope', 1, 1], anon sub new ($SELF_CONT, :$sigil!, :$type?, :$initializer?, :$scope?) {
        my $SELF := nqp::decont($SELF_CONT);
        $sigil := nqp::decont($sigil);
        $type := nqp::decont($type);
        $initializer := nqp::decont($initializer);
        $scope := nqp::decont($scope);
#line 1241 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Simple, '$!desigilname',
            $SELF.IMPL-GENERATE-NAME());
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Simple, '$!sigil', $sigil);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Simple, '$!twigil', '');
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Simple, '$!type', $type // RakuAST::Type);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Simple, '$!initializer',
            $initializer // RakuAST::Initializer);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Anonymous, 'IMPL-GENERATE-NAME', [RakuAST::VarDeclaration::Anonymous, '', 0, 0], anon sub IMPL-GENERATE-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1254 src/Raku/ast/variable-declaration.rakumod
        
        RakuAST::Name.from-identifier(QAST::Node.unique('ANON_VAR'))
    
    });
    add-method(RakuAST::VarDeclaration::Anonymous, 'desigilname', [RakuAST::VarDeclaration::Anonymous, '', 0, 0], anon sub desigilname ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1258 src/Raku/ast/variable-declaration.rakumod
        
        RakuAST::Name.from-identifier('')
    
    });
    add-method(RakuAST::VarDeclaration::Anonymous, 'generate-lookup', [RakuAST::VarDeclaration::Anonymous, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1262 src/Raku/ast/variable-declaration.rakumod
        
        nqp::die('Cannot generate lookup of an anonymous variable');
    
    });
    add-method(RakuAST::VarDeclaration::Anonymous, 'allowed-scopes', [RakuAST::VarDeclaration::Anonymous, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1266 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-WRAP-LIST(['my', 'state'])
    
    });
    compose(RakuAST::VarDeclaration::Anonymous);
    parent(RakuAST::VarDeclaration::Term, RakuAST::Declaration);
    parent(RakuAST::VarDeclaration::Term, RakuAST::Term);
    add-attribute(RakuAST::VarDeclaration::Term, RakuAST::Type, '$!type');
    add-attribute(RakuAST::VarDeclaration::Term, RakuAST::Name, '$!name');
    add-attribute(RakuAST::VarDeclaration::Term, RakuAST::Initializer, '$!initializer');
    add-method(RakuAST::VarDeclaration::Term, 'new', [RakuAST::VarDeclaration::Term, '', 0, 0, str, '$scope', 1, 1, RakuAST::Type, '$type', 1, 1, RakuAST::Name, '$name', 1, 0, RakuAST::Initializer, '$initializer', 1, 0], anon sub new ($SELF_CONT, :$scope?, :$type?, :$name!, :$initializer!) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $type := nqp::decont($type);
        $name := nqp::decont($name);
        $initializer := nqp::decont($initializer);
#line 1281 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Term, '$!type', $type // RakuAST::Type);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Term, '$!name', $name);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Term, '$!initializer',
            $initializer // RakuAST::Initializer);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Term, 'lexical-name', [RakuAST::VarDeclaration::Term, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1291 src/Raku/ast/variable-declaration.rakumod
        
        nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!name').canonicalize
    
    });
    add-method(RakuAST::VarDeclaration::Term, 'generate-lookup', [RakuAST::VarDeclaration::Term, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1295 src/Raku/ast/variable-declaration.rakumod
        
        my $lookup := RakuAST::Term::Name.new(nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!name'));
        $lookup.set-resolution($SELF);
        $lookup
    
    });
    add-method(RakuAST::VarDeclaration::Term, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Term, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1301 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new( :decl('var'), :scope('lexical'), :name(nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!name').canonicalize) )
    
    });
    add-method(RakuAST::VarDeclaration::Term, 'IMPL-TO-QAST', [RakuAST::VarDeclaration::Term, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1305 src/Raku/ast/variable-declaration.rakumod
        
        my $init-qast := nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!initializer').IMPL-TO-QAST($context);
        if nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!type') && !nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!type').is-known-to-be-exactly(Mu) {
            $init-qast := QAST::Op.new(
                :op('p6bindassert'),
                $init-qast,
                nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!type').IMPL-TO-QAST($context)
            );
        }
        QAST::Op.new( :op('bind'), $SELF.IMPL-LOOKUP-QAST($context), $init-qast )
    
    });
    add-method(RakuAST::VarDeclaration::Term, 'IMPL-LOOKUP-QAST', [RakuAST::VarDeclaration::Term, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1317 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new( :name(nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!name').canonicalize), :scope('lexical') )
    
    });
    add-method(RakuAST::VarDeclaration::Term, 'IMPL-EXPR-QAST', [RakuAST::VarDeclaration::Term, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1321 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::VarDeclaration::Term, 'default-scope', [RakuAST::VarDeclaration::Term, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1325 src/Raku/ast/variable-declaration.rakumod
         'my' 
    });
    add-method(RakuAST::VarDeclaration::Term, 'allowed-scopes', [RakuAST::VarDeclaration::Term, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1327 src/Raku/ast/variable-declaration.rakumod
         $SELF.IMPL-WRAP-LIST(['my']) 
    });
    add-method(RakuAST::VarDeclaration::Term, 'needs-sink-call', [RakuAST::VarDeclaration::Term, '', 0, 0], anon sub needs-sink-call ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1329 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::VarDeclaration::Term, 'visit-children', [RakuAST::VarDeclaration::Term, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1331 src/Raku/ast/variable-declaration.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!type')) if nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!type');
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!name'));
        $visitor(nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!initializer')) if nqp::getattr($SELF, RakuAST::VarDeclaration::Term, '$!initializer');
    
    });
#line 1276 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Term, 'type', [], anon sub type ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Term, '$!type') });
#line 1277 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Term, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Term, '$!name') });
#line 1278 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Term, 'initializer', [], anon sub initializer ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Term, '$!initializer') });
    compose(RakuAST::VarDeclaration::Term);
    parent(RakuAST::VarDeclaration::Implicit, RakuAST::Declaration);
    add-attribute(RakuAST::VarDeclaration::Implicit, str, '$!name');
    add-method(RakuAST::VarDeclaration::Implicit, 'new', [RakuAST::VarDeclaration::Implicit, '', 0, 0, str, '$name', 1, 0, str, '$scope', 1, 1], anon sub new ($SELF_CONT, :$name!, :$scope?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $scope := nqp::decont($scope);
#line 1344 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Implicit, '$!name', $name);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit, 'lexical-name', [RakuAST::VarDeclaration::Implicit, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1351 src/Raku/ast/variable-declaration.rakumod
        
        nqp::getattr_s($SELF, RakuAST::VarDeclaration::Implicit, '$!name')
    
    });
    add-method(RakuAST::VarDeclaration::Implicit, 'default-scope', [RakuAST::VarDeclaration::Implicit, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1355 src/Raku/ast/variable-declaration.rakumod
        
        'my'
    
    });
    add-method(RakuAST::VarDeclaration::Implicit, 'generate-lookup', [RakuAST::VarDeclaration::Implicit, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1359 src/Raku/ast/variable-declaration.rakumod
        
        my $lookup := RakuAST::Var::Lexical.new(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Implicit, '$!name'));
        $lookup.set-resolution($SELF);
        $lookup
    
    });
    add-method(RakuAST::VarDeclaration::Implicit, 'IMPL-TO-QAST', [RakuAST::VarDeclaration::Implicit, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1365 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::VarDeclaration::Implicit, 'IMPL-LOOKUP-QAST', [RakuAST::VarDeclaration::Implicit, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 1369 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new( :name(nqp::getattr_s($SELF, RakuAST::VarDeclaration::Implicit, '$!name')), :scope('lexical') )
    
    });
#line 1342 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Implicit, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::VarDeclaration::Implicit, '$!name') });
    compose(RakuAST::VarDeclaration::Implicit);
    parent(RakuAST::VarDeclaration::Implicit::Special, RakuAST::VarDeclaration::Implicit);
    parent(RakuAST::VarDeclaration::Implicit::Special, RakuAST::Meta);
    add-method(RakuAST::VarDeclaration::Implicit::Special, 'PRODUCE-META-OBJECT', [RakuAST::VarDeclaration::Implicit::Special, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1380 src/Raku/ast/variable-declaration.rakumod
        
        # Reuse the container descriptor for the common cases that we expect
        # to have.
        my constant COMMON := nqp::list(
            nqp::hash(),
            nqp::hash(  # 6.c
                '$_', ContainerDescriptor.new(:of(Mu), :default(Any), :dynamic, :name('$_')),
                '$/', ContainerDescriptor.new(:of(Mu), :default(Nil), :dynamic, :name('$/')),
                '$!', ContainerDescriptor.new(:of(Mu), :default(Nil), :dynamic, :name('$!'))
            ),
            nqp::hash(  # 6.d
                '$_', ContainerDescriptor.new(:of(Mu), :default(Any), :!dynamic, :name('$_')),
                '$/', ContainerDescriptor.new(:of(Mu), :default(Nil), :dynamic, :name('$/')),
                '$!', ContainerDescriptor.new(:of(Mu), :default(Nil), :dynamic, :name('$!'))
            ),
            nqp::hash(  # 6.e
                '$_', ContainerDescriptor.new(:of(Mu), :default(Any), :!dynamic, :name('$_')),
                '$/', ContainerDescriptor.new(:of(Mu), :default(Nil), :dynamic, :name('$/')),
                '$!', ContainerDescriptor.new(:of(Mu), :default(Nil), :dynamic, :name('$!'))
            )
        );
        my $cont-desc := COMMON[nqp::getcomp('Raku').language_revision]{$SELF.name} //
            ContainerDescriptor.new(:of(Mu), :default(Any), :!dynamic, :name($SELF.name));
        my $container := nqp::create(Scalar);
        nqp::bindattr($container, Scalar, '$!descriptor', $cont-desc);
        nqp::bindattr($container, Scalar, '$!value', $cont-desc.default);
        $container
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Special, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::Special, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1409 src/Raku/ast/variable-declaration.rakumod
        
        my $container := $SELF.meta-object;
        $context.ensure-sc($container);
        QAST::Var.new(
            :scope('lexical'), :decl('contvar'), :name($SELF.name),
            :value($container)
        )
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Special, 'can-be-bound-to', [RakuAST::VarDeclaration::Implicit::Special, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1418 src/Raku/ast/variable-declaration.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::VarDeclaration::Implicit::Special, 'IMPL-BIND-QAST', [RakuAST::VarDeclaration::Implicit::Special, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 1420 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Op.new(
          :op('bind'),
          QAST::Var.new( :name($SELF.name), :scope('lexical') ),
          $source-qast
        )
    
    });
    compose(RakuAST::VarDeclaration::Implicit::Special);
    parent(RakuAST::VarDeclaration::Implicit::BlockTopic, RakuAST::VarDeclaration::Implicit);
    add-attribute(RakuAST::VarDeclaration::Implicit::BlockTopic, Bool, '$!parameter');
    add-attribute(RakuAST::VarDeclaration::Implicit::BlockTopic, Bool, '$!required');
    add-attribute(RakuAST::VarDeclaration::Implicit::BlockTopic, Bool, '$!exception');
    add-method(RakuAST::VarDeclaration::Implicit::BlockTopic, 'new', [RakuAST::VarDeclaration::Implicit::BlockTopic, '', 0, 0, Bool, '$parameter', 1, 1, Bool, '$required', 1, 1, Bool, '$exception', 1, 1], anon sub new ($SELF_CONT, :$parameter?, :$required?, :$exception?) {
        my $SELF := nqp::decont($SELF_CONT);
        $parameter := nqp::decont($parameter);
        $required := nqp::decont($required);
        $exception := nqp::decont($exception);
#line 1440 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Implicit, '$!name', '$_');
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', 'my');
        nqp::bindattr($obj, RakuAST::VarDeclaration::Implicit::BlockTopic, '$!parameter',
            $parameter // (Bool.WHO)<True>);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Implicit::BlockTopic, '$!required',
            $required // (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Implicit::BlockTopic, '$!exception',
            $exception // (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::BlockTopic, 'set-parameter', [RakuAST::VarDeclaration::Implicit::BlockTopic, '', 0, 0, Bool, '$parameter', 0, 0], anon sub set-parameter ($SELF_CONT, $parameter!) {
        my $SELF := nqp::decont($SELF_CONT);
        $parameter := nqp::decont($parameter);
#line 1453 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Implicit::BlockTopic, '$!parameter',
            $parameter);
        Nil
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::BlockTopic, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::BlockTopic, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1459 src/Raku/ast/variable-declaration.rakumod
        
        if nqp::getattr($SELF, RakuAST::VarDeclaration::Implicit::BlockTopic, '$!exception') {
            QAST::Stmts.new(
                QAST::Var.new( :decl('param'), :scope('local'), :name('EXCEPTION') ),
                QAST::Op.new(
                    :op('bind'),
                    QAST::Var.new( :decl('var'), :scope('lexical'), :name('$_') ),
                    QAST::Op.new(
                        :op('call'), :name('&EXCEPTION'),
                        QAST::Var.new( :scope('local'), :name('EXCEPTION') )
                    )
                ),
                QAST::Op.new(
                    :op('p6assign'),
                    QAST::Op.new( :op('getlexouter'), QAST::SVal.new( :value('$!') ) ),
                    QAST::Var.new( :scope('lexical'), :name('$_') )
                )
            )
        }
        elsif nqp::getattr($SELF, RakuAST::VarDeclaration::Implicit::BlockTopic, '$!parameter') {
            my $param := QAST::Var.new( :decl('param'), :scope('lexical'), :name('$_') );
            unless nqp::getattr($SELF, RakuAST::VarDeclaration::Implicit::BlockTopic, '$!required') {
                $param.default(QAST::Op.new( :op('getlexouter'), QAST::SVal.new( :value('$_') ) ));
            }
            $param
        }
        else {
            QAST::Op.new:
                :op('bind'),
                QAST::Var.new( :decl('var'), :scope('lexical'), :name('$_') ),
                QAST::Op.new( :op('getlexouter'), QAST::SVal.new( :value('$_') ) )
        }
    
    });
#line 1437 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Implicit::BlockTopic, 'required', [], anon sub required ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Implicit::BlockTopic, '$!required') });
#line 1436 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Implicit::BlockTopic, 'parameter', [], anon sub parameter ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Implicit::BlockTopic, '$!parameter') });
#line 1438 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Implicit::BlockTopic, 'exception', [], anon sub exception ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Implicit::BlockTopic, '$!exception') });
    compose(RakuAST::VarDeclaration::Implicit::BlockTopic);
    parent(RakuAST::VarDeclaration::Implicit::Constant, RakuAST::VarDeclaration::Implicit);
    parent(RakuAST::VarDeclaration::Implicit::Constant, RakuAST::TraitTarget);
    parent(RakuAST::VarDeclaration::Implicit::Constant, RakuAST::BeginTime);
    parent(RakuAST::VarDeclaration::Implicit::Constant, RakuAST::Meta);
    parent(RakuAST::VarDeclaration::Implicit::Constant, RakuAST::CompileTimeValue);
    parent(RakuAST::VarDeclaration::Implicit::Constant, RakuAST::Declaration::Mergeable);
    add-attribute(RakuAST::VarDeclaration::Implicit::Constant, Mu, '$!value');
    add-method(RakuAST::VarDeclaration::Implicit::Constant, 'new', [RakuAST::VarDeclaration::Implicit::Constant, '', 0, 0, str, '$name', 1, 0, Mu, '$value', 1, 0, str, '$scope', 1, 1], anon sub new ($SELF_CONT, :$name!, :$value!, :$scope?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $value := nqp::decont($value);
        $scope := nqp::decont($scope);
#line 1506 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Implicit, '$!name', $name);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Implicit::Constant, '$!value', $value);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Constant, 'compile-time-value', [RakuAST::VarDeclaration::Implicit::Constant, '', 0, 0], anon sub compile-time-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1514 src/Raku/ast/variable-declaration.rakumod
         nqp::getattr($SELF, RakuAST::VarDeclaration::Implicit::Constant, '$!value') 
    });
    add-method(RakuAST::VarDeclaration::Implicit::Constant, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::Constant, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1516 src/Raku/ast/variable-declaration.rakumod
        
        $context.ensure-sc(nqp::getattr($SELF, RakuAST::VarDeclaration::Implicit::Constant, '$!value'));
        QAST::Var.new( :decl('static'), :scope('lexical'), :name($SELF.name), :value(nqp::getattr($SELF, RakuAST::VarDeclaration::Implicit::Constant, '$!value')) )
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Constant, 'PRODUCE-META-OBJECT', [RakuAST::VarDeclaration::Implicit::Constant, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1521 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.compile-time-value
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Constant, 'PERFORM-BEGIN', [RakuAST::VarDeclaration::Implicit::Constant, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1525 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.apply-traits($resolver, $context, $SELF, :SYMBOL(RakuAST::StrLiteral.new($SELF.name)));
    
    });
#line 1504 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Implicit::Constant, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Implicit::Constant, '$!value') });
    compose(RakuAST::VarDeclaration::Implicit::Constant);
    parent(RakuAST::VarDeclaration::Implicit::Block, RakuAST::Declaration);
    add-attribute(RakuAST::VarDeclaration::Implicit::Block, Mu, '$!block');
    add-method(RakuAST::VarDeclaration::Implicit::Block, 'new', [RakuAST::VarDeclaration::Implicit::Block, '', 0, 0, Mu, '$block', 1, 0, str, '$scope', 1, 1], anon sub new ($SELF_CONT, :$block!, :$scope?) {
        my $SELF := nqp::decont($SELF_CONT);
        $block := nqp::decont($block);
        $scope := nqp::decont($scope);
#line 1536 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::VarDeclaration::Implicit::Block, '$!block', $block);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Block, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::Block, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1543 src/Raku/ast/variable-declaration.rakumod
        
        nqp::getattr($SELF, RakuAST::VarDeclaration::Implicit::Block, '$!block').IMPL-QAST-DECL-CODE($context);
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Block, 'lexical-name', [RakuAST::VarDeclaration::Implicit::Block, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1547 src/Raku/ast/variable-declaration.rakumod
         '' 
    });
#line 1534 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Implicit::Block, 'block', [], anon sub block ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Implicit::Block, '$!block') });
    compose(RakuAST::VarDeclaration::Implicit::Block);
    parent(RakuAST::VarDeclaration::Implicit::Self, RakuAST::VarDeclaration::Implicit);
    add-method(RakuAST::VarDeclaration::Implicit::Self, 'new', [RakuAST::VarDeclaration::Implicit::Self, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1554 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Implicit, '$!name', 'self');
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', 'my');
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Self, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::Self, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1561 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new( :decl('var'), :scope('lexical'), :name($SELF.name) )
    
    });
    compose(RakuAST::VarDeclaration::Implicit::Self);
    parent(RakuAST::VarDeclaration::Implicit::Cursor, RakuAST::VarDeclaration::Implicit);
    add-method(RakuAST::VarDeclaration::Implicit::Cursor, 'new', [RakuAST::VarDeclaration::Implicit::Cursor, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1570 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Implicit, '$!name', '$¢');
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', 'my');
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Cursor, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::Cursor, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1577 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new( :decl('var'), :scope('lexical'), :name($SELF.name) )
    
    });
    compose(RakuAST::VarDeclaration::Implicit::Cursor);
    parent(RakuAST::VarDeclaration::Implicit::Routine, RakuAST::VarDeclaration::Implicit);
    add-method(RakuAST::VarDeclaration::Implicit::Routine, 'new', [RakuAST::VarDeclaration::Implicit::Routine, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1586 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Implicit, '$!name', '&?ROUTINE');
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', 'my');
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Routine, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1593 src/Raku/ast/variable-declaration.rakumod
        
        # We cannot just put the AST node's meta-object into a WVal for this, because
        # we may be running a clone of that object.
        QAST::Op.new:
            :op('bind'),
            QAST::Var.new( :decl('var'), :scope('lexical'), :name($SELF.name) ),
            QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) )
    
    });
    compose(RakuAST::VarDeclaration::Implicit::Routine);
    parent(RakuAST::VarDeclaration::Implicit::State, RakuAST::VarDeclaration::Implicit);
    parent(RakuAST::VarDeclaration::Implicit::State, RakuAST::ImplicitLookups);
    parent(RakuAST::VarDeclaration::Implicit::State, RakuAST::Meta);
    add-attribute(RakuAST::VarDeclaration::Implicit::State, int, '$!init-to-zero');
    add-method(RakuAST::VarDeclaration::Implicit::State, 'new', [RakuAST::VarDeclaration::Implicit::State, '', 0, 0, str, '$name', 0, 0, int, '$init-to-zero', 1, 1], anon sub new ($SELF_CONT, $name!, :$init-to-zero?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $init-to-zero := nqp::decont($init-to-zero);
#line 1611 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Implicit, '$!name', $name);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', 'state');
        nqp::bindattr_i($obj, RakuAST::VarDeclaration::Implicit::State, '$!init-to-zero', $init-to-zero // 0);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::State, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::VarDeclaration::Implicit::State, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1619 src/Raku/ast/variable-declaration.rakumod
        
        my @lookups := nqp::getattr_i($SELF, RakuAST::VarDeclaration::Implicit::State, '$!init-to-zero') ?? [
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Int'))
        ] !! [];
        $SELF.IMPL-WRAP-LIST(@lookups)
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::State, 'PRODUCE-META-OBJECT', [RakuAST::VarDeclaration::Implicit::State, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1626 src/Raku/ast/variable-declaration.rakumod
        
        my str $name := nqp::getattr_s($SELF, RakuAST::VarDeclaration::Implicit, '$!name');

        # Create a container descriptor and attach it to a Scalar container, then set it to Int.new(0)
        my $descriptor := ContainerDescriptor.new(:of(Mu), :default(Any), :!dynamic, :$name);
        my $container := nqp::create(Scalar);
        nqp::bindattr($container, Scalar, '$!descriptor', $descriptor);
        if nqp::getattr_i($SELF, RakuAST::VarDeclaration::Implicit::State, '$!init-to-zero') {
            my $Int := $SELF.get-implicit-lookups.AT-POS(0).compile-time-value;
            nqp::bindattr($container, Scalar, '$!value', nqp::box_i(0, $Int));
        } else {
            nqp::bindattr($container, Scalar, '$!value', $descriptor.default);
        }

        $container
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::State, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::State, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1643 src/Raku/ast/variable-declaration.rakumod
        
        my $container := $SELF.meta-object;
        $context.ensure-sc($container);
        QAST::Var.new: :decl<statevar>, :scope<lexical>, :name($SELF.name), :value($container)
    
    });
    compose(RakuAST::VarDeclaration::Implicit::State);
    parent(RakuAST::VarDeclaration::Implicit::Doc, RakuAST::VarDeclaration::Implicit);
    parent(RakuAST::VarDeclaration::Implicit::Doc, RakuAST::Attaching);
    parent(RakuAST::VarDeclaration::Implicit::Doc, RakuAST::CheckTime);
    add-attribute(RakuAST::VarDeclaration::Implicit::Doc, Mu, '$!value');
    add-attribute(RakuAST::VarDeclaration::Implicit::Doc, Mu, '$!cu');
    add-method(RakuAST::VarDeclaration::Implicit::Doc, 'new', [RakuAST::VarDeclaration::Implicit::Doc, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1659 src/Raku/ast/variable-declaration.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Implicit, '$!name',
          $SELF.name);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', 'my');
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Doc, 'attach', [RakuAST::VarDeclaration::Implicit::Doc, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1667 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Implicit::Doc, '$!cu',
          $resolver.find-attach-target('compunit'));
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Doc, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Implicit::Doc, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1672 src/Raku/ast/variable-declaration.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::VarDeclaration::Implicit::Doc, '$!value');
        $context.ensure-sc($value);
        QAST::Op.new:
          :op('bind'),
          QAST::Var.new(:decl('static'), :scope('lexical'), :name(
            nqp::getattr_s($SELF, RakuAST::VarDeclaration::Implicit, '$!name')
          )),
          QAST::WVal.new(:$value);
    
    });
#line 1656 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Implicit::Doc, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::VarDeclaration::Implicit::Doc, '$!value') });
    compose(RakuAST::VarDeclaration::Implicit::Doc);
    parent(RakuAST::VarDeclaration::Implicit::Doc::Pod, RakuAST::VarDeclaration::Implicit::Doc);
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Pod, 'name', [RakuAST::VarDeclaration::Implicit::Doc::Pod, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1688 src/Raku/ast/variable-declaration.rakumod
         '$=pod' 
    });
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Pod, 'PERFORM-CHECK', [RakuAST::VarDeclaration::Implicit::Doc::Pod, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1693 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Implicit::Doc, '$!value',
          nqp::getattr(
            $SELF,RakuAST::VarDeclaration::Implicit::Doc,'$!cu'
          ).pod-content
        );
    
    });
    compose(RakuAST::VarDeclaration::Implicit::Doc::Pod);
    parent(RakuAST::VarDeclaration::Implicit::Doc::Data, RakuAST::VarDeclaration::Implicit::Doc);
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Data, 'name', [RakuAST::VarDeclaration::Implicit::Doc::Data, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1706 src/Raku/ast/variable-declaration.rakumod
         '$=data' 
    });
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Data, 'PERFORM-CHECK', [RakuAST::VarDeclaration::Implicit::Doc::Data, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1711 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Implicit::Doc, '$!value',
          nqp::ifnull(
            nqp::getattr(
              $SELF,RakuAST::VarDeclaration::Implicit::Doc,'$!cu'
            ).data-content,
            Mu
          )
        );
    
    });
    compose(RakuAST::VarDeclaration::Implicit::Doc::Data);
    parent(RakuAST::VarDeclaration::Implicit::Doc::Finish, RakuAST::VarDeclaration::Implicit::Doc);
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Finish, 'name', [RakuAST::VarDeclaration::Implicit::Doc::Finish, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1727 src/Raku/ast/variable-declaration.rakumod
         '$=finish' 
    });
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Finish, 'PERFORM-CHECK', [RakuAST::VarDeclaration::Implicit::Doc::Finish, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1732 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Implicit::Doc, '$!value',
          nqp::getattr(
            $SELF,RakuAST::VarDeclaration::Implicit::Doc,'$!cu'
          ).finish-content,
        );
    
    });
    compose(RakuAST::VarDeclaration::Implicit::Doc::Finish);
    parent(RakuAST::VarDeclaration::Implicit::Doc::Rakudoc, RakuAST::VarDeclaration::Implicit::Doc);
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Rakudoc, 'name', [RakuAST::VarDeclaration::Implicit::Doc::Rakudoc, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1745 src/Raku/ast/variable-declaration.rakumod
         '$=rakudoc' 
    });
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Rakudoc, 'fetch-blocks', [RakuAST::VarDeclaration::Implicit::Doc::Rakudoc, '', 0, 0, RakuAST::StatementList, '$statement-list', 0, 0], anon sub fetch-blocks ($SELF_CONT, $statement-list!) {
        my $SELF := nqp::decont($SELF_CONT);
        $statement-list := nqp::decont($statement-list);
#line 1747 src/Raku/ast/variable-declaration.rakumod
        
        for nqp::getattr(
          $statement-list,RakuAST::StatementList,'$!statements'
        ) {
            if nqp::istype($_,RakuAST::Doc::Block) {
                nqp::push($*RAKUDOC,$_);
            }
            elsif nqp::istype($_,RakuAST::Statement::Expression) {
                my $expression := $_.expression;
                if nqp::istype($expression,RakuAST::Doc::DeclaratorTarget)
                  && $expression.WHY {
                    nqp::push($*RAKUDOC,$expression);
                }
            }
            elsif nqp::istype($_,RakuAST::Blockoid) {
                $SELF.fetch-blocks($_.statement-list);
            }
        }
    
    });
    add-method(RakuAST::VarDeclaration::Implicit::Doc::Rakudoc, 'PERFORM-CHECK', [RakuAST::VarDeclaration::Implicit::Doc::Rakudoc, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1770 src/Raku/ast/variable-declaration.rakumod
        
        my $*RAKUDOC := [];
        $SELF.fetch-blocks(
          nqp::getattr(
            $SELF,RakuAST::VarDeclaration::Implicit::Doc,'$!cu'
          ).statement-list
        );

        nqp::bindattr($SELF, RakuAST::VarDeclaration::Implicit::Doc, '$!value',
          $SELF.IMPL-WRAP-LIST($*RAKUDOC)
        );
    
    });
    compose(RakuAST::VarDeclaration::Implicit::Doc::Rakudoc);
    parent(RakuAST::VarDeclaration::Placeholder, RakuAST::Declaration);
    parent(RakuAST::VarDeclaration::Placeholder, RakuAST::Attaching);
    parent(RakuAST::VarDeclaration::Placeholder, RakuAST::Term);
    parent(RakuAST::VarDeclaration::Placeholder, RakuAST::BeginTime);
    parent(RakuAST::VarDeclaration::Placeholder, RakuAST::CheckTime);
    add-attribute(RakuAST::VarDeclaration::Placeholder, Bool, '$!already-declared');
    add-method(RakuAST::VarDeclaration::Placeholder, 'lexical-name', [RakuAST::VarDeclaration::Placeholder, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1794 src/Raku/ast/variable-declaration.rakumod
         nqp::die('Missing lexical-name implementation') 
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'generate-parameter', [RakuAST::VarDeclaration::Placeholder, '', 0, 0], anon sub generate-parameter ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1796 src/Raku/ast/variable-declaration.rakumod
        
        nqp::die('Missing generate-parameter implementation')
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'attach', [RakuAST::VarDeclaration::Placeholder, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1800 src/Raku/ast/variable-declaration.rakumod
        
        my $owner := $resolver.find-attach-target('block');
        if $owner {
            $owner.add-placeholder-parameter($SELF);
        }
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'default-scope', [RakuAST::VarDeclaration::Placeholder, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1807 src/Raku/ast/variable-declaration.rakumod
         'my' 
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'allowed-scopes', [RakuAST::VarDeclaration::Placeholder, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1809 src/Raku/ast/variable-declaration.rakumod
         ['my'] 
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'generate-lookup', [RakuAST::VarDeclaration::Placeholder, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1811 src/Raku/ast/variable-declaration.rakumod
        
        my $lookup := RakuAST::Var::Lexical.new($SELF.lexical-name);
        $lookup.set-resolution($SELF);
        $lookup
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'is-simple-lexical-declaration', [RakuAST::VarDeclaration::Placeholder, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1817 src/Raku/ast/variable-declaration.rakumod
        
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'PERFORM-BEGIN', [RakuAST::VarDeclaration::Placeholder, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1821 src/Raku/ast/variable-declaration.rakumod
        
        $resolver.find-attach-target('block').add-generated-lexical-declaration($SELF)
            unless nqp::getattr($SELF, RakuAST::VarDeclaration::Placeholder, '$!already-declared');
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'PERFORM-CHECK', [RakuAST::VarDeclaration::Placeholder, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1829 src/Raku/ast/variable-declaration.rakumod
        
        my $signature := $resolver.find-attach-target('block').signature;
        if $signature.parameters-initialized {
            # @_ and %_ are only real placeholders if they were not
            # already defined in the signature, so we need to check
            # there before pulling the plug
            my $name := $SELF.lexical-name;
            if $name eq '@_' || $name eq '%_' {
                return (Bool.WHO)<True> if $signature.IMPL-HAS-PARAMETER($name);
            }
            $SELF.add-sorry:
              $resolver.build-exception: 'X::Signature::Placeholder',
                precursor   => 1,
                placeholder => $name;
            return (Bool.WHO)<False>;
        }
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'IMPL-ALREADY-DECLARED', [RakuAST::VarDeclaration::Placeholder, '', 0, 0, Bool, '$declared', 0, 0], anon sub IMPL-ALREADY-DECLARED ($SELF_CONT, $declared!) {
        my $SELF := nqp::decont($SELF_CONT);
        $declared := nqp::decont($declared);
#line 1848 src/Raku/ast/variable-declaration.rakumod
        
        nqp::bindattr($SELF, RakuAST::VarDeclaration::Placeholder, '$!already-declared', $declared ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'IMPL-TO-QAST', [RakuAST::VarDeclaration::Placeholder, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1852 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'IMPL-EXPR-QAST', [RakuAST::VarDeclaration::Placeholder, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1856 src/Raku/ast/variable-declaration.rakumod
        
        $SELF.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'IMPL-LOOKUP-QAST', [RakuAST::VarDeclaration::Placeholder, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 1860 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new( :name($SELF.lexical-name), :scope('lexical') )
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder, 'IMPL-QAST-DECL', [RakuAST::VarDeclaration::Placeholder, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1864 src/Raku/ast/variable-declaration.rakumod
        
        QAST::Var.new( :decl('var'), :scope('lexical'), :name($SELF.lexical-name) )
    
    });
    compose(RakuAST::VarDeclaration::Placeholder);
    parent(RakuAST::VarDeclaration::Placeholder::Positional, RakuAST::VarDeclaration::Placeholder);
    add-attribute(RakuAST::VarDeclaration::Placeholder::Positional, str, '$!lexical-name');
    add-method(RakuAST::VarDeclaration::Placeholder::Positional, 'new', [RakuAST::VarDeclaration::Placeholder::Positional, '', 0, 0, str, '$declared-name', 0, 0], anon sub new ($SELF_CONT, $declared-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $declared-name := nqp::decont($declared-name);
#line 1875 src/Raku/ast/variable-declaration.rakumod
        
        if nqp::substr($declared-name, 1, 1) eq '^' {
            nqp::die('Should construct a ' ~ $SELF.HOW.name($SELF) ~ ' without the ^ twigil');
        }
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Placeholder::Positional,
            '$!lexical-name', $declared-name);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder::Positional, 'generate-parameter', [RakuAST::VarDeclaration::Placeholder::Positional, '', 0, 0], anon sub generate-parameter ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1885 src/Raku/ast/variable-declaration.rakumod
        
        RakuAST::Parameter.new:
            target => RakuAST::ParameterTarget::Var.new($SELF.lexical-name)
    
    });
#line 1873 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Placeholder::Positional, 'lexical-name', [], anon sub lexical-name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::VarDeclaration::Placeholder::Positional, '$!lexical-name') });
    compose(RakuAST::VarDeclaration::Placeholder::Positional);
    parent(RakuAST::VarDeclaration::Placeholder::Named, RakuAST::VarDeclaration::Placeholder);
    add-attribute(RakuAST::VarDeclaration::Placeholder::Named, str, '$!lexical-name');
    add-method(RakuAST::VarDeclaration::Placeholder::Named, 'new', [RakuAST::VarDeclaration::Placeholder::Named, '', 0, 0, str, '$declared-name', 0, 0], anon sub new ($SELF_CONT, $declared-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $declared-name := nqp::decont($declared-name);
#line 1897 src/Raku/ast/variable-declaration.rakumod
        
        if nqp::substr($declared-name, 1, 1) eq ':' {
            nqp::die('Should construct a ' ~ $SELF.HOW.name($SELF) ~ ' without the : twigil');
        }
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::VarDeclaration::Placeholder::Named,
            '$!lexical-name', $declared-name);
        $obj
    
    });
    add-method(RakuAST::VarDeclaration::Placeholder::Named, 'generate-parameter', [RakuAST::VarDeclaration::Placeholder::Named, '', 0, 0], anon sub generate-parameter ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1907 src/Raku/ast/variable-declaration.rakumod
        
        RakuAST::Parameter.new:
            target => RakuAST::ParameterTarget::Var.new($SELF.lexical-name),
            names => [nqp::substr($SELF.lexical-name, 1)],
            optional => 0
    
    });
#line 1895 src/Raku/ast/variable-declaration.rakumod
    add-method(RakuAST::VarDeclaration::Placeholder::Named, 'lexical-name', [], anon sub lexical-name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::VarDeclaration::Placeholder::Named, '$!lexical-name') });
    compose(RakuAST::VarDeclaration::Placeholder::Named);
    parent(RakuAST::VarDeclaration::Placeholder::SlurpyArray, RakuAST::VarDeclaration::Placeholder);
    add-method(RakuAST::VarDeclaration::Placeholder::SlurpyArray, 'lexical-name', [RakuAST::VarDeclaration::Placeholder::SlurpyArray, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1919 src/Raku/ast/variable-declaration.rakumod
         '@_' 
    });
    add-method(RakuAST::VarDeclaration::Placeholder::SlurpyArray, 'generate-parameter', [RakuAST::VarDeclaration::Placeholder::SlurpyArray, '', 0, 0], anon sub generate-parameter ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1921 src/Raku/ast/variable-declaration.rakumod
        
        RakuAST::Parameter.new:
            target => RakuAST::ParameterTarget::Var.new($SELF.lexical-name),
            slurpy => RakuAST::Parameter::Slurpy::Flattened
    
    });
    compose(RakuAST::VarDeclaration::Placeholder::SlurpyArray);
    parent(RakuAST::VarDeclaration::Placeholder::SlurpyHash, RakuAST::VarDeclaration::Placeholder);
    add-method(RakuAST::VarDeclaration::Placeholder::SlurpyHash, 'lexical-name', [RakuAST::VarDeclaration::Placeholder::SlurpyHash, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1932 src/Raku/ast/variable-declaration.rakumod
         '%_' 
    });
    add-method(RakuAST::VarDeclaration::Placeholder::SlurpyHash, 'generate-parameter', [RakuAST::VarDeclaration::Placeholder::SlurpyHash, '', 0, 0], anon sub generate-parameter ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1934 src/Raku/ast/variable-declaration.rakumod
        
        RakuAST::Parameter.new:
            target => RakuAST::ParameterTarget::Var.new($SELF.lexical-name),
            slurpy => RakuAST::Parameter::Slurpy::Flattened
    
    });
    compose(RakuAST::VarDeclaration::Placeholder::SlurpyHash);
    parent(RakuAST::Var, RakuAST::Term);
    add-method(RakuAST::Var, 'sigil', [RakuAST::Var, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 5 src/Raku/ast/variable-access.rakumod
         '' 
    });
    compose(RakuAST::Var);
    parent(RakuAST::Var::Lexical, RakuAST::Var);
    parent(RakuAST::Var::Lexical, RakuAST::Lookup);
    add-attribute(RakuAST::Var::Lexical, str, '$!sigil');
    add-attribute(RakuAST::Var::Lexical, str, '$!twigil');
    add-attribute(RakuAST::Var::Lexical, RakuAST::Name, '$!desigilname');
    add-method(RakuAST::Var::Lexical, 'new', [RakuAST::Var::Lexical, '', 0, 0, str, '$name', 0, 1, Str, '$sigil', 1, 1, Str, '$twigil', 1, 1, RakuAST::Name, '$desigilname', 1, 1], anon sub new ($SELF_CONT, $name?, :$sigil?, :$twigil?, :$desigilname?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $sigil := nqp::decont($sigil);
        $twigil := nqp::decont($twigil);
        $desigilname := nqp::decont($desigilname);
#line 17 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        if $name {
            nqp::bindattr_s($obj, RakuAST::Var::Lexical, '$!sigil', nqp::substr($name, 0, 1));
            nqp::bindattr_s($obj, RakuAST::Var::Lexical, '$!twigil', '');
            nqp::bindattr($obj, RakuAST::Var::Lexical, '$!desigilname',
                RakuAST::Name.from-identifier(nqp::substr($name, 1)))
        }
        else {
            nqp::bindattr_s($obj, RakuAST::Var::Lexical, '$!sigil', $sigil);
            nqp::bindattr_s($obj, RakuAST::Var::Lexical, '$!twigil', $twigil);
            nqp::bindattr($obj, RakuAST::Var::Lexical, '$!desigilname', $desigilname);
        }
        $obj
    
    });
    add-method(RakuAST::Var::Lexical, 'postdeclaration-exception-name', [RakuAST::Var::Lexical, '', 0, 0], anon sub postdeclaration-exception-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 33 src/Raku/ast/variable-access.rakumod
         'X::Redeclaration::Outer' 
    });
    add-method(RakuAST::Var::Lexical, 'name', [RakuAST::Var::Lexical, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 35 src/Raku/ast/variable-access.rakumod
        
        (nqp::getattr_s($SELF, RakuAST::Var::Lexical, '$!sigil') // '') ~ (nqp::getattr_s($SELF, RakuAST::Var::Lexical, '$!twigil') // '') ~ nqp::getattr($SELF, RakuAST::Var::Lexical, '$!desigilname').canonicalize
    
    });
    add-method(RakuAST::Var::Lexical, 'can-be-bound-to', [RakuAST::Var::Lexical, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 39 src/Raku/ast/variable-access.rakumod
        
        $SELF.is-resolved ?? $SELF.resolution.can-be-bound-to !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Var::Lexical, 'resolve-with', [RakuAST::Var::Lexical, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 43 src/Raku/ast/variable-access.rakumod
        
        my $resolved := $resolver.resolve-lexical($SELF.name);
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Var::Lexical, 'undeclared-symbol-details', [RakuAST::Var::Lexical, '', 0, 0], anon sub undeclared-symbol-details ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 51 src/Raku/ast/variable-access.rakumod
        
        nqp::getattr_s($SELF, RakuAST::Var::Lexical, '$!sigil') eq '&'
            ?? RakuAST::UndeclaredSymbolDescription::Routine.new($SELF.name)
            !! Nil
    
    });
    add-method(RakuAST::Var::Lexical, 'is-topic', [RakuAST::Var::Lexical, '', 0, 0], anon sub is-topic ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 57 src/Raku/ast/variable-access.rakumod
        
        $SELF.name eq '$_'
    
    });
    add-method(RakuAST::Var::Lexical, 'IMPL-IS-META-OP', [RakuAST::Var::Lexical, '', 0, 0], anon sub IMPL-IS-META-OP ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 61 src/Raku/ast/variable-access.rakumod
        
        (nqp::getattr_s($SELF, RakuAST::Var::Lexical, '$!sigil') eq '&' || nqp::getattr_s($SELF, RakuAST::Var::Lexical, '$!sigil') eq '')
            && nqp::elems(nqp::getattr($SELF, RakuAST::Var::Lexical, '$!desigilname').colonpairs) == 1
            && nqp::istype(nqp::getattr($SELF, RakuAST::Var::Lexical, '$!desigilname').colonpairs[0], RakuAST::QuotedString)
    
    });
    add-method(RakuAST::Var::Lexical, 'IMPL-EXPR-QAST', [RakuAST::Var::Lexical, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 67 src/Raku/ast/variable-access.rakumod
        
        $SELF.resolution.IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::Var::Lexical, 'IMPL-BIND-QAST', [RakuAST::Var::Lexical, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 71 src/Raku/ast/variable-access.rakumod
        
        $SELF.resolution.IMPL-BIND-QAST($context, $source-qast)
    
    });
    add-method(RakuAST::Var::Lexical, 'IMPL-CAN-INTERPRET', [RakuAST::Var::Lexical, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 75 src/Raku/ast/variable-access.rakumod
        
        $SELF.is-resolved && nqp::istype($SELF.resolution, RakuAST::CompileTimeValue)
    
    });
    add-method(RakuAST::Var::Lexical, 'IMPL-INTERPRET', [RakuAST::Var::Lexical, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 79 src/Raku/ast/variable-access.rakumod
        
        $SELF.resolution.compile-time-value
    
    });
    add-method(RakuAST::Var::Lexical, 'dump-markers', [RakuAST::Var::Lexical, '', 0, 0], anon sub dump-markers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 83 src/Raku/ast/variable-access.rakumod
        
        '【' ~ $SELF.name ~ '】'
    
    });
#line 14 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Lexical, 'twigil', [], anon sub twigil ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Var::Lexical, '$!twigil') });
#line 13 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Lexical, 'sigil', [], anon sub sigil ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Var::Lexical, '$!sigil') });
#line 15 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Lexical, 'desigilname', [], anon sub desigilname ($self) { nqp::getattr(nqp::decont($self), RakuAST::Var::Lexical, '$!desigilname') });
    compose(RakuAST::Var::Lexical);
    parent(RakuAST::Var::Lexical::Constant, RakuAST::Var::Lexical);
    add-method(RakuAST::Var::Lexical::Constant, 'resolve-with', [RakuAST::Var::Lexical::Constant, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 93 src/Raku/ast/variable-access.rakumod
        
        my $resolved := $resolver.resolve-lexical-constant($SELF.name);
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    compose(RakuAST::Var::Lexical::Constant);
    parent(RakuAST::Var::Lexical::Setting, RakuAST::Var::Lexical);
    parent(RakuAST::Var::Lexical::Setting, RakuAST::Lookup);
    add-method(RakuAST::Var::Lexical::Setting, 'resolve-with', [RakuAST::Var::Lexical::Setting, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 108 src/Raku/ast/variable-access.rakumod
        
        my $resolved := $resolver.resolve-lexical-constant-in-setting($SELF.name);
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    compose(RakuAST::Var::Lexical::Setting);
    parent(RakuAST::Var::Dynamic, RakuAST::Var);
    parent(RakuAST::Var::Dynamic, RakuAST::Lookup);
    parent(RakuAST::Var::Dynamic, RakuAST::CheckTime);
    add-attribute(RakuAST::Var::Dynamic, str, '$!name');
    add-method(RakuAST::Var::Dynamic, 'new', [RakuAST::Var::Dynamic, '', 0, 0, str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 125 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Var::Dynamic, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Var::Dynamic, 'sigil', [RakuAST::Var::Dynamic, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 131 src/Raku/ast/variable-access.rakumod
         nqp::substr(nqp::getattr_s($SELF, RakuAST::Var::Dynamic, '$!name'), 0, 1) 
    });
    add-method(RakuAST::Var::Dynamic, 'can-be-bound-to', [RakuAST::Var::Dynamic, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 133 src/Raku/ast/variable-access.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Var::Dynamic, 'needs-resolution', [RakuAST::Var::Dynamic, '', 0, 0], anon sub needs-resolution ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 135 src/Raku/ast/variable-access.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Var::Dynamic, 'resolve-with', [RakuAST::Var::Dynamic, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 137 src/Raku/ast/variable-access.rakumod
        
        my $resolved := $resolver.resolve-lexical(nqp::getattr_s($SELF, RakuAST::Var::Dynamic, '$!name'), :current-scope-only);
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Var::Dynamic, 'postdeclaration-exception-name', [RakuAST::Var::Dynamic, '', 0, 0], anon sub postdeclaration-exception-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 145 src/Raku/ast/variable-access.rakumod
         'X::Dynamic::Postdeclaration' 
    });
    add-method(RakuAST::Var::Dynamic, 'PERFORM-CHECK', [RakuAST::Var::Dynamic, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 147 src/Raku/ast/variable-access.rakumod
        
        $SELF.add-sorry(
          $resolver.build-exception:
            'X::Dynamic::Package', :symbol(nqp::getattr_s($SELF, RakuAST::Var::Dynamic, '$!name'))
        ) if nqp::index(nqp::getattr_s($SELF, RakuAST::Var::Dynamic, '$!name'), '::') >= 0;
    
    });
    add-method(RakuAST::Var::Dynamic, 'IMPL-EXPR-QAST', [RakuAST::Var::Dynamic, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 154 src/Raku/ast/variable-access.rakumod
        
        # If it's resolved in the current scope, just a lexical access.
        if $SELF.is-resolved {
            my $name := $SELF.resolution.lexical-name;
            QAST::Var.new( :$name, :scope<lexical> )
        }
        else {
            my $with-star := QAST::SVal.new( :value(nqp::getattr_s($SELF, RakuAST::Var::Dynamic, '$!name')) );
            my $without-star := QAST::SVal.new( :value(nqp::replace(nqp::getattr_s($SELF, RakuAST::Var::Dynamic, '$!name'), 1, 1, '')) );
            QAST::Op.new(
                :op('ifnull'),
                QAST::Op.new( :op('getlexdyn'), $with-star),
                QAST::Op.new(
                    :op('callstatic'), :name('&DYNAMIC-FALLBACK'),
                    $with-star, $without-star
                )
            )
        }
    
    });
    add-method(RakuAST::Var::Dynamic, 'IMPL-BIND-QAST', [RakuAST::Var::Dynamic, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 174 src/Raku/ast/variable-access.rakumod
        
        # If it's resolved in the current scope, just a lexical bind.
        if $SELF.is-resolved {
            my $name := $SELF.resolution.lexical-name;
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :$name, :scope<lexical> ),
                $source-qast
            )
        }
        else {
            my $complain := QAST::Op.new(
                :op('die_s'),
                QAST::SVal.new( :value('Dynamic variable ' ~ nqp::getattr_s($SELF, RakuAST::Var::Dynamic, '$!name') ~ ' not found') )
            );
            QAST::Op.new(
                :op('bind'),
                QAST::VarWithFallback.new(
                    :name(nqp::getattr_s($SELF, RakuAST::Var::Dynamic, '$!name')), :scope('contextual'), :fallback($complain)
                ),
                $source-qast
            )
        }
    
    });
#line 123 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Dynamic, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Var::Dynamic, '$!name') });
    compose(RakuAST::Var::Dynamic);
    parent(RakuAST::Var::Attribute, RakuAST::Var);
    parent(RakuAST::Var::Attribute, RakuAST::ImplicitLookups);
    parent(RakuAST::Var::Attribute, RakuAST::Attaching);
    add-attribute(RakuAST::Var::Attribute, str, '$!name');
    add-attribute(RakuAST::Var::Attribute, RakuAST::Package, '$!package');
    add-method(RakuAST::Var::Attribute, 'new', [RakuAST::Var::Attribute, '', 0, 0, str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 209 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Var::Attribute, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Var::Attribute, 'sigil', [RakuAST::Var::Attribute, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 215 src/Raku/ast/variable-access.rakumod
         nqp::substr(nqp::getattr_s($SELF, RakuAST::Var::Attribute, '$!name'), 0, 1) 
    });
    add-method(RakuAST::Var::Attribute, 'can-be-bound-to', [RakuAST::Var::Attribute, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 217 src/Raku/ast/variable-access.rakumod
        
        my $package := nqp::getattr($SELF, RakuAST::Var::Attribute, '$!package').meta-object;
        my $attr-type := $package.HOW.get_attribute_for_usage($package, nqp::getattr_s($SELF, RakuAST::Var::Attribute, '$!name')).type;
        nqp::objprimspec($attr-type) ?? (Bool.WHO)<False> !! (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Var::Attribute, 'attach', [RakuAST::Var::Attribute, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 223 src/Raku/ast/variable-access.rakumod
        
        my $package := $resolver.find-attach-target('package');
        if $package {
            # We can't check attributes exist until we compose the
            # package, since they may come from roles. Thus we need to
            # attach them to the package.
            $package.ATTACH-ATTRIBUTE-USAGE($SELF);
            nqp::bindattr($SELF, RakuAST::Var::Attribute, '$!package', $package);
        }
        else {
            # TODO check-time error
        }
    
    });
    add-method(RakuAST::Var::Attribute, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Var::Attribute, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 237 src/Raku/ast/variable-access.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Term::Self.new,
            RakuAST::Var::Compiler::Lookup.new('$?CLASS'),
        ])
    
    });
    add-method(RakuAST::Var::Attribute, 'IMPL-QAST-PACKAGE-LOOKUP', [RakuAST::Var::Attribute, '', 0, 0, RakuAST::Impl::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-PACKAGE-LOOKUP ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 244 src/Raku/ast/variable-access.rakumod
        
        my $class := $SELF.get-implicit-lookups.AT-POS(1);
        if $class.is-resolved
          && nqp::istype($class.resolution, RakuAST::CompileTimeValue) {
            my $type-object := $class.resolution.compile-time-value;
            my $how := $type-object.HOW;
            unless nqp::can($how, 'archetypes') && nqp::can($how.archetypes, 'generic') && $how.archetypes.generic {
                return QAST::WVal.new(:value($type-object))
            }
        }
        return QAST::Var.new(:scope<lexical>, :name('$?CLASS'))
    
    });
    add-method(RakuAST::Var::Attribute, 'IMPL-EXPR-QAST', [RakuAST::Var::Attribute, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 257 src/Raku/ast/variable-access.rakumod
        
        my $package := nqp::getattr($SELF, RakuAST::Var::Attribute, '$!package').meta-object;
        my $attr-type := $package.HOW.get_attribute_for_usage($package, nqp::getattr_s($SELF, RakuAST::Var::Attribute, '$!name')).type;
        QAST::Var.new(
            :scope(nqp::objprimspec($attr-type) ?? 'attributeref' !! 'attribute'),
            :name(nqp::getattr_s($SELF, RakuAST::Var::Attribute, '$!name')), :returns($attr-type),
            $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context),
            $SELF.IMPL-QAST-PACKAGE-LOOKUP($context),
        )
    
    });
    add-method(RakuAST::Var::Attribute, 'IMPL-BIND-QAST', [RakuAST::Var::Attribute, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 268 src/Raku/ast/variable-access.rakumod
        
        my $package := nqp::getattr($SELF, RakuAST::Var::Attribute, '$!package').meta-object;
        my $attr-type := $package.HOW.get_attribute_for_usage($package, nqp::getattr_s($SELF, RakuAST::Var::Attribute, '$!name')).type;
        unless nqp::eqaddr($attr-type, Mu) {
            $context.ensure-sc($attr-type);
            $source-qast := QAST::Op.new(
                :op('p6bindassert'),
                $source-qast,
                QAST::WVal.new( :value($attr-type) )
            );
        }
        QAST::Op.new(
            :op('bind'),
            QAST::Var.new(
                :scope('attribute'), :name(nqp::getattr_s($SELF, RakuAST::Var::Attribute, '$!name')), :returns($attr-type),
                $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context),
                $SELF.IMPL-QAST-PACKAGE-LOOKUP($context),
            ),
            $source-qast
        )
    
    });
#line 206 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Attribute, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Var::Attribute, '$!name') });
    compose(RakuAST::Var::Attribute);
    parent(RakuAST::Var::Compiler, RakuAST::Var);
    compose(RakuAST::Var::Compiler);
    parent(RakuAST::Var::Compiler::File, RakuAST::Var::Compiler);
    add-attribute(RakuAST::Var::Compiler::File, Str, '$!file');
    add-method(RakuAST::Var::Compiler::File, 'new', [RakuAST::Var::Compiler::File, '', 0, 0, Str, '$file', 0, 0], anon sub new ($SELF_CONT, $file!) {
        my $SELF := nqp::decont($SELF_CONT);
        $file := nqp::decont($file);
#line 301 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Var::Compiler::File, '$!file', $file);
        $obj
    
    });
    add-method(RakuAST::Var::Compiler::File, 'sigil', [RakuAST::Var::Compiler::File, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 307 src/Raku/ast/variable-access.rakumod
         '$' 
    });
    add-method(RakuAST::Var::Compiler::File, 'IMPL-EXPR-QAST', [RakuAST::Var::Compiler::File, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 309 src/Raku/ast/variable-access.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::Var::Compiler::File, '$!file');
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
    add-method(RakuAST::Var::Compiler::File, 'IMPL-CAN-INTERPRET', [RakuAST::Var::Compiler::File, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 315 src/Raku/ast/variable-access.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Var::Compiler::File, 'IMPL-INTERPRET', [RakuAST::Var::Compiler::File, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 317 src/Raku/ast/variable-access.rakumod
         nqp::getattr($SELF, RakuAST::Var::Compiler::File, '$!file') 
    });
#line 299 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Compiler::File, 'file', [], anon sub file ($self) { nqp::getattr(nqp::decont($self), RakuAST::Var::Compiler::File, '$!file') });
    compose(RakuAST::Var::Compiler::File);
    parent(RakuAST::Var::Compiler::Line, RakuAST::Var::Compiler);
    add-attribute(RakuAST::Var::Compiler::Line, Int, '$!line');
    add-method(RakuAST::Var::Compiler::Line, 'new', [RakuAST::Var::Compiler::Line, '', 0, 0, Int, '$line', 0, 0], anon sub new ($SELF_CONT, $line!) {
        my $SELF := nqp::decont($SELF_CONT);
        $line := nqp::decont($line);
#line 326 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Var::Compiler::Line, '$!line', $line);
        $obj
    
    });
    add-method(RakuAST::Var::Compiler::Line, 'sigil', [RakuAST::Var::Compiler::Line, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 332 src/Raku/ast/variable-access.rakumod
         '$' 
    });
    add-method(RakuAST::Var::Compiler::Line, 'IMPL-EXPR-QAST', [RakuAST::Var::Compiler::Line, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 334 src/Raku/ast/variable-access.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::Var::Compiler::Line, '$!line');
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
    add-method(RakuAST::Var::Compiler::Line, 'IMPL-CAN-INTERPRET', [RakuAST::Var::Compiler::Line, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 340 src/Raku/ast/variable-access.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Var::Compiler::Line, 'IMPL-INTERPRET', [RakuAST::Var::Compiler::Line, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 342 src/Raku/ast/variable-access.rakumod
         nqp::getattr($SELF, RakuAST::Var::Compiler::Line, '$!line') 
    });
#line 324 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Compiler::Line, 'line', [], anon sub line ($self) { nqp::getattr(nqp::decont($self), RakuAST::Var::Compiler::Line, '$!line') });
    compose(RakuAST::Var::Compiler::Line);
    parent(RakuAST::Var::Compiler::Block, RakuAST::Var::Compiler);
    add-method(RakuAST::Var::Compiler::Block, 'IMPL-EXPR-QAST', [RakuAST::Var::Compiler::Block, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 348 src/Raku/ast/variable-access.rakumod
        
        QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) )
    
    });
    compose(RakuAST::Var::Compiler::Block);
    parent(RakuAST::Var::Compiler::Routine, RakuAST::Var::Compiler);
    parent(RakuAST::Var::Compiler::Routine, RakuAST::Var::Lexical);
    parent(RakuAST::Var::Compiler::Routine, RakuAST::Attaching);
    add-method(RakuAST::Var::Compiler::Routine, 'new', [RakuAST::Var::Compiler::Routine, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 358 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Var::Lexical, '$!sigil', '&');
        nqp::bindattr_s($obj, RakuAST::Var::Lexical, '$!twigil', '?');
        nqp::bindattr($obj, RakuAST::Var::Lexical, '$!desigilname', RakuAST::Name.from-identifier('ROUTINE'));
        $obj
    
    });
    add-method(RakuAST::Var::Compiler::Routine, 'attach', [RakuAST::Var::Compiler::Routine, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 366 src/Raku/ast/variable-access.rakumod
        
        my $routine := $resolver.find-attach-target('routine');
        if nqp::isconcrete($routine) {
            $routine.set-need-routine-variable();
        }
    
    });
    add-method(RakuAST::Var::Compiler::Routine, 'resolve-with', [RakuAST::Var::Compiler::Routine, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 373 src/Raku/ast/variable-access.rakumod
        
        my $resolved := $resolver.resolve-lexical('&?ROUTINE');
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Var::Compiler::Routine, 'IMPL-EXPR-QAST', [RakuAST::Var::Compiler::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 381 src/Raku/ast/variable-access.rakumod
        
        QAST::Var.new(:name<&?ROUTINE>, :scope<lexical>)
    
    });
    compose(RakuAST::Var::Compiler::Routine);
    parent(RakuAST::Var::Compiler::Lookup, RakuAST::Var::Compiler);
    parent(RakuAST::Var::Compiler::Lookup, RakuAST::Lookup);
    add-attribute(RakuAST::Var::Compiler::Lookup, str, '$!name');
    add-method(RakuAST::Var::Compiler::Lookup, 'new', [RakuAST::Var::Compiler::Lookup, '', 0, 0, str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 394 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Var::Compiler::Lookup, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Var::Compiler::Lookup, 'sigil', [RakuAST::Var::Compiler::Lookup, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 400 src/Raku/ast/variable-access.rakumod
         nqp::substr(nqp::getattr_s($SELF, RakuAST::Var::Compiler::Lookup, '$!name'), 0, 1) 
    });
    add-method(RakuAST::Var::Compiler::Lookup, 'resolve-with', [RakuAST::Var::Compiler::Lookup, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 402 src/Raku/ast/variable-access.rakumod
        
        my $resolved := $resolver.resolve-lexical(nqp::getattr_s($SELF, RakuAST::Var::Compiler::Lookup, '$!name'));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Var::Compiler::Lookup, 'IMPL-EXPR-QAST', [RakuAST::Var::Compiler::Lookup, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 410 src/Raku/ast/variable-access.rakumod
        
        $SELF.resolution.IMPL-LOOKUP-QAST($context)
    
    });
#line 392 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Compiler::Lookup, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Var::Compiler::Lookup, '$!name') });
    compose(RakuAST::Var::Compiler::Lookup);
    parent(RakuAST::Var::Doc, RakuAST::Var);
    add-attribute(RakuAST::Var::Doc, str, '$!name');
    add-method(RakuAST::Var::Doc, 'new', [RakuAST::Var::Doc, '', 0, 0, Str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 421 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Var::Doc, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Var::Doc, 'sigil', [RakuAST::Var::Doc, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 426 src/Raku/ast/variable-access.rakumod
         '$' 
    });
    add-method(RakuAST::Var::Doc, 'twigil', [RakuAST::Var::Doc, '', 0, 0], anon sub twigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 427 src/Raku/ast/variable-access.rakumod
         '=' 
    });
    add-method(RakuAST::Var::Doc, 'IMPL-EXPR-QAST', [RakuAST::Var::Doc, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 429 src/Raku/ast/variable-access.rakumod
        
        QAST::Var.new(:name($SELF.sigil ~ $SELF.twigil ~ nqp::getattr_s($SELF, RakuAST::Var::Doc, '$!name')), :scope<lexical>)
    
    });
#line 419 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Doc, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Var::Doc, '$!name') });
    compose(RakuAST::Var::Doc);
    parent(RakuAST::Var::PositionalCapture, RakuAST::Var);
    parent(RakuAST::Var::PositionalCapture, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Var::PositionalCapture, Int, '$!index');
    add-method(RakuAST::Var::PositionalCapture, 'new', [RakuAST::Var::PositionalCapture, '', 0, 0, Int, '$index', 0, 0], anon sub new ($SELF_CONT, $index!) {
        my $SELF := nqp::decont($SELF_CONT);
        $index := nqp::decont($index);
#line 441 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Var::PositionalCapture, '$!index', $index);
        $obj
    
    });
    add-method(RakuAST::Var::PositionalCapture, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Var::PositionalCapture, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 447 src/Raku/ast/variable-access.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('&postcircumfix:<[ ]>'),
            RakuAST::Var::Lexical.new('$/'),
        ])
    
    });
    add-method(RakuAST::Var::PositionalCapture, 'IMPL-EXPR-QAST', [RakuAST::Var::PositionalCapture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 454 src/Raku/ast/variable-access.rakumod
        
        my $lookups := $SELF.get-implicit-lookups;
        my $index := nqp::getattr($SELF, RakuAST::Var::PositionalCapture, '$!index');
        $context.ensure-sc($index);
        QAST::Op.new(
            :op('call'),
            :name($lookups.AT-POS(0).resolution.lexical-name),
            $lookups.AT-POS(1).IMPL-TO-QAST($context),
            QAST::WVal.new( :value($index) )
        )
    
    });
#line 439 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::PositionalCapture, 'index', [], anon sub index ($self) { nqp::getattr(nqp::decont($self), RakuAST::Var::PositionalCapture, '$!index') });
    compose(RakuAST::Var::PositionalCapture);
    parent(RakuAST::Var::NamedCapture, RakuAST::Var);
    parent(RakuAST::Var::NamedCapture, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Var::NamedCapture, RakuAST::QuotedString, '$!index');
    add-method(RakuAST::Var::NamedCapture, 'new', [RakuAST::Var::NamedCapture, '', 0, 0, RakuAST::QuotedString, '$index', 0, 0], anon sub new ($SELF_CONT, $index!) {
        my $SELF := nqp::decont($SELF_CONT);
        $index := nqp::decont($index);
#line 474 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Var::NamedCapture, '$!index', $index);
        $obj
    
    });
    add-method(RakuAST::Var::NamedCapture, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Var::NamedCapture, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 480 src/Raku/ast/variable-access.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('&postcircumfix:<{ }>'),
            RakuAST::Var::Lexical.new('$/'),
        ])
    
    });
    add-method(RakuAST::Var::NamedCapture, 'IMPL-EXPR-QAST', [RakuAST::Var::NamedCapture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 487 src/Raku/ast/variable-access.rakumod
        
        my $lookups := $SELF.get-implicit-lookups;
        my $op := QAST::Op.new(
            :op('call'),
            :name($lookups.AT-POS(0).resolution.lexical-name),
            $lookups.AT-POS(1).IMPL-TO-QAST($context),
        );
        $op.push(nqp::getattr($SELF, RakuAST::Var::NamedCapture, '$!index').IMPL-TO-QAST($context)) unless nqp::getattr($SELF, RakuAST::Var::NamedCapture, '$!index').is-empty-words;
        $op
    
    });
    add-method(RakuAST::Var::NamedCapture, 'visit-children', [RakuAST::Var::NamedCapture, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 498 src/Raku/ast/variable-access.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Var::NamedCapture, '$!index'));
    
    });
#line 472 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::NamedCapture, 'index', [], anon sub index ($self) { nqp::getattr(nqp::decont($self), RakuAST::Var::NamedCapture, '$!index') });
    compose(RakuAST::Var::NamedCapture);
    parent(RakuAST::Var::Package, RakuAST::Var);
    parent(RakuAST::Var::Package, RakuAST::Lookup);
    add-attribute(RakuAST::Var::Package, str, '$!sigil');
    add-attribute(RakuAST::Var::Package, RakuAST::Name, '$!name');
    add-method(RakuAST::Var::Package, 'new', [RakuAST::Var::Package, '', 0, 0, RakuAST::Name, '$name', 1, 0, Any, '$sigil', 1, 1], anon sub new ($SELF_CONT, :$name!, :$sigil?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $sigil := nqp::decont($sigil);
#line 511 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Var::Package, '$!name', $name);
        nqp::bindattr_s($obj, RakuAST::Var::Package, '$!sigil', $sigil);
        $obj
    
    });
    add-method(RakuAST::Var::Package, 'sigil', [RakuAST::Var::Package, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 518 src/Raku/ast/variable-access.rakumod
         nqp::getattr_s($SELF, RakuAST::Var::Package, '$!sigil') 
    });
    add-method(RakuAST::Var::Package, 'can-be-bound-to', [RakuAST::Var::Package, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 520 src/Raku/ast/variable-access.rakumod
        
        $SELF.is-resolved ?? $SELF.resolution.can-be-bound-to !! nqp::getattr($SELF, RakuAST::Var::Package, '$!name').is-pseudo-package
    
    });
    add-method(RakuAST::Var::Package, 'resolve-with', [RakuAST::Var::Package, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 524 src/Raku/ast/variable-access.rakumod
        
        my @parts := $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Var::Package, '$!name').parts);
        my $resolved := $resolver.resolve-name(RakuAST::Name.new(@parts[0]));
        if $resolved {
            $SELF.set-resolution($resolved);
        }
        Nil
    
    });
    add-method(RakuAST::Var::Package, 'IMPL-EXPR-QAST', [RakuAST::Var::Package, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 533 src/Raku/ast/variable-access.rakumod
        
        my str $sigil := nqp::getattr_s($SELF, RakuAST::Var::Package, '$!sigil');
        if nqp::getattr($SELF, RakuAST::Var::Package, '$!name').is-simple {
            if nqp::getattr($SELF, RakuAST::Var::Package, '$!name').is-pseudo-package {
                nqp::getattr($SELF, RakuAST::Var::Package, '$!name').IMPL-QAST-PSEUDO-PACKAGE-LOOKUP($context, :$sigil);
            }
            else {
                my @parts := nqp::clone($SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Var::Package, '$!name').parts));
                my $final := @parts[nqp::elems(@parts) - 1];
                my $result;
                if $SELF.is-resolved {
                    my $name := $SELF.resolution.lexical-name;
                    nqp::shift(@parts);
                    $result := nqp::istype($SELF.resolution, RakuAST::CompileTimeValue)
                        ?? QAST::WVal.new(:value($SELF.resolution.compile-time-value))
                        !! QAST::Var.new(:$name, :scope<lexical>);
                }
                else {
                    $result := QAST::Op.new(:op<getcurhllsym>, QAST::SVal.new(:value<GLOBAL>));
                }
                for @parts {
                    $result := QAST::Op.new( :op('who'), $result );
                    $result := $_.IMPL-QAST-PACKAGE-LOOKUP-PART($context, $result, $_ =:= $final, :$sigil);
                }
                $result
            }
        }
        else {
            nqp::getattr($SELF, RakuAST::Var::Package, '$!name').IMPL-QAST-INDIRECT-LOOKUP($context, :$sigil)
        }
    
    });
    add-method(RakuAST::Var::Package, 'IMPL-ADJUST-QAST-FOR-LVALUE', [RakuAST::Var::Package, '', 0, 0, Mu, '$qast', 0, 0], anon sub IMPL-ADJUST-QAST-FOR-LVALUE ($SELF_CONT, $qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $qast := nqp::decont($qast);
#line 565 src/Raku/ast/variable-access.rakumod
        
        my $last := $qast.list[-1];
        $qast.pop if nqp::istype($last, QAST::SpecialArg) && $last.named eq 'global_fallback';
        $qast
    
    });
    add-method(RakuAST::Var::Package, 'IMPL-BIND-QAST', [RakuAST::Var::Package, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 571 src/Raku/ast/variable-access.rakumod
        
        my $qast := nqp::getattr($SELF, RakuAST::Var::Package, '$!name').IMPL-QAST-PSEUDO-PACKAGE-LOOKUP($context, :sigil(nqp::getattr_s($SELF, RakuAST::Var::Package, '$!sigil')));
        $source-qast.named('BIND');
        $qast.push($source-qast);
        $qast
    
    });
    add-method(RakuAST::Var::Package, 'visit-children', [RakuAST::Var::Package, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 578 src/Raku/ast/variable-access.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Var::Package, '$!name'));
    
    });
#line 509 src/Raku/ast/variable-access.rakumod
    add-method(RakuAST::Var::Package, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Var::Package, '$!name') });
    compose(RakuAST::Var::Package);
    parent(RakuAST::Var::Slang, RakuAST::Var);
    parent(RakuAST::Var::Slang, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Var::Slang, Mu, '$!grammar');
    add-attribute(RakuAST::Var::Slang, Mu, '$!actions');
    add-method(RakuAST::Var::Slang, 'new', [RakuAST::Var::Slang, '', 0, 0, Mu, '$grammar', 1, 0, Mu, '$actions', 1, 0], anon sub new ($SELF_CONT, :$grammar!, :$actions!) {
        my $SELF := nqp::decont($SELF_CONT);
        $grammar := nqp::decont($grammar);
        $actions := nqp::decont($actions);
#line 590 src/Raku/ast/variable-access.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Var::Slang, '$!grammar', $grammar);
        nqp::bindattr($obj, RakuAST::Var::Slang, '$!actions', $actions);
        $obj
    
    });
    add-method(RakuAST::Var::Slang, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Var::Slang, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 597 src/Raku/ast/variable-access.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Slang')),
        ])
    
    });
    add-method(RakuAST::Var::Slang, 'sigil', [RakuAST::Var::Slang, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 603 src/Raku/ast/variable-access.rakumod
         '$' 
    });
    add-method(RakuAST::Var::Slang, 'IMPL-EXPR-QAST', [RakuAST::Var::Slang, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 605 src/Raku/ast/variable-access.rakumod
        
        my $qast := QAST::Op.new(
            :op<callmethod>, :name<new>, :returns($SELF.get-implicit-lookups.AT-POS(1)),
            QAST::Var.new( :name<Slang>, :scope<lexical> ));
        my $g := nqp::getattr($SELF, RakuAST::Var::Slang, '$!grammar');
        $context.ensure-sc($g);
        my $a := nqp::getattr($SELF, RakuAST::Var::Slang, '$!actions');
        if !nqp::isnull($g) {
            my $wval := QAST::WVal.new( :value($g) );
            $wval.named('grammar');
            $qast.push($wval);
            $wval := QAST::WVal.new( :value($a) );
            $wval.named('actions');
            $qast.push($wval);
        }
        $qast
    
    });
    compose(RakuAST::Var::Slang);
    parent(RakuAST::Contextualizer, RakuAST::Term);
    add-attribute(RakuAST::Contextualizer, RakuAST::Contextualizable, '$!target');
    add-method(RakuAST::Contextualizer, 'new', [RakuAST::Contextualizer, '', 0, 0, RakuAST::Contextualizable, '$target', 0, 0], anon sub new ($SELF_CONT, $target!) {
        my $SELF := nqp::decont($SELF_CONT);
        $target := nqp::decont($target);
#line 8 src/Raku/ast/contextualizer.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Contextualizer, '$!target', $target);
        $obj
    
    });
    add-method(RakuAST::Contextualizer, 'IMPL-EXPR-QAST', [RakuAST::Contextualizer, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 14 src/Raku/ast/contextualizer.rakumod
        
        # TODO 6.c semantics with $/
        QAST::Op.new(
            :op('callmethod'), :name($SELF.IMPL-METHOD),
            nqp::getattr($SELF, RakuAST::Contextualizer, '$!target').IMPL-TO-QAST($context)
        )
    
    });
    add-method(RakuAST::Contextualizer, 'visit-children', [RakuAST::Contextualizer, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 22 src/Raku/ast/contextualizer.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Contextualizer, '$!target'));
    
    });
#line 6 src/Raku/ast/contextualizer.rakumod
    add-method(RakuAST::Contextualizer, 'target', [], anon sub target ($self) { nqp::getattr(nqp::decont($self), RakuAST::Contextualizer, '$!target') });
    compose(RakuAST::Contextualizer);
    parent(RakuAST::Contextualizer::Item, RakuAST::Contextualizer);
    add-method(RakuAST::Contextualizer::Item, 'IMPL-METHOD', [RakuAST::Contextualizer::Item, '', 0, 0], anon sub IMPL-METHOD ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 31 src/Raku/ast/contextualizer.rakumod
         'item' 
    });
    add-method(RakuAST::Contextualizer::Item, 'sigil', [RakuAST::Contextualizer::Item, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 32 src/Raku/ast/contextualizer.rakumod
         '$' 
    });
    compose(RakuAST::Contextualizer::Item);
    parent(RakuAST::Contextualizer::List, RakuAST::Contextualizer);
    add-method(RakuAST::Contextualizer::List, 'IMPL-METHOD', [RakuAST::Contextualizer::List, '', 0, 0], anon sub IMPL-METHOD ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 39 src/Raku/ast/contextualizer.rakumod
         'cache' 
    });
    add-method(RakuAST::Contextualizer::List, 'sigil', [RakuAST::Contextualizer::List, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 40 src/Raku/ast/contextualizer.rakumod
         '@' 
    });
    compose(RakuAST::Contextualizer::List);
    parent(RakuAST::Contextualizer::Hash, RakuAST::Contextualizer);
    add-method(RakuAST::Contextualizer::Hash, 'IMPL-METHOD', [RakuAST::Contextualizer::Hash, '', 0, 0], anon sub IMPL-METHOD ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 47 src/Raku/ast/contextualizer.rakumod
         'hash' 
    });
    add-method(RakuAST::Contextualizer::Hash, 'sigil', [RakuAST::Contextualizer::Hash, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 48 src/Raku/ast/contextualizer.rakumod
         '%' 
    });
    compose(RakuAST::Contextualizer::Hash);
    parent(RakuAST::Blockoid, RakuAST::SinkPropagator);
    add-attribute(RakuAST::Blockoid, RakuAST::StatementList, '$!statement-list');
    add-method(RakuAST::Blockoid, 'new', [RakuAST::Blockoid, '', 0, 0, RakuAST::StatementList, '$statement-list', 0, 1], anon sub new ($SELF_CONT, $statement-list?) {
        my $SELF := nqp::decont($SELF_CONT);
        $statement-list := nqp::decont($statement-list);
#line 7 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Blockoid, '$!statement-list',
            $statement-list // RakuAST::StatementList.new);
        $obj
    
    });
    add-method(RakuAST::Blockoid, 'propagate-sink', [RakuAST::Blockoid, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 14 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::Blockoid, '$!statement-list').propagate-sink($is-sunk, :has-block-parent((Bool.WHO)<True>))
    
    });
    add-method(RakuAST::Blockoid, 'IMPL-TO-QAST', [RakuAST::Blockoid, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '$immediate', 1, 1], anon sub IMPL-TO-QAST ($SELF_CONT, $context!, :$immediate?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $immediate := nqp::decont($immediate);
#line 18 src/Raku/ast/code.rakumod
        
        my $stmts := nqp::getattr($SELF, RakuAST::Blockoid, '$!statement-list').IMPL-TO-QAST($context);
        if nqp::elems($stmts.list) == 0 {
            $stmts.push(QAST::WVal.new( :value(Nil) ));
        }
        $stmts
    
    });
    add-method(RakuAST::Blockoid, 'visit-children', [RakuAST::Blockoid, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 26 src/Raku/ast/code.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Blockoid, '$!statement-list'));
    
    });
    add-method(RakuAST::Blockoid, 'IMPL-CAN-INTERPRET', [RakuAST::Blockoid, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 30 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::Blockoid, '$!statement-list').IMPL-CAN-INTERPRET
    
    });
    add-method(RakuAST::Blockoid, 'IMPL-INTERPRET', [RakuAST::Blockoid, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 34 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::Blockoid, '$!statement-list').IMPL-INTERPRET($ctx)
    
    });
#line 5 src/Raku/ast/code.rakumod
    add-method(RakuAST::Blockoid, 'statement-list', [], anon sub statement-list ($self) { nqp::getattr(nqp::decont($self), RakuAST::Blockoid, '$!statement-list') });
    compose(RakuAST::Blockoid);
    parent(RakuAST::OnlyStar, RakuAST::Blockoid);
    parent(RakuAST::OnlyStar, RakuAST::Term);
    add-method(RakuAST::OnlyStar, 'new', [RakuAST::OnlyStar, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 43 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Blockoid, '$!statement-list',
          RakuAST::StatementList.new);
        $obj
    
    });
    add-method(RakuAST::OnlyStar, 'IMPL-TO-QAST', [RakuAST::OnlyStar, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '$immediate', 1, 1], anon sub IMPL-TO-QAST ($SELF_CONT, $context!, :$immediate?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $immediate := nqp::decont($immediate);
#line 50 src/Raku/ast/code.rakumod
        
        QAST::Op.new(
            :op('dispatch'),
            QAST::SVal.new( :value('boot-resume') ),
            QAST::IVal.new( :value(nqp::const::DISP_ONLYSTAR) ));
    
    });
    compose(RakuAST::OnlyStar);
    parent(RakuAST::Code, RakuAST::Attaching);
    add-attribute(RakuAST::Code, Bool, '$!custom-args');
    add-attribute(RakuAST::Code, Mu, '$!qast-block');
    add-attribute(RakuAST::Code, str, '$!cuid');
    add-attribute(RakuAST::Code, RakuAST::Resolver, '$!resolver');
    add-method(RakuAST::Code, 'attach', [RakuAST::Code, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 68 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Code, '$!resolver', $resolver.clone);
    
    });
    add-method(RakuAST::Code, 'set-custom-args', [RakuAST::Code, '', 0, 0], anon sub set-custom-args ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 72 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Code, '$!custom-args', (Bool.WHO)<True>);
    
    });
    add-method(RakuAST::Code, 'IMPL-CLOSURE-QAST', [RakuAST::Code, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Bool, '$regex', 1, 1], anon sub IMPL-CLOSURE-QAST ($SELF_CONT, $context!, :$regex?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $regex := nqp::decont($regex);
#line 76 src/Raku/ast/code.rakumod
        
        my $code-obj := $SELF.meta-object;
        $context.ensure-sc($code-obj);
        my $clone := QAST::Op.new(
            :op('callmethod'), :name('clone'),
            QAST::WVal.new( :value($code-obj) )
        );
        $SELF.IMPL-TWEAK-REGEX-CLONE($context, $clone) if $regex;
        QAST::Op.new( :op('p6capturelex'), $clone )
    
    });
    add-method(RakuAST::Code, 'IMPL-QAST-BLOCK', [RakuAST::Code, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 88 src/Raku/ast/code.rakumod
        
        unless (nqp::getattr($SELF, RakuAST::Code, '$!qast-block')) {
            $SELF.IMPL-FINISH-CODE-OBJECT($context, :$blocktype, :$expression);
        }
        nqp::getattr($SELF, RakuAST::Code, '$!qast-block')
    
    });
    add-method(RakuAST::Code, 'IMPL-FINISH-CODE-OBJECT', [RakuAST::Code, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-FINISH-CODE-OBJECT ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 96 src/Raku/ast/code.rakumod
        
        my $block := $SELF.IMPL-QAST-FORM-BLOCK($context, :$blocktype, :$expression);
        $SELF.IMPL-LINK-META-OBJECT($context, $block);
        nqp::bindattr($SELF, RakuAST::Code, '$!qast-block', $block);
    
    });
    add-method(RakuAST::Code, 'IMPL-STUB-CODE', [RakuAST::Code, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-STUB-CODE ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 102 src/Raku/ast/code.rakumod
        
        # Not all objects of certain subclasses will be attached properly,
        # so get that resolver here
        nqp::bindattr($SELF, RakuAST::Code, '$!resolver', $resolver.clone)
            unless nqp::getattr($SELF, RakuAST::Code, '$!resolver');

        my $code-obj := $SELF.meta-object;
        nqp::bindattr_s($SELF, RakuAST::Code, '$!cuid', QAST::Block.next-cuid());

        # Stash it under the QAST block unique ID.
        my str $cuid := nqp::getattr_s($SELF, RakuAST::Code, '$!cuid');
        $context.sub-id-to-code-object(){$cuid} := $code-obj;

        my $precomp;
        my $stub := nqp::freshcoderef(sub (*@pos, *%named) {
            my $code-obj := nqp::getcodeobj(nqp::curcode());
            unless $precomp {
                my $*IMPL-COMPILE-DYNAMICALLY := 1;
                my $block := $SELF.IMPL-QAST-BLOCK($context, :blocktype<declaration_static>);
                $precomp := $SELF.IMPL-COMPILE-DYNAMICALLY($resolver, $context, $block);
            }
            unless nqp::isnull($code-obj) {
                return $code-obj(|@pos, |%named);
            }
        });

        nqp::bindattr($code-obj, Code, '$!do', $stub);
        nqp::markcodestatic($stub);
        nqp::markcodestub($stub);
        nqp::setcodeobj($stub, $code-obj);

        # Create the compiler stuff array and stick it in the code object.
        # Also add clearup task to remove it again later.
        my @compstuff;
        nqp::bindattr($code-obj, Code, '@!compstuff', @compstuff);
        $context.add-cleanup-task(sub () {
            nqp::bindattr($code-obj, Code, '@!compstuff', nqp::null());
            nqp::bindattr($SELF, RakuAST::Code, '$!resolver', RakuAST::Resolver) if $context.is-precompilation-mode;
        });

        @compstuff[2] := sub ($orig, $clone) {
            my $do := nqp::getattr($clone, Code, '$!do');
            nqp::markcodestub($do);
            $context.add-cleanup-task(sub () {
                nqp::bindattr($clone, Code, '@!compstuff', nqp::null());
            });
            $context.add-clone-for-cuid($clone, $cuid);
        }

        $stub
    
    });
    add-method(RakuAST::Code, 'IMPL-LINK-META-OBJECT', [RakuAST::Code, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$block', 0, 0], anon sub IMPL-LINK-META-OBJECT ($SELF_CONT, $context!, $block!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $block := nqp::decont($block);
#line 154 src/Raku/ast/code.rakumod
        
        # Obtain the meta-object and connect it to the code block.
        my $code-obj := $SELF.meta-object;
        $context.ensure-sc($code-obj);

        # Associate QAST block with code object, which will ensure it is
        # fixed up as needed.
        $block.code_object($code-obj);

        my @compstuff := nqp::getattr($code-obj, Code, '@!compstuff');
        my $cuid := nqp::getattr_s($SELF, RakuAST::Code, '$!cuid');
        $block.set-cuid(nqp::getattr_s($SELF, RakuAST::Code, '$!cuid'));

        my $fixups := QAST::Stmts.new();
        unless $context.is-precompilation-mode || $context.is-nested {
            # We need to do a fixup of the code block for the non-precompiled case.
            $fixups.push(
                QAST::Op.new(
                    :op('bindattr'),
                    QAST::WVal.new( :value($code-obj) ),
                    QAST::WVal.new( :value(Code) ),
                    QAST::SVal.new( :value('$!do') ),
                    QAST::BVal.new( :value($block) )
                )
            );
            @compstuff[2] := sub ($orig, $clone) {
                $context.ensure-sc($clone);
                $context.add-cleanup-task(sub () {
                    nqp::bindattr($clone, Code, '@!compstuff', nqp::null());
                });
                $context.add-clone-for-cuid($clone, $cuid);

                my $tmp := $fixups.unique('tmp_block_fixup');
                $fixups.push(QAST::Stmt.new(
                    QAST::Op.new(
                        :op('bind'),
                        QAST::Var.new( :name($tmp), :scope('local'), :decl('var') ),
                        QAST::Op.new( :op('clone'), QAST::BVal.new( :value($block) ) )
                    ),
                    QAST::Op.new(
                        :op('bind'),
                        QAST::Var.new(
                            :name('$!do'), :scope('attribute'),
                            QAST::WVal.new( :value($clone) ),
                            QAST::WVal.new( :value(Code) )
                        ),
                        QAST::Var.new( :name($tmp), :scope('local') ),
                    ),
                    QAST::Op.new(
                        :op('setcodeobj'),
                        QAST::Var.new( :name($tmp), :scope('local') ),
                        QAST::WVal.new( :value($clone) )
                    )));
            }
            @compstuff[3] := $fixups;
        }

        @compstuff[0] := $block;

        $context.add-code-ref(nqp::getattr($code-obj, Code, '$!do'), $block);

        $context.add-fixup-task(-> {
            $fixups
        });
    
    });
    add-method(RakuAST::Code, 'IMPL-COMPILE-DYNAMICALLY', [RakuAST::Code, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$block', 0, 0], anon sub IMPL-COMPILE-DYNAMICALLY ($SELF_CONT, $resolver!, $context!, $block!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $block := nqp::decont($block);
#line 220 src/Raku/ast/code.rakumod
        
        my $wrapper := QAST::Block.new(QAST::Stmts.new(), $block);
        $wrapper.annotate('DYN_COMP_WRAPPER', 1);

        my $compunit := QAST::CompUnit.new(
            :hll('Raku'),
            :sc($context.sc()),
            :compilation_mode(0),
            $wrapper
        );
        my $comp := $*HLL-COMPILER // nqp::getcomp("Raku");
        my $precomp := $comp.compile($compunit, :from<qast>, :compunit_ok(1));
        {
            my $resolver := nqp::getattr($SELF, RakuAST::Code, '$!resolver');
#?if !jvm
            nqp::dispatch(
                'boot-syscall',
                'set-compunit-resolver',
                $precomp,
                -> $name {
                    my $result := $resolver.resolve-lexical($name);
                    if $result {
                        nqp::istype($result, RakuAST::CompileTimeValue)
                            ?? $result.compile-time-value
                            !! Mu
                    }
                    else {
                        nqp::die("No lexical found with name $name via resolver");
                    }
                },
                -> $dyn-name {
                    my $dynamic-fallback := $resolver.resolve-lexical-in-outer('&DYNAMIC-FALLBACK');
                    my $without-star := nqp::replace($dyn-name, 1, 1, '');
                    $dynamic-fallback.compile-time-value()($dyn-name, $without-star)
                }
            );
#?endif
        }

        my $mainline := $comp.backend.compunit_mainline($precomp);
        $mainline();

        # Fix up Code object associations (including nested blocks).
        # We un-stub any code objects for already-compiled inner blocks
        # to avoid wasting re-compiling them, and also to help make
        # parametric role outer chain work out. Also set up their static
        # lexpads, if they have any.
        my @coderefs := $comp.backend.compunit_coderefs($precomp);
        my int $num-subs := nqp::elems(@coderefs);
        my int $i := -1;
        my $result;
        while ++$i < $num-subs {
            my $subid := nqp::getcodecuid(@coderefs[$i]);

            # un-stub code objects for blocks we just compiled:
            my %sub-id-to-code-object := $context.sub-id-to-code-object();
            if nqp::existskey(%sub-id-to-code-object, $subid) {
                my $code-obj := %sub-id-to-code-object{$subid};
                nqp::setcodeobj(@coderefs[$i], $code-obj);
                nqp::bindattr($code-obj, Code, '$!do', @coderefs[$i]);
                my $fixups := nqp::getattr($code-obj, Code, '@!compstuff')[3];
                if $fixups {
                    $fixups.pop() while $fixups.list;
                }
                nqp::bindattr($code-obj, Code, '@!compstuff', nqp::null());
            }

            # un-stub clones of code objects for blocks we just compiled:
            my %sub-id-to-cloned-code-objects := $context.sub-id-to-cloned-code-objects();
            if nqp::existskey(%sub-id-to-cloned-code-objects, $subid) {
                for %sub-id-to-cloned-code-objects{$subid} -> $code-obj {
                    my $clone := nqp::clone(@coderefs[$i]);
                    nqp::setcodeobj($clone, $code-obj);
                    nqp::bindattr($code-obj, Code, '$!do', $clone);
                    my $fixups := nqp::getattr($code-obj, Code, '@!compstuff')[3];
                    if $fixups {
                        $fixups.pop() while $fixups.list;
                    }
                    nqp::bindattr($code-obj, Code, '@!compstuff', nqp::null());
                }
            }

            my %sub-id-to-sc-idx := $context.sub-id-to-sc-idx();
            if nqp::existskey(%sub-id-to-sc-idx, $subid) {
                nqp::markcodestatic(@coderefs[$i]);
                nqp::scsetcode($context.sc, %sub-id-to-sc-idx{$subid}, @coderefs[$i]);
            }

            if $subid eq $block.cuid {
                # Remember the VM coderef that maps to the thing we were originally
                # asked to compile.
                $result := @coderefs[$i];
            }
        }
        $result
    
    });
    add-method(RakuAST::Code, 'IMPL-APPEND-SIGNATURE-RETURN', [RakuAST::Code, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$qast-stmts', 0, 0], anon sub IMPL-APPEND-SIGNATURE-RETURN ($SELF_CONT, $context!, $qast-stmts!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $qast-stmts := nqp::decont($qast-stmts);
#line 317 src/Raku/ast/code.rakumod
        
        my $signature := $SELF.signature;
        if $signature && $signature.provides-return-value {
            $qast-stmts.push($signature.returns.IMPL-TO-QAST($context));
        }
        $qast-stmts
    
    });
    add-method(RakuAST::Code, 'needs-sink-call', [RakuAST::Code, '', 0, 0], anon sub needs-sink-call ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 325 src/Raku/ast/code.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Code, 'signature', [RakuAST::Code, '', 0, 0], anon sub signature ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 327 src/Raku/ast/code.rakumod
         Nil 
    });
#line 62 src/Raku/ast/code.rakumod
    add-method(RakuAST::Code, 'custom-args', [], anon sub custom-args ($self) { nqp::getattr(nqp::decont($self), RakuAST::Code, '$!custom-args') });
    compose(RakuAST::Code);
    parent(RakuAST::ExpressionThunk, RakuAST::Code);
    parent(RakuAST::ExpressionThunk, RakuAST::Meta);
    parent(RakuAST::ExpressionThunk, RakuAST::BeginTime);
    add-attribute(RakuAST::ExpressionThunk, RakuAST::ExpressionThunk, '$!next');
    add-attribute(RakuAST::ExpressionThunk, RakuAST::Signature, '$!signature');
    add-method(RakuAST::ExpressionThunk, 'set-next', [RakuAST::ExpressionThunk, '', 0, 0, RakuAST::ExpressionThunk, '$next', 0, 0], anon sub set-next ($SELF_CONT, $next!) {
        my $SELF := nqp::decont($SELF_CONT);
        $next := nqp::decont($next);
#line 340 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::ExpressionThunk, '$!next', $next);
        Nil
    
    });
    add-method(RakuAST::ExpressionThunk, 'thunk-kind', [RakuAST::ExpressionThunk, '', 0, 0], anon sub thunk-kind ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 345 src/Raku/ast/code.rakumod
        
        $SELF.HOW.name($SELF)
    
    });
    add-method(RakuAST::ExpressionThunk, 'thunk-details', [RakuAST::ExpressionThunk, '', 0, 0], anon sub thunk-details ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 349 src/Raku/ast/code.rakumod
        
        ''
    
    });
    add-method(RakuAST::ExpressionThunk, 'is-begin-performed-before-children', [RakuAST::ExpressionThunk, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 353 src/Raku/ast/code.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::ExpressionThunk, 'PERFORM-BEGIN', [RakuAST::ExpressionThunk, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 355 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-STUB-CODE($resolver, $context);

        Nil
    
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-THUNK-CODE-QAST', [RakuAST::ExpressionThunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$target', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub IMPL-THUNK-CODE-QAST ($SELF_CONT, $context!, $target!, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $target := nqp::decont($target);
        $expression := nqp::decont($expression);
#line 366 src/Raku/ast/code.rakumod
        

        my $block := $SELF.IMPL-QAST-BLOCK($context, :$expression);
        # Link and push the produced code block.
        $target.push($block);
    
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-QAST-FORM-BLOCK', [RakuAST::ExpressionThunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 0], anon sub IMPL-QAST-FORM-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 374 src/Raku/ast/code.rakumod
        
        # From the block, compiling the signature.
        my $signature := $SELF.IMPL-GET-OR-PRODUCE-SIGNATURE;
        my $block :=
            $SELF.IMPL-SET-NODE(
                QAST::Block.new(
                    :blocktype('declaration_static'),
                    QAST::Stmts.new( $signature.IMPL-QAST-BINDINGS($context) )),
                :key);
        my $stmts := QAST::Stmts.new();
        for $SELF.IMPL-UNWRAP-LIST($signature.parameters) {
            $stmts.push($_.target.IMPL-QAST-DECL($context)) unless $_.target.lexical-name eq '$_';
        }
        if nqp::istype($SELF, RakuAST::ImplicitDeclarations) {
            for $SELF.IMPL-UNWRAP-LIST($SELF.get-implicit-declarations()) -> $decl {
                if $decl.is-simple-lexical-declaration {
                    nqp::push($stmts, $decl.IMPL-QAST-DECL($context));
                }
            }
        }
        # Add blocks embedded in the thunked expression children of the thunk
        # block, so they can access the thunk argument.
        my @code-todo := [$expression];
        while @code-todo {
            my $visit := @code-todo.shift;
            $visit.visit-children: -> $node {
                if nqp::istype($node, RakuAST::Code) {
                    if $visit =:= $expression
                        || !(nqp::istype($visit, RakuAST::IMPL::ImmediateBlockUser) &&
                            $visit.IMPL-IMMEDIATELY-USES($node))
                    {
                        $stmts.push($node.IMPL-QAST-DECL-CODE($context));
                    }
                }
                unless nqp::istype($node, RakuAST::LexicalScope) {
                    @code-todo.push($node);
                }
            }
        }
        $block.push($stmts) if $stmts.list;
        $block.arity($signature.arity);

        # If there's an inner thunk the body evaluates to that.
        if nqp::getattr($SELF, RakuAST::ExpressionThunk, '$!next') {
            nqp::getattr($SELF, RakuAST::ExpressionThunk, '$!next').IMPL-THUNK-CODE-QAST($context, $block[0], $expression);
            my $value := nqp::getattr($SELF, RakuAST::ExpressionThunk, '$!next').IMPL-THUNK-VALUE-QAST($context);
            $block.push($value) if $value;
        }

        # Otherwise, we evaluate to the expression.
        else {
            $block.push($SELF.IMPL-THUNK-TWEAK-EXPRESSION($context,
                $expression.IMPL-EXPR-QAST($context)));
        }

        $block
    
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-THUNK-VALUE-QAST', [RakuAST::ExpressionThunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-THUNK-VALUE-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 433 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-CLOSURE-QAST($context)
    
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-THUNK-OBJECT-TYPE', [RakuAST::ExpressionThunk, '', 0, 0], anon sub IMPL-THUNK-OBJECT-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 439 src/Raku/ast/code.rakumod
         Code 
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-THUNK-SIGNATURE', [RakuAST::ExpressionThunk, '', 0, 0], anon sub IMPL-THUNK-SIGNATURE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 443 src/Raku/ast/code.rakumod
        
        RakuAST::Signature.new
    
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-THUNK-TWEAK-EXPRESSION', [RakuAST::ExpressionThunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$qast', 0, 0], anon sub IMPL-THUNK-TWEAK-EXPRESSION ($SELF_CONT, $context!, $qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $qast := nqp::decont($qast);
#line 449 src/Raku/ast/code.rakumod
        
        $qast
    
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-THUNK-META-OBJECT-PRODUCED', [RakuAST::ExpressionThunk, '', 0, 0, Mu, '$meta', 0, 0], anon sub IMPL-THUNK-META-OBJECT-PRODUCED ($SELF_CONT, $meta!) {
        my $SELF := nqp::decont($SELF_CONT);
        $meta := nqp::decont($meta);
#line 455 src/Raku/ast/code.rakumod
        
    
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-GET-OR-PRODUCE-SIGNATURE', [RakuAST::ExpressionThunk, '', 0, 0], anon sub IMPL-GET-OR-PRODUCE-SIGNATURE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 458 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::ExpressionThunk, '$!signature') // nqp::bindattr($SELF, RakuAST::ExpressionThunk, '$!signature',
            $SELF.IMPL-THUNK-SIGNATURE)
    
    });
    add-method(RakuAST::ExpressionThunk, 'PRODUCE-META-OBJECT', [RakuAST::ExpressionThunk, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 463 src/Raku/ast/code.rakumod
        
        my $code := nqp::create($SELF.IMPL-THUNK-OBJECT-TYPE);
        my $signature := $SELF.IMPL-GET-OR-PRODUCE-SIGNATURE;
        nqp::bindattr($code, Code, '$!signature', $signature.meta-object);
        nqp::bindattr($signature.meta-object, Signature, '$!code', $code);
        $SELF.IMPL-THUNK-META-OBJECT-PRODUCED($code);
        $code
    
    });
    add-method(RakuAST::ExpressionThunk, 'IMPL-UPDATE-SIGNATURE', [RakuAST::ExpressionThunk, '', 0, 0], anon sub IMPL-UPDATE-SIGNATURE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 472 src/Raku/ast/code.rakumod
        
        return Nil unless $SELF.has-meta-object;

        my $code := $SELF.meta-object;
        nqp::bindattr($SELF, RakuAST::ExpressionThunk, '$!signature', $SELF.IMPL-THUNK-SIGNATURE);
        my $signature := nqp::getattr($SELF, RakuAST::ExpressionThunk, '$!signature');
        nqp::bindattr($code, Code, '$!signature', $signature.meta-object);
        nqp::bindattr($signature.meta-object, Signature, '$!code', $code);
        $SELF.IMPL-THUNK-META-OBJECT-PRODUCED($code);
    
    });
#line 337 src/Raku/ast/code.rakumod
    add-method(RakuAST::ExpressionThunk, 'next', [], anon sub next ($self) { nqp::getattr(nqp::decont($self), RakuAST::ExpressionThunk, '$!next') });
    compose(RakuAST::ExpressionThunk);
    parent(RakuAST::PlaceholderParameterOwner, RakuAST::Node);
    add-attribute(RakuAST::PlaceholderParameterOwner, Mu, '$!attached-placeholder-parameters');
    add-attribute(RakuAST::PlaceholderParameterOwner, Mu, '$!placeholder-map');
    add-attribute(RakuAST::PlaceholderParameterOwner, RakuAST::Signature, '$!placeholder-signature');
    add-method(RakuAST::PlaceholderParameterOwner, 'add-placeholder-parameter', [RakuAST::PlaceholderParameterOwner, '', 0, 0, RakuAST::VarDeclaration::Placeholder, '$placeholder', 0, 0], anon sub add-placeholder-parameter ($SELF_CONT, $placeholder!) {
        my $SELF := nqp::decont($SELF_CONT);
        $placeholder := nqp::decont($placeholder);
#line 498 src/Raku/ast/code.rakumod
        
        unless nqp::islist(nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!attached-placeholder-parameters')) {
            nqp::bindattr($SELF, RakuAST::PlaceholderParameterOwner,
                '$!attached-placeholder-parameters', []);
        }
        my $name := $placeholder.lexical-name;
        if $SELF.IMPL-HAS-PARAMETER($name) {
            # matches an explicitly declared parameter
            $placeholder.IMPL-ALREADY-DECLARED((Bool.WHO)<True>);
        }
        else {
            for nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!attached-placeholder-parameters') {
                if $_.lexical-name eq $name {
                    # same placeholder is used multiple times
                    $placeholder.IMPL-ALREADY-DECLARED((Bool.WHO)<True>);
                    return Nil
                }
            }
            nqp::push(nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!attached-placeholder-parameters'), $placeholder);
        }
        Nil
    
    });
    add-method(RakuAST::PlaceholderParameterOwner, 'clear-placeholder-attachments', [RakuAST::PlaceholderParameterOwner, '', 0, 0], anon sub clear-placeholder-attachments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 521 src/Raku/ast/code.rakumod
        
        if nqp::islist(nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!attached-placeholder-parameters')) {
            for nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!attached-placeholder-parameters') {
                # reset declared state on parameters,
                # will be re-set when they are attached again
                $_.IMPL-ALREADY-DECLARED((Bool.WHO)<False>);
            }
            nqp::bindattr($SELF, RakuAST::PlaceholderParameterOwner,
                '$!attached-placeholder-parameters', nqp::null());
        }
        Nil
    
    });
    add-method(RakuAST::PlaceholderParameterOwner, 'has-placeholder-parameters', [RakuAST::PlaceholderParameterOwner, '', 0, 0], anon sub has-placeholder-parameters ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 534 src/Raku/ast/code.rakumod
        
        my $params := nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!attached-placeholder-parameters');
        nqp::islist($params) && nqp::elems($params) ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::PlaceholderParameterOwner, 'IMPL-HAS-PARAMETER', [RakuAST::PlaceholderParameterOwner, '', 0, 0, Str, '$name', 0, 0], anon sub IMPL-HAS-PARAMETER ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 539 src/Raku/ast/code.rakumod
        
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::PlaceholderParameterOwner, 'IMPL-PLACEHOLDER-MAP', [RakuAST::PlaceholderParameterOwner, '', 0, 0], anon sub IMPL-PLACEHOLDER-MAP ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 543 src/Raku/ast/code.rakumod
        
        unless nqp::ishash(nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!placeholder-map')) {
            my %map;
            if $SELF.has-placeholder-parameters {
                for nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!attached-placeholder-parameters') -> $param {
                    my str $key := $param.lexical-name;
                    (%map{$key} || (%map{$key} := [])).push($param);
                }
            }
            nqp::bindattr($SELF, RakuAST::PlaceholderParameterOwner,
                '$!placeholder-map', %map);
        }
        nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!placeholder-map')
    
    });
    add-method(RakuAST::PlaceholderParameterOwner, 'placeholder-signature', [RakuAST::PlaceholderParameterOwner, '', 0, 0], anon sub placeholder-signature ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 560 src/Raku/ast/code.rakumod
        
        # Return Nil if there isn't one to generate, or the cached one if we have
        # it.
        return Nil unless $SELF.has-placeholder-parameters();
        return nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!placeholder-signature') if nqp::getattr($SELF, RakuAST::PlaceholderParameterOwner, '$!placeholder-signature');

        # Group and sort parameters.
        my @positionals;
        my @nameds;
        my @slurpies;
        for $SELF.IMPL-PLACEHOLDER-MAP() {
            my $placeholder := $_.value[0];
            if nqp::istype($placeholder, RakuAST::VarDeclaration::Placeholder::Positional) {
                my int $insert-at := 0;
                my str $desigil-insert := nqp::substr($placeholder.lexical-name, 1);
                while $insert-at < nqp::elems(@positionals) {
                    my str $desigil-cur := nqp::substr(@positionals[$insert-at].lexical-name, 1);
                    last if $desigil-insert lt $desigil-cur;
                    $insert-at++;
                }
                nqp::splice(@positionals, [$placeholder], $insert-at, 0);
            }
            elsif nqp::istype($placeholder, RakuAST::VarDeclaration::Placeholder::Named) {
                my int $insert-at := 0;
                my str $desigil-insert := nqp::substr($placeholder.lexical-name, 1);
                while $insert-at < nqp::elems(@nameds) {
                    my str $desigil-cur := nqp::substr(@nameds[$insert-at].lexical-name, 1);
                    last if $desigil-insert lt $desigil-cur;
                    $insert-at++;
                }
                nqp::splice(@nameds, [$placeholder], $insert-at, 0);
            }
            else {
                if $placeholder.lexical-name eq '@_' { # @_ before %_
                    @slurpies.unshift($placeholder);
                }
                else {
                    @slurpies.push($placeholder);
                }
            }
        }

        # Add to signature.
        my @parameters;
        for @positionals, @nameds, @slurpies -> @placeholders {
            for @placeholders {
                @parameters.push($_.generate-parameter());
            }
        }
        my $signature := RakuAST::Signature.new(:@parameters);
        nqp::bindattr($SELF, RakuAST::PlaceholderParameterOwner,
            '$!placeholder-signature', $signature);
        $signature
    
    });
    compose(RakuAST::PlaceholderParameterOwner);
    parent(RakuAST::ScopePhaser, Any);
    add-attribute(RakuAST::ScopePhaser, Bool, '$!has-exit-handler');
    add-attribute(RakuAST::ScopePhaser, Bool, '$!is-loop-body');
    add-attribute(RakuAST::ScopePhaser, List, '$!ENTER');
    add-attribute(RakuAST::ScopePhaser, List, '$!LEAVE');
    add-attribute(RakuAST::ScopePhaser, List, '$!KEEP');
    add-attribute(RakuAST::ScopePhaser, List, '$!UNDO');
    add-attribute(RakuAST::ScopePhaser, List, '$!FIRST');
    add-attribute(RakuAST::ScopePhaser, List, '$!NEXT');
    add-attribute(RakuAST::ScopePhaser, List, '$!LAST');
    add-attribute(RakuAST::ScopePhaser, List, '$!PRE');
    add-attribute(RakuAST::ScopePhaser, List, '$!POST');
    add-attribute(RakuAST::ScopePhaser, List, '$!QUIT');
    add-attribute(RakuAST::ScopePhaser, List, '$!CLOSE');
    add-attribute(RakuAST::ScopePhaser, RakuAST::Block, '$!let');
    add-attribute(RakuAST::ScopePhaser, RakuAST::Block, '$!temp');
    add-attribute(RakuAST::ScopePhaser, int, '$!next-enter-phaser-result');
    add-method(RakuAST::ScopePhaser, 'add-phaser', [RakuAST::ScopePhaser, '', 0, 0, Str, '$name', 0, 0, RakuAST::StatementPrefix::Phaser, '$phaser', 0, 0, Any, '$has-exit-handler', 1, 1], anon sub add-phaser ($SELF_CONT, $name!, $phaser!, :$has-exit-handler?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $phaser := nqp::decont($phaser);
        $has-exit-handler := nqp::decont($has-exit-handler);
#line 638 src/Raku/ast/code.rakumod
        
        my $attr := '$!' ~ $name;
        my $list := nqp::getattr($SELF, RakuAST::ScopePhaser, $attr);
        $list := nqp::bindattr($SELF, RakuAST::ScopePhaser, $attr, [])
          unless $list;

        for $list {
            if nqp::eqaddr($_, $phaser) {
                return;
            }
        }
        nqp::push($list, $phaser);
        nqp::bindattr($SELF, RakuAST::ScopePhaser, '$!has-exit-handler', (Bool.WHO)<True>)
          if $has-exit-handler;
    
    });
    add-method(RakuAST::ScopePhaser, 'add-enter-phaser', [RakuAST::ScopePhaser, '', 0, 0, RakuAST::StatementPrefix::Phaser, '$phaser', 0, 0], anon sub add-enter-phaser ($SELF_CONT, $phaser!) {
        my $SELF := nqp::decont($SELF_CONT);
        $phaser := nqp::decont($phaser);
#line 654 src/Raku/ast/code.rakumod
        
        $SELF.add-phaser('ENTER', $phaser);
        my $result-name := '__enter_phaser_result_' ~ nqp::getattr_i($SELF, RakuAST::ScopePhaser, '$!next-enter-phaser-result');
        nqp::bindattr_i($SELF, RakuAST::ScopePhaser, '$!next-enter-phaser-result', nqp::getattr_i($SELF, RakuAST::ScopePhaser, '$!next-enter-phaser-result') + 1);
        $result-name
    
    });
    add-method(RakuAST::ScopePhaser, 'set-has-let', [RakuAST::ScopePhaser, '', 0, 0], anon sub set-has-let ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 661 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::ScopePhaser, '$!let', RakuAST::Block.new(:implicit-topic((Bool.WHO)<False>)));
    
    });
    add-method(RakuAST::ScopePhaser, 'set-has-temp', [RakuAST::ScopePhaser, '', 0, 0], anon sub set-has-temp ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 665 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::ScopePhaser, '$!has-exit-handler', (Bool.WHO)<True>);
        nqp::bindattr($SELF, RakuAST::ScopePhaser, '$!temp', RakuAST::Block.new(:implicit-topic((Bool.WHO)<False>)));
    
    });
    add-method(RakuAST::ScopePhaser, 'set-is-loop-body', [RakuAST::ScopePhaser, '', 0, 0], anon sub set-is-loop-body ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 671 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::ScopePhaser, '$!is-loop-body', (Bool.WHO)<True>);
    
    });
    add-method(RakuAST::ScopePhaser, 'is-loop-body', [RakuAST::ScopePhaser, '', 0, 0], anon sub is-loop-body ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 675 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::ScopePhaser, '$!is-loop-body') // (Bool.WHO)<False>
    
    });
    add-method(RakuAST::ScopePhaser, 'add-list-to-code-object', [RakuAST::ScopePhaser, '', 0, 0, Str, '$attr', 0, 0, Any, '$code-object', 0, 0], anon sub add-list-to-code-object ($SELF_CONT, $attr!, $code-object!) {
        my $SELF := nqp::decont($SELF_CONT);
        $attr := nqp::decont($attr);
        $code-object := nqp::decont($code-object);
#line 679 src/Raku/ast/code.rakumod
        
        my $list := nqp::getattr($SELF, RakuAST::ScopePhaser, $attr);
        if $list {
            my $name := nqp::substr($attr,2);  # $!FOO -> FOO
            for $list {
                $code-object.add_phaser($name, $_.meta-object);
            }
        }
    
    });
    add-method(RakuAST::ScopePhaser, 'add-phasers-to-code-object', [RakuAST::ScopePhaser, '', 0, 0, Any, '$code-object', 0, 0], anon sub add-phasers-to-code-object ($SELF_CONT, $code-object!) {
        my $SELF := nqp::decont($SELF_CONT);
        $code-object := nqp::decont($code-object);
#line 689 src/Raku/ast/code.rakumod
        
        $SELF.add-list-to-code-object('$!ENTER', $code-object);
        $SELF.add-list-to-code-object('$!LEAVE', $code-object);
        $SELF.add-list-to-code-object( '$!KEEP', $code-object);
        $SELF.add-list-to-code-object( '$!UNDO', $code-object);
        $SELF.add-list-to-code-object('$!FIRST', $code-object);
        $SELF.add-list-to-code-object( '$!NEXT', $code-object);
        $SELF.add-list-to-code-object( '$!LAST', $code-object);
        $SELF.add-list-to-code-object( '$!QUIT', $code-object);
        $SELF.add-list-to-code-object(  '$!PRE', $code-object);
        $SELF.add-list-to-code-object( '$!POST', $code-object);
        $SELF.add-list-to-code-object('$!CLOSE', $code-object);

        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!let') {
            $code-object.add_phaser('UNDO', nqp::getattr($SELF, RakuAST::ScopePhaser, '$!let').meta-object);
        }
        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!temp') {
            $code-object.add_phaser('LEAVE', nqp::getattr($SELF, RakuAST::ScopePhaser, '$!temp').meta-object);
        }

        $code-object.fatalize if $*LANG && $*LANG.pragma('fatal');
    
    });
    add-method(RakuAST::ScopePhaser, 'add-phasers-handling-code', [RakuAST::ScopePhaser, '', 0, 0, RakuAST::IMPL::Context, '$context', 0, 0, Mu, '$qast', 0, 0], anon sub add-phasers-handling-code ($SELF_CONT, $context!, $qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $qast := nqp::decont($qast);
#line 712 src/Raku/ast/code.rakumod
        
        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!has-exit-handler') {
            $qast.has_exit_handler(1);
        }

        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!PRE') {
            my $pre-setup := QAST::Stmts.new;
            for nqp::getattr($SELF, RakuAST::ScopePhaser, '$!PRE') {
                $pre-setup.push($_.IMPL-CALLISH-QAST($context));
            }

            $qast[0].push(QAST::Op.new( :op('p6setpre') ));
            $qast[0].push($pre-setup);
            $qast[0].push(QAST::Op.new( :op('p6clearpre') ));
        }

        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!FIRST') {
            my $first-setup := QAST::Stmts.new;
            for nqp::getattr($SELF, RakuAST::ScopePhaser, '$!FIRST') {
                $first-setup.push($_.IMPL-CALLISH-QAST($context));
            }
            $qast[0].push: $first-setup;
        }

        my $phasers := nqp::istype($SELF, RakuAST::Code)
            ?? nqp::getattr($SELF.meta-object, Block, '$!phasers')
            !! NQPMu;
        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!ENTER') || nqp::ishash($phasers) && nqp::existskey($phasers, 'ENTER') {
            my $enter-setup := QAST::Stmts.new;
            my %seen;
            if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!ENTER') {
                for nqp::getattr($SELF, RakuAST::ScopePhaser, '$!ENTER') {
                    my $result-name := $_.IMPL-RESULT-NAME;
                    $enter-setup.push(
                      QAST::Op.new(
                        :op<bind>,
                        QAST::Var.new( :name($result-name), :scope<local>, :decl<var> ),
                        $_.IMPL-CALLISH-QAST($context)
                      )
                    );
                    %seen{nqp::objectid($_.meta-object)} := 1;
                }
            }
            my $enter-phasers := nqp::atkey($phasers, 'ENTER');
            if nqp::isconcrete($enter-phasers) {
                for $enter-phasers {
                    unless %seen{nqp::objectid($_)} {
                        $context.ensure-sc($_);
                        $enter-setup.push(QAST::Op.new(:op<call>, QAST::WVal.new(:value($_))));
                    }
                }
            }
            $qast[0].push($enter-setup);
        }

        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!let') {
            $SELF.IMPL-ADD-PHASER-QAST($context, nqp::getattr($SELF, RakuAST::ScopePhaser, '$!let'), '!LET-RESTORE', $qast);
        }
        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!temp') {
            $SELF.IMPL-ADD-PHASER-QAST($context, nqp::getattr($SELF, RakuAST::ScopePhaser, '$!temp'), '!TEMP-RESTORE', $qast);
        }

        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!LAST') || nqp::getattr($SELF, RakuAST::ScopePhaser, '$!NEXT') || nqp::getattr($SELF, RakuAST::ScopePhaser, '$!QUIT') || nqp::getattr($SELF, RakuAST::ScopePhaser, '$!CLOSE') {
            $qast[0].push(
              QAST::Op.new(
                :op('callmethod'),
                :name('!capture_phasers'),
                QAST::Op.new(
                  :op('getcodeobj'),
                  QAST::Op.new(:op('curcode'))
                )
              )
            );
        }

        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!LEAVE') || nqp::getattr($SELF, RakuAST::ScopePhaser, '$!KEEP') || nqp::getattr($SELF, RakuAST::ScopePhaser, '$!UNDO') || nqp::getattr($SELF, RakuAST::ScopePhaser, '$!POST') {
            $qast.annotate('WANTMEPLEASE',1);
        }
    
    });
    add-method(RakuAST::ScopePhaser, 'IMPL-STUB-PHASERS', [RakuAST::ScopePhaser, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::Context, '$context', 0, 0], anon sub IMPL-STUB-PHASERS ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 792 src/Raku/ast/code.rakumod
        
        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!let') {
            nqp::getattr($SELF, RakuAST::ScopePhaser, '$!let').IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);
            nqp::getattr($SELF, RakuAST::ScopePhaser, '$!let').IMPL-STUB-CODE($resolver, $context);
        }
        if nqp::getattr($SELF, RakuAST::ScopePhaser, '$!temp') {
            nqp::getattr($SELF, RakuAST::ScopePhaser, '$!temp').IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);
            nqp::getattr($SELF, RakuAST::ScopePhaser, '$!temp').IMPL-STUB-CODE($resolver, $context);
        }
    
    });
    add-method(RakuAST::ScopePhaser, 'IMPL-ADD-PHASER-QAST', [RakuAST::ScopePhaser, '', 0, 0, RakuAST::IMPL::Context, '$context', 0, 0, RakuAST::Block, '$phaser', 0, 0, Str, '$value_stash', 0, 0, QAST::Block, '$block', 0, 0], anon sub IMPL-ADD-PHASER-QAST ($SELF_CONT, $context!, $phaser!, $value_stash!, $block!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $phaser := nqp::decont($phaser);
        $value_stash := nqp::decont($value_stash);
        $block := nqp::decont($block);
#line 808 src/Raku/ast/code.rakumod
        
        $block[0].push(QAST::Op.new(
            :op('bind'),
            QAST::Var.new( :name($value_stash), :scope('lexical'), :decl('var') ),
            QAST::Op.new(
              :op('create'),
              QAST::WVal.new( :value(IterationBuffer)))));
        $block.symbol($value_stash, :scope('lexical'));

        my $phaser-block := $phaser.IMPL-QAST-BLOCK($context, :blocktype('declaration_static'));
        $phaser-block.push(QAST::Op.new(
            :op('while'),
            QAST::Op.new(
                :op('elems'),
                QAST::Var.new( :name($value_stash), :scope('lexical') )),
            QAST::Op.new(
                :op('if'),
                QAST::Op.new(
                    :op('iscont'),
                    QAST::Op.new(
                        :op('atpos'),
                        QAST::Var.new( :name($value_stash), :scope('lexical') ),
                        QAST::IVal.new( :value(0) ))),
                QAST::Op.new( # p6store is for Scalar
                    :op('p6store'),
                    QAST::Op.new(
                        :op('shift'),
                        QAST::Var.new( :name($value_stash), :scope('lexical') )),
                    QAST::Op.new(
                        :op('shift'),
                        QAST::Var.new( :name($value_stash), :scope('lexical') ))),
                QAST::Op.new( # Otherwise we restore by means of the container itself
                    :op('callmethod'),
                    :name('TEMP-LET-RESTORE'),
                    QAST::Op.new(
                        :op('shift'),
                        QAST::Var.new( :name($value_stash), :scope('lexical') )),
                    QAST::Op.new(
                        :op('shift'),
                        QAST::Var.new( :name($value_stash), :scope('lexical') ))))));

        # Add as phaser.
        $block[0].push($phaser-block);
    
    });
    add-method(RakuAST::ScopePhaser, 'clear-phaser-attachments', [RakuAST::ScopePhaser, '', 0, 0], anon sub clear-phaser-attachments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 853 src/Raku/ast/code.rakumod
        
        my @attrs := ['$!LEAVE', '$!FIRST', '$!NEXT', '$!LAST'];
        for @attrs {
            my $attr := nqp::getattr($SELF, RakuAST::ScopePhaser, $_);
            nqp::setelems($attr, 0) if $attr;
        }
    
    });
    add-method(RakuAST::ScopePhaser, 'has-phaser', [RakuAST::ScopePhaser, '', 0, 0, str, '$phaser-name', 0, 0], anon sub has-phaser ($SELF_CONT, $phaser-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $phaser-name := nqp::decont($phaser-name);
#line 861 src/Raku/ast/code.rakumod
        
        # TOOD: Also check '$!phasers' hash on the meta-object
        nqp::elems(nqp::getattr($SELF, RakuAST::ScopePhaser, '$!' ~ $phaser-name) // []) > 0
    
    });
    compose(RakuAST::ScopePhaser);
    parent(RakuAST::Block, RakuAST::LexicalScope);
    parent(RakuAST::Block, RakuAST::Term);
    parent(RakuAST::Block, RakuAST::Code);
    parent(RakuAST::Block, RakuAST::Meta);
    parent(RakuAST::Block, RakuAST::BlockStatementSensitive);
    parent(RakuAST::Block, RakuAST::SinkPropagator);
    parent(RakuAST::Block, RakuAST::Blorst);
    parent(RakuAST::Block, RakuAST::ImplicitDeclarations);
    parent(RakuAST::Block, RakuAST::ImplicitLookups);
    parent(RakuAST::Block, RakuAST::AttachTarget);
    parent(RakuAST::Block, RakuAST::PlaceholderParameterOwner);
    parent(RakuAST::Block, RakuAST::BeginTime);
    parent(RakuAST::Block, RakuAST::ScopePhaser);
    parent(RakuAST::Block, RakuAST::Doc::DeclaratorTarget);
    add-attribute(RakuAST::Block, RakuAST::Blockoid, '$!body');
    add-attribute(RakuAST::Block, int, '$!implicit-topic-mode');
    add-attribute(RakuAST::Block, int, '$!fresh-match');
    add-attribute(RakuAST::Block, int, '$!fresh-exception');
    add-method(RakuAST::Block, 'new', [RakuAST::Block, '', 0, 0, RakuAST::Blockoid, '$body', 1, 1, Bool, '$implicit-topic', 1, 1, Bool, '$required-topic', 1, 1, Bool, '$exception', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$body?, :$implicit-topic?, :$required-topic?, :$exception?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $body := nqp::decont($body);
        $implicit-topic := nqp::decont($implicit-topic);
        $required-topic := nqp::decont($required-topic);
        $exception := nqp::decont($exception);
        $WHY := nqp::decont($WHY);
#line 905 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Block, '$!body', $body // RakuAST::Blockoid.new);
        $obj.set-implicit-topic($implicit-topic // 1, :required($required-topic), :$exception);
        $obj.set-WHY($WHY);
        $obj
    
    });
    add-method(RakuAST::Block, 'replace-body', [RakuAST::Block, '', 0, 0, RakuAST::Blockoid, '$new-body', 0, 0], anon sub replace-body ($SELF_CONT, $new-body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-body := nqp::decont($new-body);
#line 913 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Block, '$!body', $new-body);
        Nil
    
    });
    add-method(RakuAST::Block, 'set-implicit-topic', [RakuAST::Block, '', 0, 0, Bool, '$implicit', 0, 0, Bool, '$required', 1, 1, Bool, '$exception', 1, 1, Bool, '$local', 1, 1], anon sub set-implicit-topic ($SELF_CONT, $implicit!, :$required?, :$exception?, :$local?) {
        my $SELF := nqp::decont($SELF_CONT);
        $implicit := nqp::decont($implicit);
        $required := nqp::decont($required);
        $exception := nqp::decont($exception);
        $local := nqp::decont($local);
#line 918 src/Raku/ast/code.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode', $implicit
            ?? ($exception ?? 3 !!
                $required  ?? 2 !!
                              1)
            !! $local ?? -1 !! 0);
        Nil
    
    });
    add-method(RakuAST::Block, 'implicit-topic', [RakuAST::Block, '', 0, 0], anon sub implicit-topic ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 927 src/Raku/ast/code.rakumod
         nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') == 1 ?? Bool !! nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') > 1 
    });
    add-method(RakuAST::Block, 'required-topic', [RakuAST::Block, '', 0, 0], anon sub required-topic ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 928 src/Raku/ast/code.rakumod
         nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') > 1 || Bool 
    });
    add-method(RakuAST::Block, 'exception', [RakuAST::Block, '', 0, 0], anon sub exception ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 929 src/Raku/ast/code.rakumod
         nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') > 2 || Bool 
    });
    add-method(RakuAST::Block, 'set-fresh-variables', [RakuAST::Block, '', 0, 0, Bool, '$match', 1, 1, Bool, '$exception', 1, 1], anon sub set-fresh-variables ($SELF_CONT, :$match?, :$exception?) {
        my $SELF := nqp::decont($SELF_CONT);
        $match := nqp::decont($match);
        $exception := nqp::decont($exception);
#line 931 src/Raku/ast/code.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::Block, '$!fresh-match', $match ?? 1 !! 0);
        nqp::bindattr_i($SELF, RakuAST::Block, '$!fresh-exception', $exception ?? 1 !! 0);
    
    });
    add-method(RakuAST::Block, 'attach-target-names', [RakuAST::Block, '', 0, 0], anon sub attach-target-names ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 936 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST(['block'])
    
    });
    add-method(RakuAST::Block, 'clear-attachments', [RakuAST::Block, '', 0, 0], anon sub clear-attachments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 940 src/Raku/ast/code.rakumod
        
        $SELF.clear-handler-attachments();
        $SELF.clear-placeholder-attachments();
        $SELF.clear-phaser-attachments();
        Nil
    
    });
    add-method(RakuAST::Block, 'propagate-sink', [RakuAST::Block, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 947 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::Block, '$!body').apply-sink($is-sunk);
    
    });
    add-method(RakuAST::Block, 'PRODUCE-IMPLICIT-DECLARATIONS', [RakuAST::Block, '', 0, 0], anon sub PRODUCE-IMPLICIT-DECLARATIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 951 src/Raku/ast/code.rakumod
        
        my @implicit;
        unless $SELF.IMPL-HAS-PARAMETER('$_') {
            if nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') == 1 {
                @implicit[0] := RakuAST::VarDeclaration::Implicit::BlockTopic.new:
                    parameter => $SELF.signature ?? (Bool.WHO)<False> !! (Bool.WHO)<True>;
            }
            elsif nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') == -1 {
                @implicit[0] := RakuAST::VarDeclaration::Implicit::BlockTopic.new:
                    parameter => (Bool.WHO)<False>;
            }
            elsif nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') == 2 {
                @implicit[0] := RakuAST::VarDeclaration::Implicit::BlockTopic.new:
                    :required,
                    parameter => $SELF.signature ?? (Bool.WHO)<False> !! (Bool.WHO)<True>;
            }
            elsif nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') == 3 {
                @implicit[0] := RakuAST::VarDeclaration::Implicit::BlockTopic.new(:required,
                    :exception);
            }
        }
        if nqp::getattr_i($SELF, RakuAST::Block, '$!fresh-match') {
            nqp::push(@implicit, RakuAST::VarDeclaration::Implicit::Special.new(:name('$/')));
        }
        if nqp::getattr_i($SELF, RakuAST::Block, '$!fresh-exception') {
            nqp::push(@implicit, RakuAST::VarDeclaration::Implicit::Special.new(:name('$!')));
        }
        $SELF.IMPL-WRAP-LIST(@implicit)
    
    });
    add-method(RakuAST::Block, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Block, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 981 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Code'))
        ])
    
    });
    add-method(RakuAST::Block, 'is-begin-performed-before-children', [RakuAST::Block, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 987 src/Raku/ast/code.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Block, 'PERFORM-BEGIN', [RakuAST::Block, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 989 src/Raku/ast/code.rakumod
        
        # Make sure that our placeholder signature has resolutions performed,
        # and that we don't produce a topic parameter.
        my $placeholder-signature := $SELF.placeholder-signature;
        if $placeholder-signature {
            $placeholder-signature.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
            if nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') > 0 {
                my $topic := $SELF.IMPL-UNWRAP-LIST($SELF.get-implicit-declarations)[0];
                $topic.set-parameter((Bool.WHO)<False>);
            }
        }

        $SELF.IMPL-STUB-PHASERS($resolver, $context);

        $SELF.IMPL-STUB-CODE($resolver, $context);

        Nil
    
    });
    add-method(RakuAST::Block, 'PRODUCE-META-OBJECT', [RakuAST::Block, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1008 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-PRODUCE-META-OBJECT
    
    });
    add-method(RakuAST::Block, 'IMPL-PRODUCE-META-OBJECT', [RakuAST::Block, '', 0, 0], anon sub IMPL-PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1012 src/Raku/ast/code.rakumod
        
        # Create block object and install signature. If it doesn't have one, then
        # we can create it based upon the implicit topic it may or may not have.
        my $block := nqp::create(Block);
        my $signature := $SELF.signature || $SELF.placeholder-signature;
        if $signature {
            nqp::bindattr($block, Code, '$!signature', $signature.meta-object);
            nqp::bindattr($signature.meta-object, Signature, '$!code', $block);
        }
        elsif nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') > 0 {
            my constant REQUIRED-TOPIC-SIG := -> {
                my $param := nqp::create(Parameter);
                nqp::bindattr_s($param, Parameter, '$!variable_name', '$_');
                my $sig := nqp::create(Signature);
                nqp::bindattr($sig, Signature, '@!params', [$param]);
                nqp::bindattr_i($sig, Signature, '$!arity', 1);
                nqp::bindattr($sig, Signature, '$!count', nqp::box_i(1, Int));
                $sig
            }();
            my constant OPTIONAL-TOPIC-SIG := -> {
                my $param := nqp::create(Parameter);
                nqp::bindattr_s($param, Parameter, '$!variable_name', '$_');
                nqp::bindattr_i($param, Parameter, '$!flags', 2048 + 16384); # Optional + default from outer
                my $sig := nqp::create(Signature);
                nqp::bindattr($sig, Signature, '@!params', [$param]);
                nqp::bindattr_i($sig, Signature, '$!arity', 0);
                nqp::bindattr($sig, Signature, '$!count', nqp::box_i(1, Int));
                $sig
            }();
            nqp::bindattr($block, Code, '$!signature', nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') == 1
                ?? OPTIONAL-TOPIC-SIG
                !! REQUIRED-TOPIC-SIG);
        }
        $SELF.add-phasers-to-code-object($block);
        $block
    
    });
    add-method(RakuAST::Block, 'IMPL-QAST-FORM-BLOCK', [RakuAST::Block, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-FORM-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 1050 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-QAST-FORM-BLOCK-FOR-BODY($context, :$blocktype, :$expression,
            $SELF.IMPL-APPEND-SIGNATURE-RETURN($context,
            nqp::getattr($SELF, RakuAST::Block, '$!body').IMPL-TO-QAST($context)));
    
    });
    add-method(RakuAST::Block, 'IMPL-QAST-FORM-BLOCK-FOR-BODY', [RakuAST::Block, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$body-qast', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-FORM-BLOCK-FOR-BODY ($SELF_CONT, $context!, $body-qast!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $body-qast := nqp::decont($body-qast);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 1056 src/Raku/ast/code.rakumod
        
        # Form block with declarations.
        my $block := QAST::Block.new(
            :$blocktype,
            $SELF.IMPL-QAST-DECLS($context)
        );

        # Compile body and, if needed, a signature, and set up arity and any
        # exception rethrow logic.
        my $signature := $SELF.signature || $SELF.placeholder-signature;
        if $signature {
            $block.push($signature.IMPL-QAST-BINDINGS($context, :needs-full-binder($SELF.custom-args)));
            $block.custom_args(1) if $SELF.custom-args;
            $block.arity($signature.arity);
            $block.annotate('count', $signature.count);
        }
        elsif nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') == 1 {
            $block.arity(0);
            $block.annotate('count', 1);
        }
        elsif nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') >= 2 {
            $block.arity(1);
            $block.annotate('count', 1);
        }

        my $is-handler := nqp::getattr_i($SELF, RakuAST::Block, '$!implicit-topic-mode') == 3 ?? (Bool.WHO)<True> !! (Bool.WHO)<False>;
        $block.push($SELF.IMPL-WRAP-SCOPE-HANDLER-QAST($context, $body-qast, :$is-handler));

        $SELF.add-phasers-handling-code($context, $block);

        $block
    
    });
    add-method(RakuAST::Block, 'IMPL-QAST-DECL-CODE', [RakuAST::Block, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL-CODE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1089 src/Raku/ast/code.rakumod
        
        # Form the block itself and link it with the meta-object.
        $SELF.IMPL-QAST-BLOCK($context, :blocktype('declaration_static'));
    
    });
    add-method(RakuAST::Block, 'IMPL-EXPR-QAST', [RakuAST::Block, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '$immediate', 1, 1], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!, :$immediate?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $immediate := nqp::decont($immediate);
#line 1094 src/Raku/ast/code.rakumod
        
        if $immediate {
            # For now, assume we never need a code object for such a block. The
            # closure clone is done for us by the QAST compiler.
            my $block := $SELF.IMPL-QAST-FORM-BLOCK($context, :blocktype<immediate>);
            $SELF.IMPL-LINK-META-OBJECT($context, $block);
            $block
        }
        else {
            # Not immediate, so already produced as a declaration above; just
            # closure clone it. Only invoke if it's a bare block.
            # Ensure the block is linked when our outer block gets cloned before
            # our IMPL-QAST-DECL-CODE is called.
            $SELF.IMPL-QAST-BLOCK($context, :blocktype('declaration_static'));
            my $ast := $SELF.IMPL-CLOSURE-QAST($context);
            $SELF.bare-block
                ?? QAST::Op.new( :op('call'), $ast )
                !! $ast
        }
    
    });
    add-method(RakuAST::Block, 'bare-block', [RakuAST::Block, '', 0, 0], anon sub bare-block ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1115 src/Raku/ast/code.rakumod
        
        $SELF.is-block-statement
    
    });
    add-method(RakuAST::Block, 'block-or-hash', [RakuAST::Block, '', 0, 0, int, '$object-hash', 1, 1], anon sub block-or-hash ($SELF_CONT, :$object-hash?) {
        my $SELF := nqp::decont($SELF_CONT);
        $object-hash := nqp::decont($object-hash);
#line 1128 src/Raku/ast/code.rakumod
        
        my @statements := $SELF.body.statement-list.code-statements;
        my int $num-statements := nqp::elems(@statements);

        # Empty block is always an empty hash composer
        if $num-statements == 0 {
            return RakuAST::Circumfix::HashComposer.new(:$object-hash)
        }

        # Multiple statements is always a block
        elsif $num-statements > 1 {
            return $SELF
        }

        # Not a statement always means block
        my $statement := @statements[0];
        unless nqp::istype($statement, RakuAST::Statement::Expression) {
            return $SELF;
        }

        # If it's a comma list, then obtain the first element. Otherwise,
        # we have the thing to test already.
        my $expression := $statement.expression;
        my int $is-comma := nqp::istype($expression, RakuAST::ApplyListInfix) &&
            nqp::istype($expression.infix, RakuAST::Infix) &&
            $expression.infix.operator eq ',';
        my $test := $is-comma
            ?? $SELF.IMPL-UNWRAP-LIST($expression.operands)[0]
            !! $expression;

        # A fatarrow is ok
        if nqp::istype($test,RakuAST::FatArrow) {
        }
        # A colonpair is ok
        elsif nqp::istype($test,RakuAST::ColonPair) {
        }
        # A hash sigil'd variable is ok
        elsif nqp::istype($test,RakuAST::Var) && $test.sigil eq '%' {
        }
        # Some kind of infix may be ok
        elsif nqp::istype($test,RakuAST::ApplyInfix) {

            # Get the proper infix to check
            my $infix := $test.infix;
            if nqp::istype($infix,RakuAST::Infix) {
            }
            elsif nqp::istype($infix,RakuAST::MetaInfix::Reverse) {
                $infix := $infix.infix;
            }

            # It's a block as no valid infix found
            else {
                return $SELF
            }

            # It's a block if not a fat arrow
            return $SELF unless $infix.operator eq '=>';
        }

        # It's a block as nothing recognizable
        else {
            return $SELF;
        }

        # Looks like a hash, but check for declarations or $_ usage.
        my int $seen-decl-or-topic;
        $expression.visit: -> $node {
            # Don't walk into other scopes
            if nqp::istype($node, RakuAST::LexicalScope) {
                0
            }
            # If it's a declaration, it blocks; walk no futher
            elsif nqp::istype($node, RakuAST::Declaration) {
                $seen-decl-or-topic := 1;
                0
            }
            # If it's a usage of the topic, it also blocks; walk no further
            elsif nqp::istype($node, RakuAST::Var::Lexical) && $node.name eq '$_' ||
                nqp::istype($node, RakuAST::Term::TopicCall) {
                $seen-decl-or-topic := 1;
                0
            }
            # Otherwise, keep looking
            else {
                1
            }
        }
        $seen-decl-or-topic
            ?? $SELF
            !! RakuAST::Circumfix::HashComposer.new($expression, :$object-hash)
    
    });
    add-method(RakuAST::Block, 'visit-children', [RakuAST::Block, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1220 src/Raku/ast/code.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Block, '$!body'));
        $visitor($SELF.WHY) if $SELF.WHY;
    
    });
    add-method(RakuAST::Block, 'IMPL-CAN-INTERPRET', [RakuAST::Block, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1225 src/Raku/ast/code.rakumod
        
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Block, 'IMPL-INTERPRET', [RakuAST::Block, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 1229 src/Raku/ast/code.rakumod
        
        $SELF.meta-object
    
    });
    add-method(RakuAST::Block, 'as-block', [RakuAST::Block, '', 0, 0], anon sub as-block ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1233 src/Raku/ast/code.rakumod
        
        $SELF
    
    });
#line 884 src/Raku/ast/code.rakumod
    add-method(RakuAST::Block, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Block, '$!body') });
    compose(RakuAST::Block);
    parent(RakuAST::PointyBlock, RakuAST::Block);
    parent(RakuAST::PointyBlock, RakuAST::ImplicitLookups);
    parent(RakuAST::PointyBlock, RakuAST::Doc::DeclaratorTarget);
    add-attribute(RakuAST::PointyBlock, RakuAST::Signature, '$!signature');
    add-method(RakuAST::PointyBlock, 'new', [RakuAST::PointyBlock, '', 0, 0, RakuAST::Signature, '$signature', 1, 1, RakuAST::Blockoid, '$body', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$signature?, :$body?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $signature := nqp::decont($signature);
        $body := nqp::decont($body);
        $WHY := nqp::decont($WHY);
#line 1249 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::PointyBlock, '$!signature',
          $signature // RakuAST::Signature.new);
        nqp::bindattr($obj, RakuAST::Block, '$!body',
          $body // RakuAST::Blockoid.new);
        $obj.set-WHY($WHY);
        $obj
    
    });
    add-method(RakuAST::PointyBlock, 'replace-signature', [RakuAST::PointyBlock, '', 0, 0, RakuAST::Signature, '$new-signature', 0, 0], anon sub replace-signature ($SELF_CONT, $new-signature!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-signature := nqp::decont($new-signature);
#line 1259 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::PointyBlock, '$!signature', $new-signature);
        Nil
    
    });
    add-method(RakuAST::PointyBlock, 'bare-block', [RakuAST::PointyBlock, '', 0, 0], anon sub bare-block ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1264 src/Raku/ast/code.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::PointyBlock, 'propagate-sink', [RakuAST::PointyBlock, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 1266 src/Raku/ast/code.rakumod
        
        $SELF.body.apply-sink($is-sunk);
        nqp::getattr($SELF, RakuAST::PointyBlock, '$!signature').apply-sink((Bool.WHO)<True>);
    
    });
    add-method(RakuAST::PointyBlock, 'visit-children', [RakuAST::PointyBlock, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1271 src/Raku/ast/code.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::PointyBlock, '$!signature'));
        $visitor($SELF.body);
        $visitor($SELF.WHY) if $SELF.WHY;
    
    });
    add-method(RakuAST::PointyBlock, 'IMPL-HAS-PARAMETER', [RakuAST::PointyBlock, '', 0, 0, Str, '$name', 0, 0], anon sub IMPL-HAS-PARAMETER ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 1277 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::PointyBlock, '$!signature').IMPL-HAS-PARAMETER($name)
    
    });
    add-method(RakuAST::PointyBlock, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::PointyBlock, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1281 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Callable'))
        ])
    
    });
    add-method(RakuAST::PointyBlock, 'PRODUCE-META-OBJECT', [RakuAST::PointyBlock, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1287 src/Raku/ast/code.rakumod
        
        my $block := $SELF.IMPL-PRODUCE-META-OBJECT();
        my $signature := $SELF.signature || $SELF.placeholder-signature;

        if $signature.meta-object.has_returns {
            my $Callable :=
              $SELF.get-implicit-lookups.AT-POS(0).compile-time-value;
            $block.HOW.mixin(
              $block,
              $Callable.HOW.parameterize(
                $Callable,
                $signature.meta-object.returns
              )
            );
        }
        $block
    
    });
    add-method(RakuAST::PointyBlock, 'PERFORM-BEGIN', [RakuAST::PointyBlock, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1305 src/Raku/ast/code.rakumod
        
        # Cannot rely on IMPL-CHECK getting run before this, as that would
        # also run our children's BEGIN handlers which would screw up our
        # block-or-hash detection
        $SELF.resolve-implicit-lookups-with($resolver);

        # Make sure that our placeholder signature has resolutions performed,
        # and that we don't produce a topic parameter.
        if nqp::getattr($SELF, RakuAST::PointyBlock, '$!signature') {
            nqp::getattr($SELF, RakuAST::PointyBlock, '$!signature').IMPL-ENSURE-IMPLICITS;
            nqp::getattr($SELF, RakuAST::PointyBlock, '$!signature').IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
        }
        my $placeholder-signature := $SELF.placeholder-signature;
        if $placeholder-signature {
            $placeholder-signature.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
            if nqp::getattr($SELF, RakuAST::Block, '$!implicit-topic-mode') {
                my $topic := $SELF.IMPL-UNWRAP-LIST($SELF.get-implicit-declarations)[0];
                $topic.set-parameter((Bool.WHO)<False>);
            }
        }

        $SELF.IMPL-STUB-PHASERS($resolver, $context);

        $SELF.IMPL-STUB-CODE($resolver, $context);

        Nil
    
    });
    add-method(RakuAST::PointyBlock, 'IMPL-WRAP-RETURN-HANDLER', [RakuAST::PointyBlock, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$body', 0, 0], anon sub IMPL-WRAP-RETURN-HANDLER ($SELF_CONT, $context!, $body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $body := nqp::decont($body);
#line 1333 src/Raku/ast/code.rakumod
        
        my $result := $body;
        my $block := $SELF.compile-time-value;
        my $signature := nqp::getattr($block, Code, '$!signature');
        $context.ensure-sc($block);

        # Add return type check if needed.
        # TODO also infer body type
        my $returns := nqp::ifnull($signature.returns, Mu);
        unless $returns =:= Mu || $returns =:= Nil || nqp::isconcrete($returns) {
            $context.ensure-sc($returns);
            $result := QAST::Op.new(
                :op('p6typecheckrv'),
                $result,
                QAST::WVal.new( :value($block) ),
                QAST::WVal.new( :value(Nil) )
            );
        }

        $result
    
    });
    add-method(RakuAST::PointyBlock, 'IMPL-QAST-FORM-BLOCK', [RakuAST::PointyBlock, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-FORM-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 1356 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-QAST-FORM-BLOCK-FOR-BODY($context, :$blocktype, :$expression,
            $SELF.IMPL-WRAP-RETURN-HANDLER($context,
                $SELF.IMPL-APPEND-SIGNATURE-RETURN($context, $SELF.body.IMPL-TO-QAST($context))))
    
    });
#line 1244 src/Raku/ast/code.rakumod
    add-method(RakuAST::PointyBlock, 'signature', [], anon sub signature ($self) { nqp::getattr(nqp::decont($self), RakuAST::PointyBlock, '$!signature') });
    compose(RakuAST::PointyBlock);
    parent(RakuAST::Routine, RakuAST::LexicalScope);
    parent(RakuAST::Routine, RakuAST::Term);
    parent(RakuAST::Routine, RakuAST::Code);
    parent(RakuAST::Routine, RakuAST::StubbyMeta);
    parent(RakuAST::Routine, RakuAST::Declaration);
    parent(RakuAST::Routine, RakuAST::Attaching);
    parent(RakuAST::Routine, RakuAST::ImplicitDeclarations);
    parent(RakuAST::Routine, RakuAST::AttachTarget);
    parent(RakuAST::Routine, RakuAST::PlaceholderParameterOwner);
    parent(RakuAST::Routine, RakuAST::ImplicitLookups);
    parent(RakuAST::Routine, RakuAST::BeginTime);
    parent(RakuAST::Routine, RakuAST::TraitTarget);
    parent(RakuAST::Routine, RakuAST::ScopePhaser);
    parent(RakuAST::Routine, RakuAST::Doc::DeclaratorTarget);
    add-attribute(RakuAST::Routine, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Routine, RakuAST::Signature, '$!signature');
    add-attribute(RakuAST::Routine, str, '$!multiness');
    add-attribute(RakuAST::Routine, RakuAST::Package, '$!package');
    add-attribute(RakuAST::Routine, Bool, '$!need-routine-variable');
    add-method(RakuAST::Routine, 'multiness', [RakuAST::Routine, '', 0, 0], anon sub multiness ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1386 src/Raku/ast/code.rakumod
        
        my $multiness := nqp::getattr_s($SELF, RakuAST::Routine, '$!multiness');
        nqp::isnull_s($multiness) ?? '' !! $multiness
    
    });
    add-method(RakuAST::Routine, 'replace-name', [RakuAST::Routine, '', 0, 0, RakuAST::Name, '$new-name', 0, 0], anon sub replace-name ($SELF_CONT, $new-name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-name := nqp::decont($new-name);
#line 1391 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Routine, '$!name', $new-name);
        Nil
    
    });
    add-method(RakuAST::Routine, 'replace-signature', [RakuAST::Routine, '', 0, 0, RakuAST::Signature, '$new-signature', 0, 0], anon sub replace-signature ($SELF_CONT, $new-signature!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-signature := nqp::decont($new-signature);
#line 1396 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Routine, '$!signature', $new-signature);
        Nil
    
    });
    add-method(RakuAST::Routine, 'attach-target-names', [RakuAST::Routine, '', 0, 0], anon sub attach-target-names ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1401 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST(['routine', 'block'])
    
    });
    add-method(RakuAST::Routine, 'attach', [RakuAST::Routine, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1405 src/Raku/ast/code.rakumod
        
        my $package := $resolver.find-attach-target('package');
        nqp::bindattr($SELF, RakuAST::Routine, '$!package', $package // $resolver.global-package);
        nqp::bindattr($SELF, RakuAST::Code, '$!resolver', $resolver.clone);
    
    });
    add-method(RakuAST::Routine, 'set-need-routine-variable', [RakuAST::Routine, '', 0, 0], anon sub set-need-routine-variable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1411 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Routine, '$!need-routine-variable', (Bool.WHO)<True>);
    
    });
    add-method(RakuAST::Routine, 'clear-attachments', [RakuAST::Routine, '', 0, 0], anon sub clear-attachments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1415 src/Raku/ast/code.rakumod
        
        $SELF.clear-handler-attachments();
        $SELF.clear-placeholder-attachments();
        $SELF.clear-phaser-attachments();
        Nil
    
    });
    add-method(RakuAST::Routine, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Routine, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1422 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Callable'))
        ])
    
    });
    add-method(RakuAST::Routine, 'PRODUCE-STUBBED-META-OBJECT', [RakuAST::Routine, '', 0, 0], anon sub PRODUCE-STUBBED-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1428 src/Raku/ast/code.rakumod
        
        nqp::create($SELF.IMPL-META-OBJECT-TYPE)
    
    });
    add-method(RakuAST::Routine, 'PRODUCE-META-OBJECT', [RakuAST::Routine, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1432 src/Raku/ast/code.rakumod
        
        my $routine := $SELF.stubbed-meta-object;
        my $signature := $SELF.placeholder-signature || $SELF.signature;
        nqp::bindattr($routine, Code, '$!signature', $signature.meta-object);
        nqp::bindattr($signature.meta-object, Signature, '$!code', $routine);

        if $signature.meta-object.has_returns {
            my $Callable :=
              $SELF.get-implicit-lookups.AT-POS(0).compile-time-value;
            $routine.HOW.mixin(
              $routine,
              $Callable.HOW.parameterize(
                $Callable,
                $signature.meta-object.returns
              )
            );
        }

        if nqp::istype($SELF.body, RakuAST::OnlyStar) {
            $routine.set_onlystar;
        }

        nqp::bindattr($routine,Routine,'$!package',nqp::getattr($SELF, RakuAST::Routine, '$!package').compile-time-value)
          if nqp::getattr($SELF, RakuAST::Routine, '$!package');

        # Make sure that any OperatorProperties are set on the meta-object
        # if it is some kind of operator.  This feels pretty hackish way
        # to do this, perhaps better done with dedicated subclasses of
        # RakuAST::Sub.  But it will do for now.
        if nqp::getattr($SELF, RakuAST::Routine, '$!name') {
            my @parts;
            for nqp::getattr($SELF, RakuAST::Routine, '$!name').colonpairs {
                @parts.push($_.canonicalize);
            }
            my str $op := nqp::join(' ',@parts);
            if $op {
                $op := nqp::substr($op,1,nqp::chars($op) - 2);
                my str $name := nqp::getattr($SELF, RakuAST::Routine, '$!name').canonicalize;
                my $op_props := nqp::eqat($name,'infix:',0)
                  ?? OperatorProperties.infix($op)
                  !! nqp::eqat($name,'prefix:',0)
                    ?? OperatorProperties.prefix($op)
                    !! nqp::eqat($name,'postfix:',0)
                      ?? OperatorProperties.postfix($op)
                      !! nqp::eqat($name,'postcircumfix:',0)
                        ?? OperatorProperties.postcircumfix($op)
                        !! nqp::eqat($name,'circumfix:',0)
                          ?? OperatorProperties.circumfix($op)
                          !! Mu;
                nqp::bindattr($routine,Routine,'$!op_props',$op_props)
                  if $op_props;
            }
        }

        $SELF.add-phasers-to-code-object($routine);

        $routine
    
    });
    add-method(RakuAST::Routine, 'is-begin-performed-before-children', [RakuAST::Routine, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1491 src/Raku/ast/code.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Routine, 'is-begin-performed-after-children', [RakuAST::Routine, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1492 src/Raku/ast/code.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Routine, 'PERFORM-BEGIN-BEFORE-CHILDREN', [RakuAST::Routine, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-BEFORE-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1494 src/Raku/ast/code.rakumod
        
        my $placeholder-signature := $SELF.placeholder-signature;
        if $placeholder-signature {
            $placeholder-signature.IMPL-ENSURE-IMPLICITS;
        }
        if nqp::getattr($SELF, RakuAST::Routine, '$!signature') {
            nqp::getattr($SELF, RakuAST::Routine, '$!signature').IMPL-ENSURE-IMPLICITS;
        }
    
    });
    add-method(RakuAST::Routine, 'PERFORM-BEGIN-AFTER-CHILDREN', [RakuAST::Routine, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-AFTER-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1504 src/Raku/ast/code.rakumod
        
        # Make sure that our placeholder signature has resolutions performed.
        my $placeholder-signature := $SELF.placeholder-signature;
        if $placeholder-signature {
            $placeholder-signature.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
        }
        # Make sure that our signature has resolutions performed.
        if nqp::getattr($SELF, RakuAST::Routine, '$!signature') {
            nqp::getattr($SELF, RakuAST::Routine, '$!signature').set-default-type(
                RakuAST::Type::Simple.new(
                    RakuAST::Name.from-identifier('Any'),
                ),
            );
            nqp::getattr($SELF, RakuAST::Routine, '$!signature').IMPL-ENSURE-IMPLICITS;
            nqp::getattr($SELF, RakuAST::Routine, '$!signature').IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
        }

        if $SELF.multiness eq 'multi' {
            my $name := '&' ~ $SELF.name.canonicalize;
            my $proto := $resolver.resolve-lexical($name, :current-scope-only);
            if $proto {
                $proto := $proto.compile-time-value;
            }
            else {
                my $scope := $resolver.current-scope;

                if $proto := $resolver.resolve-lexical-constant($name) {
                    $proto := $proto.compile-time-value.derive_dispatcher;
                }
                elsif $proto := $resolver.resolve-lexical-constant-in-outer($name) {
                    $proto := $proto.compile-time-value.derive_dispatcher;
                }
                else {
                    my $proto-ast := RakuAST::Sub.new(
                        :scope<my>,
                        :name($SELF.name),
                        :signature(RakuAST::Signature.new(
                            :parameters($SELF.IMPL-WRAP-LIST([
                                RakuAST::Parameter.new(
                                    :slurpy(RakuAST::Parameter::Slurpy::Capture),
                                )
                            ])),
                        )),
                        :body(RakuAST::OnlyStar.new),
                        :multiness<proto>,
                    );

                    $proto-ast.ensure-begin-performed($resolver, $context);
                    $proto := $proto-ast.meta-object;

                    $scope.add-generated-lexical-declaration(
                        RakuAST::VarDeclaration::Implicit::Block.new(:block($proto-ast))
                    );
                }
                $scope.add-generated-lexical-declaration(
                    RakuAST::VarDeclaration::Implicit::Constant.new(:$name, :value($proto))
                );
            }
            $proto.add_dispatchee($SELF.meta-object);
        }
        elsif $SELF.multiness eq 'proto' {
            nqp::bindattr($SELF.meta-object, Routine, '@!dispatchees', []);
        }

        $SELF.IMPL-STUB-PHASERS($resolver, $context);

        my $stub := $SELF.IMPL-STUB-CODE($resolver, $context);
        nqp::setcodename($stub, nqp::getattr($SELF, RakuAST::Routine, '$!name').canonicalize) if nqp::getattr($SELF, RakuAST::Routine, '$!name');

        # Apply any traits.
        $SELF.apply-traits($resolver, $context, $SELF)
    
    });
    add-method(RakuAST::Routine, 'PRODUCE-IMPLICIT-DECLARATIONS', [RakuAST::Routine, '', 0, 0], anon sub PRODUCE-IMPLICIT-DECLARATIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1577 src/Raku/ast/code.rakumod
        
        my $slash := 1;
        my $exclamation-mark := 1;
        my $underscore := 1;
        my @declarations;
        if nqp::getattr($SELF, RakuAST::Routine, '$!signature') {
            nqp::getattr($SELF, RakuAST::Routine, '$!signature').IMPL-ENSURE-IMPLICITS;
            my $implicit-invocant := nqp::getattr($SELF, RakuAST::Routine, '$!signature').implicit-invocant;
            if $implicit-invocant {
                my $type-captures := $SELF.IMPL-UNWRAP-LIST($implicit-invocant.type-captures);
                for $type-captures {
                    nqp::push(@declarations, $_);
                }
            }
            for $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Routine, '$!signature').parameters) {
                if ($_.target) {
                    my $name := $_.target.name;
                    $slash := 0            if $name eq '$/';
                    $exclamation-mark := 0 if $name eq '$!';
                    $underscore := 0       if $name eq '$_';
                }
                my $type-captures := $SELF.IMPL-UNWRAP-LIST($_.type-captures);
                for $type-captures {
                    nqp::push(@declarations, $_);
                }
            }
        }
        nqp::push(@declarations, RakuAST::VarDeclaration::Implicit::Special.new(:name('$/'))) if $slash;
        nqp::push(@declarations, RakuAST::VarDeclaration::Implicit::Special.new(:name('$!'))) if $exclamation-mark;
        nqp::push(@declarations, RakuAST::VarDeclaration::Implicit::Special.new(:name('$_'))) if $underscore;
        nqp::push(@declarations, RakuAST::VarDeclaration::Implicit::Routine.new()) if nqp::getattr($SELF, RakuAST::Routine, '$!need-routine-variable');
        $SELF.IMPL-WRAP-LIST(@declarations)
    
    });
    add-method(RakuAST::Routine, 'IMPL-HAS-PARAMETER', [RakuAST::Routine, '', 0, 0, Str, '$name', 0, 0], anon sub IMPL-HAS-PARAMETER ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 1611 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::Routine, '$!signature').IMPL-HAS-PARAMETER($name)
    
    });
    add-method(RakuAST::Routine, 'IMPL-QAST-FORM-BLOCK', [RakuAST::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-FORM-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 1616 src/Raku/ast/code.rakumod
        
        # RegexThunk needs the body compiled first
        my $body := $SELF.IMPL-COMPILE-BODY($context);

        my $block :=
            $SELF.IMPL-SET-NODE(
                QAST::Block.new(
                    :name($SELF.name ?? $SELF.name.canonicalize !! ''),
                    :blocktype('declaration_static'),
                    $SELF.IMPL-QAST-DECLS($context)
                ), :key);
        my $signature := $SELF.placeholder-signature || nqp::getattr($SELF, RakuAST::Routine, '$!signature');
        $block.push($signature.IMPL-QAST-BINDINGS($context, :needs-full-binder($SELF.custom-args)));
        $block.custom_args(1) if $SELF.custom-args;
        $block.arity($signature.arity);
        $block.annotate('count', $signature.count);
        $block.push($body);
        $SELF.add-phasers-handling-code($context, $block);
        $block
    
    });
    add-method(RakuAST::Routine, 'IMPL-COMPILE-BODY', [RakuAST::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-COMPILE-BODY ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1637 src/Raku/ast/code.rakumod
        
        nqp::die('RakuAST::Routine subclass must implement IMPL-COMPILE-BODY')
    
    });
    add-method(RakuAST::Routine, 'IMPL-WRAP-RETURN-HANDLER', [RakuAST::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, QAST::Node, '$body', 0, 0], anon sub IMPL-WRAP-RETURN-HANDLER ($SELF_CONT, $context!, $body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $body := nqp::decont($body);
#line 1641 src/Raku/ast/code.rakumod
        
        my $result := $body;
        my $routine := $SELF.compile-time-value;
        my $signature := nqp::getattr($routine, Code, '$!signature');
        $context.ensure-sc($routine);

        # Add return exception and decont handler if needed.
        # TODO optimize out if provably no return call
        my str $decont-rv-op := $context.lang-version lt 'd' && $context.is-moar
            ?? 'p6decontrv_6c'
            !! 'p6decontrv';
        $result := QAST::Op.new(
            :op<handlepayload>,
            QAST::Op.new( :op($decont-rv-op), QAST::WVal.new( :value($routine) ), $result ),
            'RETURN',
            QAST::Op.new( :op<lastexpayload> )
        );

        # Add return type check if needed.
        # TODO also infer body type
        my $returns := nqp::ifnull($signature.returns, Mu);
        unless $returns =:= Mu || $returns =:= Nil || nqp::isconcrete($returns) {
            $context.ensure-sc($returns);
            $result := QAST::Op.new(
                :op('p6typecheckrv'),
                $result,
                QAST::WVal.new( :value($routine) ),
                QAST::WVal.new( :value(Nil) )
            );
        }

        $result
    
    });
    add-method(RakuAST::Routine, 'IMPL-QAST-DECL-CODE', [RakuAST::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL-CODE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1675 src/Raku/ast/code.rakumod
        
        # Form the QAST block itself and link it with the meta-object.
        my $block := $SELF.IMPL-QAST-BLOCK($context);

        # Set a name, if there is one.
        if nqp::getattr($SELF, RakuAST::Routine, '$!name') {
            my $canon-name := nqp::getattr($SELF, RakuAST::Routine, '$!name').canonicalize;
            $block.name($canon-name);
        }

        my $name := $SELF.lexical-name;
        if $name && ($SELF.scope eq 'our' || $SELF.scope eq 'unit') {
            my $stmts := $SELF.IMPL-SET-NODE(QAST::Stmts.new(), :key);
            $stmts.push($block);
            (nqp::getattr($SELF, RakuAST::Routine, '$!package').meta-object.WHO){$name} := $SELF.meta-object;
            $stmts.push(QAST::Op.new(
                :op('bindkey'),
                QAST::Op.new( :op('who'), QAST::WVal.new( :value(nqp::getattr($SELF, RakuAST::Routine, '$!package').meta-object) ) ),
                QAST::SVal.new( :value($name) ),
                QAST::Var.new( :name($name), :scope('lexical') )
            ));
            return $stmts;
        }

        $block
    
    });
    add-method(RakuAST::Routine, 'IMPL-QAST-DECL', [RakuAST::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1702 src/Raku/ast/code.rakumod
        
        # If we're a named lexical thing, install us in the block.
        my $name := $SELF.lexical-name;
        if $name && $SELF.multiness ne 'multi' {
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :decl<var>, :scope<lexical>, :$name ),
                $SELF.IMPL-CLOSURE-QAST($context)
            )
        }
        else {
            QAST::Op.new( :op('null') )
        }
    
    });
    add-method(RakuAST::Routine, 'IMPL-EXPR-QAST', [RakuAST::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1717 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-CLOSURE-QAST($context)
    
    });
    add-method(RakuAST::Routine, 'lexical-name', [RakuAST::Routine, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1721 src/Raku/ast/code.rakumod
        
        my $name := $SELF.name;
        if $name {
            '&' ~ $name.canonicalize
        }
        else {
            Nil
        }
    
    });
    add-method(RakuAST::Routine, 'is-lexical', [RakuAST::Routine, '', 0, 0], anon sub is-lexical ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1731 src/Raku/ast/code.rakumod
        
        my str $scope := $SELF.scope;
        $scope eq 'my' || $scope eq 'state' || $scope eq 'our' || $scope eq 'unit'
    
    });
    add-method(RakuAST::Routine, 'is-simple-lexical-declaration', [RakuAST::Routine, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1736 src/Raku/ast/code.rakumod
        
        $SELF.is-lexical && $SELF.multiness ne 'multi'
    
    });
    add-method(RakuAST::Routine, 'generate-lookup', [RakuAST::Routine, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1740 src/Raku/ast/code.rakumod
        
        if $SELF.is-lexical {
            my $lookup := RakuAST::Var::Lexical.new($SELF.lexical-name);
            $lookup.set-resolution($SELF);
            $lookup
        }
        else {
            nqp::die('Cannot generate lookup of a routine for scope ' ~ $SELF.scope);
        }
    
    });
    add-method(RakuAST::Routine, 'IMPL-LOOKUP-QAST', [RakuAST::Routine, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$rvalue', 1, 1], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!, :$rvalue?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $rvalue := nqp::decont($rvalue);
#line 1751 src/Raku/ast/code.rakumod
        
        QAST::Var.new( :scope('lexical'), :name($SELF.lexical-name) )
    
    });
    add-method(RakuAST::Routine, 'visit-children', [RakuAST::Routine, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1755 src/Raku/ast/code.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Routine, '$!name')) if nqp::getattr($SELF, RakuAST::Routine, '$!name');
        $visitor($SELF.WHY) if $SELF.WHY;  # needs to be before signature
        $visitor(nqp::getattr($SELF, RakuAST::Routine, '$!signature'));
        $SELF.visit-traits($visitor);
        $visitor($SELF.body);
    
    });
    add-method(RakuAST::Routine, 'IMPL-CAN-INTERPRET', [RakuAST::Routine, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1763 src/Raku/ast/code.rakumod
        
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Routine, 'IMPL-INTERPRET', [RakuAST::Routine, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 1767 src/Raku/ast/code.rakumod
        
        $SELF.meta-object
    
    });
#line 1381 src/Raku/ast/code.rakumod
    add-method(RakuAST::Routine, 'signature', [], anon sub signature ($self) { nqp::getattr(nqp::decont($self), RakuAST::Routine, '$!signature') });
#line 1384 src/Raku/ast/code.rakumod
    add-method(RakuAST::Routine, 'need-routine-variable', [], anon sub need-routine-variable ($self) { nqp::getattr(nqp::decont($self), RakuAST::Routine, '$!need-routine-variable') });
#line 1380 src/Raku/ast/code.rakumod
    add-method(RakuAST::Routine, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Routine, '$!name') });
    compose(RakuAST::Routine);
    parent(RakuAST::Sub, RakuAST::Routine);
    parent(RakuAST::Sub, RakuAST::SinkBoundary);
    add-attribute(RakuAST::Sub, RakuAST::Blockoid, '$!body');
    add-method(RakuAST::Sub, 'new', [RakuAST::Sub, '', 0, 0, str, '$scope', 1, 1, str, '$multiness', 1, 1, RakuAST::Name, '$name', 1, 1, RakuAST::Signature, '$signature', 1, 1, List, '$traits', 1, 1, RakuAST::Blockoid, '$body', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$scope?, :$multiness?, :$name?, :$signature?, :$traits?, :$body?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $multiness := nqp::decont($multiness);
        $name := nqp::decont($name);
        $signature := nqp::decont($signature);
        $traits := nqp::decont($traits);
        $body := nqp::decont($body);
        $WHY := nqp::decont($WHY);
#line 1786 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr_s($obj, RakuAST::Routine, '$!multiness', $multiness //'');
        nqp::bindattr($obj, RakuAST::Routine, '$!name', $name // RakuAST::Name);
        nqp::bindattr($obj, RakuAST::Routine, '$!signature',
          $signature // RakuAST::Signature.new);
        $obj.set-traits($traits);
        nqp::bindattr($obj, RakuAST::Sub, '$!body',
          $body // RakuAST::Blockoid.new);
        $obj.set-WHY($WHY);
        $obj
    
    });
    add-method(RakuAST::Sub, 'replace-body', [RakuAST::Sub, '', 0, 0, RakuAST::Blockoid, '$new-body', 0, 0], anon sub replace-body ($SELF_CONT, $new-body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-body := nqp::decont($new-body);
#line 1800 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Sub, '$!body', $new-body);
        Nil
    
    });
    add-method(RakuAST::Sub, 'IMPL-META-OBJECT-TYPE', [RakuAST::Sub, '', 0, 0], anon sub IMPL-META-OBJECT-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1805 src/Raku/ast/code.rakumod
         Sub 
    });
    add-method(RakuAST::Sub, 'default-scope', [RakuAST::Sub, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1807 src/Raku/ast/code.rakumod
        
        $SELF.name ?? 'my' !! 'anon'
    
    });
    add-method(RakuAST::Sub, 'allowed-scopes', [RakuAST::Sub, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1811 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST(['my', 'anon', 'our'])
    
    });
    add-method(RakuAST::Sub, 'get-boundary-sink-propagator', [RakuAST::Sub, '', 0, 0], anon sub get-boundary-sink-propagator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1815 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::Sub, '$!body').statement-list
    
    });
    add-method(RakuAST::Sub, 'is-boundary-sunk', [RakuAST::Sub, '', 0, 0], anon sub is-boundary-sunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1819 src/Raku/ast/code.rakumod
        
        my $signature := $SELF.signature;
        $signature ?? $signature.provides-return-value !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Sub, 'IMPL-COMPILE-BODY', [RakuAST::Sub, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-COMPILE-BODY ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1824 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-RETURN-HANDLER($context,
            $SELF.IMPL-WRAP-SCOPE-HANDLER-QAST($context,
                $SELF.IMPL-APPEND-SIGNATURE-RETURN($context, nqp::getattr($SELF, RakuAST::Sub, '$!body').IMPL-TO-QAST($context))))
    
    });
#line 1777 src/Raku/ast/code.rakumod
    add-method(RakuAST::Sub, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Sub, '$!body') });
    compose(RakuAST::Sub);
    parent(RakuAST::Methodish, RakuAST::Routine);
    parent(RakuAST::Methodish, RakuAST::Attaching);
    add-method(RakuAST::Methodish, 'default-scope', [RakuAST::Methodish, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1837 src/Raku/ast/code.rakumod
        
        $SELF.name ?? 'has' !! 'anon'
    
    });
    add-method(RakuAST::Methodish, 'allowed-scopes', [RakuAST::Methodish, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1841 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST(['has', 'my', 'anon', 'our'])
    
    });
    add-method(RakuAST::Methodish, 'attach', [RakuAST::Methodish, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1845 src/Raku/ast/code.rakumod
        
        if $SELF.scope eq 'has' || $SELF.scope eq 'our' {
            my $package := $resolver.find-attach-target('package');
            if $package {
                nqp::bindattr($SELF, RakuAST::Routine, '$!package', $package);
            }
        }
        nqp::bindattr($SELF, RakuAST::Code, '$!resolver', $resolver.clone);
    
    });
    add-method(RakuAST::Methodish, 'is-begin-performed-before-children', [RakuAST::Methodish, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1855 src/Raku/ast/code.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Methodish, 'is-begin-performed-after-children', [RakuAST::Methodish, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1856 src/Raku/ast/code.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Methodish, 'PERFORM-BEGIN-BEFORE-CHILDREN', [RakuAST::Methodish, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-BEFORE-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1858 src/Raku/ast/code.rakumod
        
        my $package := nqp::getattr($SELF, RakuAST::Routine, '$!package');
        my $package-is-role := $package && $package.declarator eq 'role';
        my $placeholder-signature := $SELF.placeholder-signature;
        if $placeholder-signature {
            $placeholder-signature.set-is-on-method((Bool.WHO)<True>);
            $placeholder-signature.set-is-on-named-method((Bool.WHO)<True>) if $SELF.name;
            $placeholder-signature.set-is-on-meta-method((Bool.WHO)<True>) if nqp::can($SELF, 'meta') && $SELF.meta;
            $placeholder-signature.set-is-on-role-method((Bool.WHO)<True>) if $package-is-role;
            $placeholder-signature.attach($resolver);
            $placeholder-signature.IMPL-ENSURE-IMPLICITS;
        }
        # Make sure that our signature has resolutions performed.
        my $signature := $SELF.signature;
        if $signature {
            $signature.set-default-type(
                RakuAST::Type::Simple.new(
                    RakuAST::Name.from-identifier('Any'),
                ),
            );
            $signature.set-is-on-method((Bool.WHO)<True>);
            $signature.set-is-on-named-method((Bool.WHO)<True>) if $SELF.name;
            $signature.set-is-on-meta-method((Bool.WHO)<True>) if nqp::can($SELF, 'meta') && $SELF.meta;
            $signature.set-is-on-role-method((Bool.WHO)<True>) if $package-is-role;
            $signature.attach($resolver);
            $signature.IMPL-ENSURE-IMPLICITS;
        }
    
    });
    add-method(RakuAST::Methodish, 'PERFORM-BEGIN-AFTER-CHILDREN', [RakuAST::Methodish, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN-AFTER-CHILDREN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1887 src/Raku/ast/code.rakumod
        
        if nqp::getattr($SELF,RakuAST::Routine,'$!package') {
            nqp::getattr($SELF,RakuAST::Routine,'$!package').ATTACH-METHOD($SELF)
              unless $SELF.scope eq 'our';
        }
        elsif $SELF.scope eq 'has' {
            nqp::die('Did not find an attach target for method.');
        }

        # Make sure that our placeholder signature has resolutions performed.
        my $placeholder-signature := $SELF.placeholder-signature;
        if $placeholder-signature {
            $placeholder-signature.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
        }
        # Make sure that our signature has resolutions performed.
        my $signature := $SELF.signature;
        if $signature {
            $signature.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
        }

        if $SELF.multiness eq 'proto' {
            nqp::bindattr($SELF.meta-object, Routine, '@!dispatchees', []);
        }
        $SELF.IMPL-STUB-PHASERS($resolver, $context);

        my $stub := $SELF.IMPL-STUB-CODE($resolver, $context);
        nqp::setcodename($stub, $SELF.name.canonicalize) if $SELF.name;

        # Apply any traits.
        $SELF.apply-traits($resolver, $context, $SELF)
    
    });
    compose(RakuAST::Methodish);
    parent(RakuAST::Method, RakuAST::Methodish);
    parent(RakuAST::Method, RakuAST::SinkBoundary);
    add-attribute(RakuAST::Method, RakuAST::Blockoid, '$!body');
    add-attribute(RakuAST::Method, Bool, '$!meta');
    add-attribute(RakuAST::Method, Bool, '$!private');
    add-method(RakuAST::Method, 'new', [RakuAST::Method, '', 0, 0, str, '$scope', 1, 1, str, '$multiness', 1, 1, Bool, '$private', 1, 1, Bool, '$meta', 1, 1, RakuAST::Name, '$name', 1, 1, RakuAST::Signature, '$signature', 1, 1, List, '$traits', 1, 1, RakuAST::Blockoid, '$body', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$scope?, :$multiness?, :$private?, :$meta?, :$name?, :$signature?, :$traits?, :$body?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $multiness := nqp::decont($multiness);
        $private := nqp::decont($private);
        $meta := nqp::decont($meta);
        $name := nqp::decont($name);
        $signature := nqp::decont($signature);
        $traits := nqp::decont($traits);
        $body := nqp::decont($body);
        $WHY := nqp::decont($WHY);
#line 1938 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr_s($obj, RakuAST::Routine, '$!multiness', $multiness //'');
        nqp::bindattr($obj, RakuAST::Method, '$!private',
          $private ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Method, '$!meta', $meta ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Routine, '$!name', $name // RakuAST::Name);
        nqp::bindattr($obj, RakuAST::Routine, '$!signature',
          $signature // RakuAST::Signature.new);
        $obj.set-traits($traits);
        nqp::bindattr($obj, RakuAST::Method, '$!body',
          $body // RakuAST::Blockoid.new);
        $obj.set-WHY($WHY);
        $obj
    
    });
    add-method(RakuAST::Method, 'replace-body', [RakuAST::Method, '', 0, 0, RakuAST::Blockoid, '$new-body', 0, 0], anon sub replace-body ($SELF_CONT, $new-body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-body := nqp::decont($new-body);
#line 1955 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Method, '$!body', $new-body);
        Nil
    
    });
    add-method(RakuAST::Method, 'set-meta', [RakuAST::Method, '', 0, 0, Bool, '$meta', 0, 0], anon sub set-meta ($SELF_CONT, $meta!) {
        my $SELF := nqp::decont($SELF_CONT);
        $meta := nqp::decont($meta);
#line 1960 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Method, '$!meta', $meta ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
    
    });
    add-method(RakuAST::Method, 'set-private', [RakuAST::Method, '', 0, 0, Bool, '$private', 0, 0], anon sub set-private ($SELF_CONT, $private!) {
        my $SELF := nqp::decont($SELF_CONT);
        $private := nqp::decont($private);
#line 1964 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::Method, '$!private', $private ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
    
    });
    add-method(RakuAST::Method, 'IMPL-META-OBJECT-TYPE', [RakuAST::Method, '', 0, 0], anon sub IMPL-META-OBJECT-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1968 src/Raku/ast/code.rakumod
         Method 
    });
    add-method(RakuAST::Method, 'PRODUCE-IMPLICIT-DECLARATIONS', [RakuAST::Method, '', 0, 0], anon sub PRODUCE-IMPLICIT-DECLARATIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1970 src/Raku/ast/code.rakumod
        
        my $list := nqp::findmethod(RakuAST::Routine, 'PRODUCE-IMPLICIT-DECLARATIONS')($SELF);
        $SELF.IMPL-UNWRAP-LIST($list).push:
            RakuAST::VarDeclaration::Implicit::Self.new(),
    
    });
    add-method(RakuAST::Method, 'get-boundary-sink-propagator', [RakuAST::Method, '', 0, 0], anon sub get-boundary-sink-propagator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1976 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::Method, '$!body').statement-list
    
    });
    add-method(RakuAST::Method, 'is-boundary-sunk', [RakuAST::Method, '', 0, 0], anon sub is-boundary-sunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1980 src/Raku/ast/code.rakumod
        
        my $signature := $SELF.signature;
        $signature ?? $signature.provides-return-value !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Method, 'IMPL-COMPILE-BODY', [RakuAST::Method, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-COMPILE-BODY ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1985 src/Raku/ast/code.rakumod
        
        # If our first expression is a stub object (!!!, ..., ???),
        # set the yada bit on the Method itself
        if (my $first-statement := nqp::getattr($SELF, RakuAST::Method, '$!body').statement-list.statements.AT-POS(0))
            && nqp::istype($first-statement, RakuAST::Statement::Expression)
            && nqp::istype($first-statement.expression, RakuAST::Stub)
        {
            $SELF.meta-object.set_yada;
        }

        $SELF.IMPL-WRAP-RETURN-HANDLER($context,
            $SELF.IMPL-WRAP-SCOPE-HANDLER-QAST($context,
                $SELF.IMPL-APPEND-SIGNATURE-RETURN($context, nqp::getattr($SELF, RakuAST::Method, '$!body').IMPL-TO-QAST($context))))
    
    });
#line 1927 src/Raku/ast/code.rakumod
    add-method(RakuAST::Method, 'private', [], anon sub private ($self) { nqp::getattr(nqp::decont($self), RakuAST::Method, '$!private') });
#line 1926 src/Raku/ast/code.rakumod
    add-method(RakuAST::Method, 'meta', [], anon sub meta ($self) { nqp::getattr(nqp::decont($self), RakuAST::Method, '$!meta') });
#line 1925 src/Raku/ast/code.rakumod
    add-method(RakuAST::Method, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Method, '$!body') });
    compose(RakuAST::Method);
    parent(RakuAST::Submethod, RakuAST::Method);
    add-method(RakuAST::Submethod, 'IMPL-META-OBJECT-TYPE', [RakuAST::Submethod, '', 0, 0], anon sub IMPL-META-OBJECT-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2005 src/Raku/ast/code.rakumod
         Submethod 
    });
    compose(RakuAST::Submethod);
    parent(RakuAST::RegexDeclaration, RakuAST::Methodish);
    parent(RakuAST::RegexDeclaration, RakuAST::CheckTime);
    add-attribute(RakuAST::RegexDeclaration, RakuAST::Regex, '$!body');
    add-attribute(RakuAST::RegexDeclaration, str, '$!source');
    add-method(RakuAST::RegexDeclaration, 'new', [RakuAST::RegexDeclaration, '', 0, 0, str, '$scope', 1, 1, RakuAST::Name, '$name', 1, 1, RakuAST::Signature, '$signature', 1, 1, List, '$traits', 1, 1, RakuAST::Regex, '$body', 1, 1, str, '$source', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$scope?, :$name?, :$signature?, :$traits?, :$body?, :$source?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $name := nqp::decont($name);
        $signature := nqp::decont($signature);
        $traits := nqp::decont($traits);
        $body := nqp::decont($body);
        $source := nqp::decont($source);
        $WHY := nqp::decont($WHY);
#line 2024 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::Routine, '$!name', $name // RakuAST::Name);
        nqp::bindattr($obj, RakuAST::Routine, '$!signature',
            $signature // RakuAST::Signature.new);
        $obj.set-traits($traits);
        nqp::bindattr($obj, RakuAST::RegexDeclaration, '$!body',
            $body // RakuAST::Regex::Assertion::Fail.new);
        $obj.set-source($source);
        $obj.set-WHY($WHY);
        $obj
    
    });
    add-method(RakuAST::RegexDeclaration, 'declarator', [RakuAST::RegexDeclaration, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2038 src/Raku/ast/code.rakumod
         'regex' 
    });
    add-method(RakuAST::RegexDeclaration, 'replace-body', [RakuAST::RegexDeclaration, '', 0, 0, RakuAST::Regex, '$new-body', 0, 0], anon sub replace-body ($SELF_CONT, $new-body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-body := nqp::decont($new-body);
#line 2040 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::RegexDeclaration, '$!body', $new-body);
        Nil
    
    });
    add-method(RakuAST::RegexDeclaration, 'set-source', [RakuAST::RegexDeclaration, '', 0, 0, Any, '$source', 0, 0], anon sub set-source ($SELF_CONT, $source!) {
        my $SELF := nqp::decont($SELF_CONT);
        $source := nqp::decont($source);
#line 2045 src/Raku/ast/code.rakumod
        
        nqp::bindattr_s($SELF, RakuAST::RegexDeclaration, '$!source',
          $source // '');
        Nil
    
    });
    add-method(RakuAST::RegexDeclaration, 'PERFORM-CHECK', [RakuAST::RegexDeclaration, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 2054 src/Raku/ast/code.rakumod
        
        my $meta := $SELF.meta-object;
        nqp::bindattr_s($meta, $meta.WHAT, '$!source',
          $SELF.declarator ~ ' ' ~ nqp::getattr_s($SELF, RakuAST::RegexDeclaration, '$!source')
        );
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::RegexDeclaration, 'IMPL-META-OBJECT-TYPE', [RakuAST::RegexDeclaration, '', 0, 0], anon sub IMPL-META-OBJECT-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2062 src/Raku/ast/code.rakumod
         Regex 
    });
    add-method(RakuAST::RegexDeclaration, 'PRODUCE-IMPLICIT-DECLARATIONS', [RakuAST::RegexDeclaration, '', 0, 0], anon sub PRODUCE-IMPLICIT-DECLARATIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2064 src/Raku/ast/code.rakumod
        
        my @declarations := [
            RakuAST::VarDeclaration::Implicit::Special.new(:name('$/')),
            RakuAST::VarDeclaration::Implicit::Special.new(:name('$!')),
            RakuAST::VarDeclaration::Implicit::Special.new(:name('$_')),
            RakuAST::VarDeclaration::Implicit::Self.new(),
            RakuAST::VarDeclaration::Implicit::Cursor.new(),
        ];
        nqp::push(@declarations, RakuAST::VarDeclaration::Implicit::Routine.new())
            if nqp::getattr($SELF, RakuAST::Routine, '$!need-routine-variable');
        $SELF.IMPL-WRAP-LIST(@declarations)
    
    });
    add-method(RakuAST::RegexDeclaration, 'IMPL-COMPILE-BODY', [RakuAST::RegexDeclaration, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-COMPILE-BODY ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2077 src/Raku/ast/code.rakumod
        
        my %mods;
        %mods<s> := 1 if $SELF.declarator eq 'rule';
        %mods<r> := 1 if $SELF.declarator ne 'regex';

        my $name := $SELF.name;
        $name := $name ?? $name.canonicalize !! "";

        $SELF.IMPL-SET-NODE(
            QAST::Stmts.new(
                # Regex compiler wants a local named "self"
                QAST::Op.new(
                    :op('bind'),
                    QAST::Var.new( :decl('var'), :scope('local'), :name('self') ),
                    QAST::Var.new( :scope('lexical'), :name('self') )
                ),
                nqp::getattr($SELF, RakuAST::RegexDeclaration, '$!body').IMPL-REGEX-TOP-LEVEL-QAST(
                  $context, $SELF.meta-object, %mods, :$name
                )
            ), :key)
    
    });
#line 2015 src/Raku/ast/code.rakumod
    add-method(RakuAST::RegexDeclaration, 'source', [], anon sub source ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::RegexDeclaration, '$!source') });
#line 2014 src/Raku/ast/code.rakumod
    add-method(RakuAST::RegexDeclaration, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::RegexDeclaration, '$!body') });
    compose(RakuAST::RegexDeclaration);
    parent(RakuAST::TokenDeclaration, RakuAST::RegexDeclaration);
    add-method(RakuAST::TokenDeclaration, 'declarator', [RakuAST::TokenDeclaration, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2103 src/Raku/ast/code.rakumod
         'token' 
    });
    compose(RakuAST::TokenDeclaration);
    parent(RakuAST::RuleDeclaration, RakuAST::RegexDeclaration);
    add-method(RakuAST::RuleDeclaration, 'declarator', [RakuAST::RuleDeclaration, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2109 src/Raku/ast/code.rakumod
         'rule' 
    });
    compose(RakuAST::RuleDeclaration);
    parent(RakuAST::RegexThunk, RakuAST::Code);
    parent(RakuAST::RegexThunk, RakuAST::Meta);
    parent(RakuAST::RegexThunk, RakuAST::BeginTime);
    add-method(RakuAST::RegexThunk, 'PRODUCE-META-OBJECT', [RakuAST::RegexThunk, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2121 src/Raku/ast/code.rakumod
        
        # Create default signature, receiving invocant only.
        my $signature := nqp::create(Signature);
        my $parameter := nqp::create(Parameter);
        nqp::bindattr($parameter, Parameter, '$!type', Mu);
        nqp::bindattr($signature, Signature, '@!params', nqp::list($parameter));

        # Create Regex object.
        my $regex := nqp::create(Regex);
        nqp::bindattr($regex, Code, '$!signature', $signature);
        nqp::bindattr_s($regex, Regex, '$!source', $SELF.origin ?? $SELF.origin.Str !! $SELF.DEPARSE);
        nqp::bindattr($signature, Signature, '$!code', $regex);
        $regex
    
    });
    add-method(RakuAST::RegexThunk, 'IMPL-QAST-FORM-BLOCK', [RakuAST::RegexThunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-FORM-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 2137 src/Raku/ast/code.rakumod
        
        my $slash := RakuAST::VarDeclaration::Implicit::Special.new(:name('$/'));
        QAST::Block.new(
            :blocktype('declaration_static'),
            QAST::Var.new( :decl('var'), :scope('local'), :name('self') ),
            QAST::Var.new( :decl('var'), :scope('lexical'), :name('$¢') ),
            QAST::Op.new(
              :op('bind'),
              QAST::Var.new(:name('$?REGEX'), :scope<lexical>, :decl('var')),
              QAST::Op.new(
                  :op('getcodeobj'),
                  QAST::Op.new( :op('curcode') )
              )
            ),
            $slash.IMPL-QAST-DECL($context),
            QAST::Var.new(
                :decl('param'), :scope('local'), :name('__lowered_param'),
                QAST::Op.new(
                    :op('bind'),
                    QAST::Var.new( :scope('local'), :name('self') ),
                    QAST::Op.new(
                        :op('decont'),
                        QAST::Var.new( :scope('local'), :name('__lowered_param') )
                    )
                )
            ),
            $SELF.IMPL-THUNKED-REGEX-QAST($context)
        )
    
    });
    add-method(RakuAST::RegexThunk, 'is-begin-performed-before-children', [RakuAST::RegexThunk, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2167 src/Raku/ast/code.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::RegexThunk, 'PERFORM-BEGIN', [RakuAST::RegexThunk, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 2169 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-STUB-CODE($resolver, $context);

        Nil
    
    });
    compose(RakuAST::RegexThunk);
    parent(RakuAST::QuotedMatchConstruct, RakuAST::Term);
    parent(RakuAST::QuotedMatchConstruct, RakuAST::BeginTime);
    add-attribute(RakuAST::QuotedMatchConstruct, List, '$!adverbs');
    add-method(RakuAST::QuotedMatchConstruct, 'replace-adverbs', [RakuAST::QuotedMatchConstruct, '', 0, 0, List, '$adverbs', 0, 0], anon sub replace-adverbs ($SELF_CONT, $adverbs!) {
        my $SELF := nqp::decont($SELF_CONT);
        $adverbs := nqp::decont($adverbs);
#line 2184 src/Raku/ast/code.rakumod
        
        my @checked-adverbs;
        if $adverbs {
            for $SELF.IMPL-UNWRAP-LIST($adverbs) {
                unless nqp::istype($_, RakuAST::QuotePair) {
                    nqp::die('A regex adverb may only be a RakuAST::QuotePair');
                }
                nqp::push(@checked-adverbs, $_);
            }
        }
        nqp::bindattr($SELF, RakuAST::QuotedMatchConstruct, '$!adverbs',
            $SELF.IMPL-WRAP-LIST(@checked-adverbs));
        Nil
    
    });
    add-method(RakuAST::QuotedMatchConstruct, 'IMPL-NORMALIZE-ADVERB', [RakuAST::QuotedMatchConstruct, '', 0, 0, str, '$adverb', 0, 0], anon sub IMPL-NORMALIZE-ADVERB ($SELF_CONT, $adverb!) {
        my $SELF := nqp::decont($SELF_CONT);
        $adverb := nqp::decont($adverb);
#line 2199 src/Raku/ast/code.rakumod
        
        my constant NORMS := nqp::hash(
            'ignorecase',   'i',
            'ignoremark',   'm',
            'ratchet',      'r',
            'sigspace',     's',
            'continue',     'c',
            'pos',          'p',
            'th',           'nth',
            'st',           'nth',
            'nd',           'nth',
            'rd',           'nth',
            'global',       'g',
            'overlap',      'ov',
            'exhaustive',   'ex',
            'Perl5',        'P5',
            'samecase',     'ii',
            'samespace',    'ss',
            'samemark',     'mm',
            'squash',       's',
            'complement',   'c',
            'delete',       'd'
        );
        NORMS{$adverb} // $adverb
    
    });
    add-method(RakuAST::QuotedMatchConstruct, 'IMPL-IS-COMPILATION-ADVERB', [RakuAST::QuotedMatchConstruct, '', 0, 0, str, '$norm-adverb', 0, 0], anon sub IMPL-IS-COMPILATION-ADVERB ($SELF_CONT, $norm-adverb!) {
        my $SELF := nqp::decont($SELF_CONT);
        $norm-adverb := nqp::decont($norm-adverb);
#line 2225 src/Raku/ast/code.rakumod
        
        my constant COMPS := nqp::hash('i', 1, 'm', 1, 'r', 1, 's', 1, 'P5', 1);
        nqp::existskey(COMPS, $norm-adverb)
    
    });
    add-method(RakuAST::QuotedMatchConstruct, 'IMPL-IS-POSITION-ADVERB', [RakuAST::QuotedMatchConstruct, '', 0, 0, str, '$norm-adverb', 0, 0], anon sub IMPL-IS-POSITION-ADVERB ($SELF_CONT, $norm-adverb!) {
        my $SELF := nqp::decont($SELF_CONT);
        $norm-adverb := nqp::decont($norm-adverb);
#line 2230 src/Raku/ast/code.rakumod
        
        my constant POS := nqp::hash('c', 1, 'p', 1);
        nqp::existskey(POS, $norm-adverb)
    
    });
    add-method(RakuAST::QuotedMatchConstruct, 'IMPL-IS-MULTIPLE-ADVERB', [RakuAST::QuotedMatchConstruct, '', 0, 0, str, '$norm-adverb', 0, 0], anon sub IMPL-IS-MULTIPLE-ADVERB ($SELF_CONT, $norm-adverb!) {
        my $SELF := nqp::decont($SELF_CONT);
        $norm-adverb := nqp::decont($norm-adverb);
#line 2235 src/Raku/ast/code.rakumod
        
        my constant POS := nqp::hash('x', 1, 'g', 1, 'ov', 1, 'ex', 1);
        nqp::existskey(POS, $norm-adverb)
    
    });
    add-method(RakuAST::QuotedMatchConstruct, 'IMPL-SUBST-TO-MATCH-ADVERB', [RakuAST::QuotedMatchConstruct, '', 0, 0, str, '$adverb', 0, 0], anon sub IMPL-SUBST-TO-MATCH-ADVERB ($SELF_CONT, $adverb!) {
        my $SELF := nqp::decont($SELF_CONT);
        $adverb := nqp::decont($adverb);
#line 2240 src/Raku/ast/code.rakumod
        
        my constant S2M := nqp::hash('ii', 'i', 'ss', 's', 'mm', 'm');
        S2M{$adverb} // $adverb
    
    });
    add-method(RakuAST::QuotedMatchConstruct, 'IMPL-ADVERBS-TO-COMPILATION-MODS', [RakuAST::QuotedMatchConstruct, '', 0, 0], anon sub IMPL-ADVERBS-TO-COMPILATION-MODS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2245 src/Raku/ast/code.rakumod
        
        # Obtain adverbs that affect compilation and install them into
        # the %mods hash.
        my %mods;
        for $SELF.IMPL-UNWRAP-LIST($SELF.adverbs) {
            my str $norm := $SELF.IMPL-SUBST-TO-MATCH-ADVERB($SELF.IMPL-NORMALIZE-ADVERB($_.key));
            if $SELF.IMPL-IS-COMPILATION-ADVERB($norm) {
                %mods{$norm} := $_.simple-compile-time-quote-value() ?? 1 !! 0;
            }
        }
        %mods
    
    });
    add-method(RakuAST::QuotedMatchConstruct, 'IMPL-VISIT-ADVERBS', [RakuAST::QuotedMatchConstruct, '', 0, 0, Code, '$visitor', 0, 0], anon sub IMPL-VISIT-ADVERBS ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2258 src/Raku/ast/code.rakumod
        
        for $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::QuotedMatchConstruct, '$!adverbs')) {
            $visitor($_);
        }
    
    });
    add-method(RakuAST::QuotedMatchConstruct, 'is-begin-performed-before-children', [RakuAST::QuotedMatchConstruct, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2264 src/Raku/ast/code.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::QuotedMatchConstruct, 'PERFORM-BEGIN', [RakuAST::QuotedMatchConstruct, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 2266 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-STUB-CODE($resolver, $context);

        Nil
    
    });
#line 2182 src/Raku/ast/code.rakumod
    add-method(RakuAST::QuotedMatchConstruct, 'adverbs', [], anon sub adverbs ($self) { nqp::getattr(nqp::decont($self), RakuAST::QuotedMatchConstruct, '$!adverbs') });
    compose(RakuAST::QuotedMatchConstruct);
    parent(RakuAST::QuotedRegex, RakuAST::RegexThunk);
    parent(RakuAST::QuotedRegex, RakuAST::QuotedMatchConstruct);
    parent(RakuAST::QuotedRegex, RakuAST::Sinkable);
    parent(RakuAST::QuotedRegex, RakuAST::ImplicitLookups);
    parent(RakuAST::QuotedRegex, RakuAST::CheckTime);
    add-attribute(RakuAST::QuotedRegex, RakuAST::Regex, '$!body');
    add-attribute(RakuAST::QuotedRegex, Bool, '$!match-immediately');
    add-method(RakuAST::QuotedRegex, 'new', [RakuAST::QuotedRegex, '', 0, 0, RakuAST::Regex, '$body', 1, 1, Bool, '$match-immediately', 1, 1, List, '$adverbs', 1, 1], anon sub new ($SELF_CONT, :$body?, :$match-immediately?, :$adverbs?) {
        my $SELF := nqp::decont($SELF_CONT);
        $body := nqp::decont($body);
        $match-immediately := nqp::decont($match-immediately);
        $adverbs := nqp::decont($adverbs);
#line 2285 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::QuotedRegex, '$!body',
            $body // RakuAST::Regex::Assertion::Fail.new);
        nqp::bindattr($obj, RakuAST::QuotedRegex, '$!match-immediately',
            $match-immediately ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj.replace-adverbs($adverbs // List);
        $obj
    
    });
    add-method(RakuAST::QuotedRegex, 'replace-body', [RakuAST::QuotedRegex, '', 0, 0, RakuAST::Regex, '$new-body', 0, 0], anon sub replace-body ($SELF_CONT, $new-body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $new-body := nqp::decont($new-body);
#line 2295 src/Raku/ast/code.rakumod
        
        nqp::bindattr($SELF, RakuAST::QuotedRegex, '$!body', $new-body);
        Nil
    
    });
    add-method(RakuAST::QuotedRegex, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::QuotedRegex, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2300 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('$_'),
            RakuAST::Var::Lexical.new('$/'),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier-parts(
                'Rakudo', 'Internals', 'RegexBoolification6cMarker'
            ))
        ])
    
    });
    add-method(RakuAST::QuotedRegex, 'IMPL-IS-IMMEDIATE-MATCH-ADVERB', [RakuAST::QuotedRegex, '', 0, 0, str, '$norm-adverb', 0, 0], anon sub IMPL-IS-IMMEDIATE-MATCH-ADVERB ($SELF_CONT, $norm-adverb!) {
        my $SELF := nqp::decont($SELF_CONT);
        $norm-adverb := nqp::decont($norm-adverb);
#line 2310 src/Raku/ast/code.rakumod
        
        $norm-adverb eq 'nth' || $SELF.IMPL-IS-POSITION-ADVERB($norm-adverb) ||
            $SELF.IMPL-IS-MULTIPLE-ADVERB($norm-adverb)
    
    });
    add-method(RakuAST::QuotedRegex, 'PERFORM-CHECK', [RakuAST::QuotedRegex, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 2315 src/Raku/ast/code.rakumod
        
        # Check adverbs
        for $SELF.IMPL-UNWRAP-LIST($SELF.adverbs) {
            my str $key := $_.key;
            my str $norm := $SELF.IMPL-NORMALIZE-ADVERB($key);
            if $SELF.IMPL-IS-COMPILATION-ADVERB($norm) {
                # Compile-time adverbs must have a simple compile time value.
                unless nqp::isconcrete($_.simple-compile-time-quote-value()) {
                    $SELF.add-sorry:
                      $resolver.build-exception: 'X::Value::Dynamic',
                        what => "Adverb $key";
                }
            }
            elsif !(nqp::getattr($SELF, RakuAST::QuotedRegex, '$!match-immediately') && $SELF.IMPL-IS-IMMEDIATE-MATCH-ADVERB($norm)) {
                # Not applicable to the construct, so report.
                $SELF.add-sorry:
                  $resolver.build-exception: 'X::Syntax::Regex::Adverb',
                    adverb    => $key,
                    construct => nqp::getattr($SELF, RakuAST::QuotedRegex, '$!match-immediately') ?? 'm' !! 'rx'
            }
        }
    
    });
    add-method(RakuAST::QuotedRegex, 'IMPL-THUNKED-REGEX-QAST', [RakuAST::QuotedRegex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-THUNKED-REGEX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2338 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::QuotedRegex, '$!body').IMPL-REGEX-TOP-LEVEL-QAST($context, $SELF.meta-object,
            $SELF.IMPL-ADVERBS-TO-COMPILATION-MODS())
    
    });
    add-method(RakuAST::QuotedRegex, 'IMPL-QAST-DECL-CODE', [RakuAST::QuotedRegex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL-CODE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2343 src/Raku/ast/code.rakumod
        
        # Form the block itself and link it with the meta-object.
        $SELF.IMPL-QAST-BLOCK($context, :blocktype('declaration_static'));
    
    });
    add-method(RakuAST::QuotedRegex, 'IMPL-EXPR-QAST', [RakuAST::QuotedRegex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2348 src/Raku/ast/code.rakumod
        
        my $closure := $SELF.IMPL-CLOSURE-QAST($context, :regex);
        if nqp::getattr($SELF, RakuAST::QuotedRegex, '$!match-immediately') {
            my $lookups := $SELF.get-implicit-lookups;
            my $topic   := $lookups.AT-POS(0).IMPL-TO-QAST($context);
            my $slash   := $lookups.AT-POS(1).IMPL-TO-QAST($context);

            my $match-qast := QAST::Op.new(
              :op('callmethod'), :name('match'), $topic, $closure
            );
            my int $is-multiple-match := 0;
            for $SELF.IMPL-UNWRAP-LIST($SELF.adverbs) {
                my str $norm := $SELF.IMPL-NORMALIZE-ADVERB($_.key);
                if $SELF.IMPL-IS-POSITION-ADVERB($norm) {
                    # These need to be passed the end of the last match.
                    $match-qast.push: QAST::Op.new:
                        :named($norm), :op<if>,
                        $slash,
                        QAST::Op.new( :op<callmethod>, :name<to>, $slash ),
                        QAST::IVal.new( :value(0) )
                }
                else {
                    # Pass the value of the pair.
                    my $arg := $_.value.IMPL-TO-QAST($context);
                    $arg.named($_.key);
                    $match-qast.push($arg);
                    $is-multiple-match := 1 if $SELF.IMPL-IS-MULTIPLE-ADVERB($norm);
                }
            }
            if $is-multiple-match {
                # Don't update $/ in the list case
                $match-qast
            }
            else {
                QAST::Op.new(
                  :op('decont'),
                  QAST::Op.new(:op('p6store'), $slash, $match-qast)
                )
            }
        }
        else {
            $SELF.sunk
                ?? QAST::Op.new( :op('callmethod'), :name('Bool'), $closure )
                !! $closure
        }
    
    });
    add-method(RakuAST::QuotedRegex, 'IMPL-TWEAK-REGEX-CLONE', [RakuAST::QuotedRegex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$clone', 0, 0], anon sub IMPL-TWEAK-REGEX-CLONE ($SELF_CONT, $context!, $clone!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $clone := nqp::decont($clone);
#line 2395 src/Raku/ast/code.rakumod
        
        my $lookups := $SELF.get-implicit-lookups;
        if $context.lang-version lt 'd' {
            my $topic := $lookups.AT-POS(2).IMPL-TO-QAST($context);
            $topic.named('topic');
            $clone.push($topic);
        }
        else {
            my $topic := $lookups.AT-POS(0).IMPL-TO-QAST($context);
            $topic.named('topic');
            $clone.push($topic);
            my $slash := $lookups.AT-POS(1).IMPL-TO-QAST($context);
            $slash.named('slash');
            $clone.push($slash);
        }
        Nil
    
    });
    add-method(RakuAST::QuotedRegex, 'visit-children', [RakuAST::QuotedRegex, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2413 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-VISIT-ADVERBS($visitor);
        $visitor(nqp::getattr($SELF, RakuAST::QuotedRegex, '$!body'));
    
    });
#line 2283 src/Raku/ast/code.rakumod
    add-method(RakuAST::QuotedRegex, 'match-immediately', [], anon sub match-immediately ($self) { nqp::getattr(nqp::decont($self), RakuAST::QuotedRegex, '$!match-immediately') });
#line 2282 src/Raku/ast/code.rakumod
    add-method(RakuAST::QuotedRegex, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::QuotedRegex, '$!body') });
    compose(RakuAST::QuotedRegex);
    parent(RakuAST::Substitution, RakuAST::RegexThunk);
    parent(RakuAST::Substitution, RakuAST::QuotedMatchConstruct);
    parent(RakuAST::Substitution, RakuAST::ImplicitLookups);
    parent(RakuAST::Substitution, RakuAST::CheckTime);
    add-attribute(RakuAST::Substitution, Bool, '$!immutable');
    add-attribute(RakuAST::Substitution, Bool, '$!samespace');
    add-attribute(RakuAST::Substitution, RakuAST::Regex, '$!pattern');
    add-attribute(RakuAST::Substitution, RakuAST::Infixish, '$!infix');
    add-attribute(RakuAST::Substitution, RakuAST::Expression, '$!replacement');
    add-method(RakuAST::Substitution, 'new', [RakuAST::Substitution, '', 0, 0, Bool, '$immutable', 1, 1, Bool, '$samespace', 1, 1, List, '$adverbs', 1, 1, RakuAST::Regex, '$pattern', 1, 0, RakuAST::Infixish, '$infix', 1, 1, RakuAST::Expression, '$replacement', 1, 0], anon sub new ($SELF_CONT, :$immutable?, :$samespace?, :$adverbs?, :$pattern!, :$infix?, :$replacement!) {
        my $SELF := nqp::decont($SELF_CONT);
        $immutable := nqp::decont($immutable);
        $samespace := nqp::decont($samespace);
        $adverbs := nqp::decont($adverbs);
        $pattern := nqp::decont($pattern);
        $infix := nqp::decont($infix);
        $replacement := nqp::decont($replacement);
#line 2434 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Substitution, '$!immutable',
            $immutable ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Substitution, '$!samespace',
            $samespace ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj.replace-adverbs($adverbs // List);
        nqp::bindattr($obj, RakuAST::Substitution, '$!pattern', $pattern);
        nqp::bindattr($obj, RakuAST::Substitution, '$!infix', $infix);
        nqp::bindattr($obj, RakuAST::Substitution, '$!replacement', $replacement);
        $obj
    
    });
    add-method(RakuAST::Substitution, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Substitution, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2447 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Var::Lexical.new('$_'),
            RakuAST::Var::Lexical.new('$/'),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Positional')),
        ])
    
    });
    add-method(RakuAST::Substitution, 'IMPL-IS-SUBST-MATCH-ADVERB', [RakuAST::Substitution, '', 0, 0, str, '$norm-adverb', 0, 0], anon sub IMPL-IS-SUBST-MATCH-ADVERB ($SELF_CONT, $norm-adverb!) {
        my $SELF := nqp::decont($SELF_CONT);
        $norm-adverb := nqp::decont($norm-adverb);
#line 2455 src/Raku/ast/code.rakumod
        
        my constant SUBST_OK := nqp::hash(
            'x', 1, 'g', 1, 'nth', 1,
            'ii', 1, 'ss', 1, 'mm', 1);
        $SELF.IMPL-IS-POSITION-ADVERB($norm-adverb) || nqp::existskey(SUBST_OK, $norm-adverb)
    
    });
    add-method(RakuAST::Substitution, 'PERFORM-CHECK', [RakuAST::Substitution, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 2462 src/Raku/ast/code.rakumod
        
        # Check adverbs
        for $SELF.IMPL-UNWRAP-LIST($SELF.adverbs) {
            my str $key := $_.key;
            my str $norm := $SELF.IMPL-NORMALIZE-ADVERB($key);
            if $SELF.IMPL-IS-COMPILATION-ADVERB($SELF.IMPL-SUBST-TO-MATCH-ADVERB($norm)) {
                # Compile-time adverbs must have a simple compile time value.
                unless nqp::isconcrete($_.simple-compile-time-quote-value()) {
                    $SELF.add-sorry:
                      $resolver.build-exception: 'X::Value::Dynamic',
                        what => "Adverb $key";
                }
            }
            elsif !$SELF.IMPL-IS-SUBST-MATCH-ADVERB($norm) {
                # Not applicable to the construct, so report.
                $SELF.add-sorry:
                  $resolver.build-exception: 'X::Syntax::Regex::Adverb',
                    adverb    => $key,
                    construct => nqp::getattr($SELF, RakuAST::Substitution, '$!immutable') ?? 'S' !! 's';
            }
        }

        # Thunk the replacement part.
        nqp::getattr($SELF, RakuAST::Substitution, '$!replacement').wrap-with-thunk: RakuAST::SubstitutionReplacementThunk.new:
            :infix(nqp::getattr($SELF, RakuAST::Substitution, '$!infix'));
        nqp::getattr($SELF, RakuAST::Substitution, '$!replacement').visit-thunks(-> $thunk { $thunk.ensure-begin-performed($resolver, $context) });
    
    });
    add-method(RakuAST::Substitution, 'IMPL-THUNKED-REGEX-QAST', [RakuAST::Substitution, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-THUNKED-REGEX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2490 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::Substitution, '$!pattern').IMPL-REGEX-TOP-LEVEL-QAST($context, $SELF.meta-object,
            $SELF.IMPL-ADVERBS-TO-COMPILATION-MODS())
    
    });
    add-method(RakuAST::Substitution, 'IMPL-QAST-DECL-CODE', [RakuAST::Substitution, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL-CODE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2495 src/Raku/ast/code.rakumod
        
        # Form the block itself and link it with the meta-object.
        my $block := $SELF.IMPL-QAST-FORM-BLOCK($context, :blocktype('declaration_static'));
        $SELF.IMPL-LINK-META-OBJECT($context, $block);
        $block
    
    });
    add-method(RakuAST::Substitution, 'IMPL-EXPR-QAST', [RakuAST::Substitution, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2502 src/Raku/ast/code.rakumod
        
        # Coerce the topic into a Str before we start (we need to do that for
        # applying the match results anyway, so may as well avoid a double
        # coercion in the call to .match also).
        my $lookups    := $SELF.get-implicit-lookups;
        my $topic      := $lookups.AT-POS(0);
        my $slash      := $lookups.AT-POS(1);
        my $Positional := $lookups.AT-POS(2);

        my $topic-str-var := QAST::Node.unique('subst_topic_str');
        my $result := $SELF.IMPL-SET-NODE(
            QAST::Stmts.new(
                QAST::Op.new:
                    :op('bind'),
                    QAST::Var.new( :decl('var'), :scope('local'), :name($topic-str-var) ),
                    QAST::Op.new:
                        :op('callmethod'), :name('Str'),
                        $topic.IMPL-TO-QAST($context) ), :key);

        # Compile the call to match the regex against the stringified topic,
        # binding it into a result variable. While emitting adverbs, take
        # note of those needed for the replacement also.
        my $regex-closure := $SELF.IMPL-CLOSURE-QAST($context);
        my $match-qast := QAST::Op.new:
            :op('callmethod'), :name('match'),
            QAST::Var.new( :scope('local'), :name($topic-str-var) ),
            $regex-closure;
        my $match-lookup := $slash.IMPL-TO-QAST($context);
        my int $samespace := nqp::getattr($SELF, RakuAST::Substitution, '$!samespace');
        my int $sigspace := $samespace;
        my int $samecase := 0;
        my int $samemark := 0;
        for $SELF.IMPL-UNWRAP-LIST($SELF.adverbs) {
            my str $norm := $SELF.IMPL-NORMALIZE-ADVERB($_.key);
            if $SELF.IMPL-IS-POSITION-ADVERB($norm) {
                # These need to be passed the end of the last match.
                $match-qast.push: QAST::Op.new:
                    :named($norm), :op<if>,
                    $match-lookup,
                    QAST::Op.new( :op<callmethod>, :name<to>, $match-lookup ),
                    QAST::IVal.new( :value(0) )
            }
            else {
                # Pass the value of the pair.
                my $arg := $_.value.IMPL-TO-QAST($context);
                $arg.named($_.key);
                $match-qast.push($arg);

                # Take note of interesting ones for the replacement.
                if $norm eq 'ii' {
                    $samecase := 1;
                }
                elsif $norm eq 'mm' {
                    $samemark := 1;
                }
                elsif $norm eq 'ss' {
                    $samespace := 1;
                    $sigspace := 1;
                }
                elsif $norm eq 's' {
                    $sigspace := 1;
                }
            }
        }
        my $match-result-var := QAST::Node.unique('subst_match');
        $result.push: QAST::Op.new:
            :op('bind'),
            QAST::Var.new( :decl('var'), :scope('local'), :name($match-result-var) ),
            $match-qast;

        # Assign the result to $/.
        $result.push: QAST::Op.new:
            :op('p6store'),
            $match-lookup,
            QAST::Var.new( :scope('local'), :name($match-result-var) );

        # Obtain the replacement part and build the call to apply it to
        # the matches.
        my $replacement-closure := nqp::getattr($SELF, RakuAST::Substitution, '$!replacement').IMPL-TO-QAST($context);
        my $apply-matches-meth := Str.HOW.find_private_method(Str, 'APPLY-MATCHES');
        my $apply-call := QAST::Op.new:
            :op('call'),
            QAST::WVal.new( :value($apply-matches-meth) ),
            QAST::Var.new( :scope('local'), :name($topic-str-var) ),
            QAST::Var.new( :scope('local'), :name($match-result-var) ),
            $replacement-closure,
            $match-lookup,                      # $/
            QAST::WVal.new( :value((Bool.WHO)<True>) ),     # Flag to update $/
            QAST::IVal.new( :value($sigspace) ),
            QAST::IVal.new( :value($samespace) ),
            QAST::IVal.new( :value($samecase) ),
            QAST::IVal.new( :value($samemark) );

        # We only want to apply matches if we really did match. The pre-RakuAST
        # compiler frontend explicitly checked if it got a Match object or a
        # non-empty List. However, those are both truthy, and all the non-match
        # cases would be falsey, so we can just emit a truth test.
        $result.push: QAST::Op.new:
            :op('if'),
            QAST::Var.new( :scope('local'), :name($match-result-var) ),
            # If we matched...
            nqp::getattr($SELF, RakuAST::Substitution, '$!immutable')
                # For the S/// form, we evaluate to the result of the call to
                # APPLY-MATCHES
                ?? $apply-call
                # For the s/// form, we assign the result of APPLY-MATCHES
                # into the topic, and evaluate to the match result.
                !! QAST::Stmts.new(
                    QAST::Op.new(
                        :op('assign'),
                        $lookups.AT-POS(0).IMPL-TO-QAST($context),
                        $apply-call
                    ),
                    # If we have a list of matches, then put them into $/,
                    # otherwise, $/ already has the Match object we want it to have.
                    # Not entirely sure, why we need to do this. Guess $/ gets
                    # clobbered by the APPLY-MATCHES call.
                    QAST::Op.new( :op('p6store'),
                        $match-lookup,
                        QAST::Var.new( :name($match-result-var), :scope('local') ),
                    ),
                    QAST::Var.new( :scope('local'), :name($match-result-var) )
                ),
            # If we didn't match...
            nqp::getattr($SELF, RakuAST::Substitution, '$!immutable')
                # For the S/// form, evaluate to topic Str
                ?? QAST::Var.new( :scope('local'), :name($topic-str-var) )
                # For the s/// form, evaluate to the match variable
                !! $match-lookup;

        $result
    
    });
    add-method(RakuAST::Substitution, 'visit-children', [RakuAST::Substitution, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2635 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-VISIT-ADVERBS($visitor);
        $visitor(nqp::getattr($SELF, RakuAST::Substitution, '$!pattern'));
        $visitor(nqp::getattr($SELF, RakuAST::Substitution, '$!infix')) if nqp::getattr($SELF, RakuAST::Substitution, '$!infix');
        $visitor(nqp::getattr($SELF, RakuAST::Substitution, '$!replacement'));
    
    });
#line 2427 src/Raku/ast/code.rakumod
    add-method(RakuAST::Substitution, 'samespace', [], anon sub samespace ($self) { nqp::getattr(nqp::decont($self), RakuAST::Substitution, '$!samespace') });
#line 2430 src/Raku/ast/code.rakumod
    add-method(RakuAST::Substitution, 'replacement', [], anon sub replacement ($self) { nqp::getattr(nqp::decont($self), RakuAST::Substitution, '$!replacement') });
#line 2428 src/Raku/ast/code.rakumod
    add-method(RakuAST::Substitution, 'pattern', [], anon sub pattern ($self) { nqp::getattr(nqp::decont($self), RakuAST::Substitution, '$!pattern') });
#line 2429 src/Raku/ast/code.rakumod
    add-method(RakuAST::Substitution, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::Substitution, '$!infix') });
#line 2426 src/Raku/ast/code.rakumod
    add-method(RakuAST::Substitution, 'immutable', [], anon sub immutable ($self) { nqp::getattr(nqp::decont($self), RakuAST::Substitution, '$!immutable') });
    compose(RakuAST::Substitution);
    parent(RakuAST::SubstitutionReplacementThunk, RakuAST::ExpressionThunk);
    add-attribute(RakuAST::SubstitutionReplacementThunk, RakuAST::Infixish, '$!infix');
    add-method(RakuAST::SubstitutionReplacementThunk, 'new', [RakuAST::SubstitutionReplacementThunk, '', 0, 0, RakuAST::Infixish, '$infix', 1, 1], anon sub new ($SELF_CONT, :$infix?) {
        my $SELF := nqp::decont($SELF_CONT);
        $infix := nqp::decont($infix);
#line 2649 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::SubstitutionReplacementThunk, '$!infix', $infix);
        $obj
    
    });
    add-method(RakuAST::SubstitutionReplacementThunk, 'IMPL-THUNK-TWEAK-EXPRESSION', [RakuAST::SubstitutionReplacementThunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$qast', 0, 0], anon sub IMPL-THUNK-TWEAK-EXPRESSION ($SELF_CONT, $context!, $qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $qast := nqp::decont($qast);
#line 2655 src/Raku/ast/code.rakumod
        
        # We only need to really do the assignment if it's not a plain `=`;
        # if it's just that, we can avoid that work.
        if nqp::getattr($SELF, RakuAST::SubstitutionReplacementThunk, '$!infix') && !(nqp::istype(nqp::getattr($SELF, RakuAST::SubstitutionReplacementThunk, '$!infix'), RakuAST::Infix) && nqp::getattr($SELF, RakuAST::SubstitutionReplacementThunk, '$!infix').operator eq '=') {
            my $temp-var := QAST::Op.new:
                :op('p6assign'),
                QAST::Op.new( :op('p6scalarfromdesc'), QAST::Op.new( :op('null') ) ),
                QAST::Var.new( :name('$/'), :scope('lexical') );
            nqp::getattr($SELF, RakuAST::SubstitutionReplacementThunk, '$!infix').IMPL-INFIX-QAST($context, $temp-var, $qast)
        }
        else {
            $qast
        }
    
    });
    add-method(RakuAST::SubstitutionReplacementThunk, 'visit-children', [RakuAST::SubstitutionReplacementThunk, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2670 src/Raku/ast/code.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::SubstitutionReplacementThunk, '$!infix')) if nqp::getattr($SELF, RakuAST::SubstitutionReplacementThunk, '$!infix');
    
    });
#line 2647 src/Raku/ast/code.rakumod
    add-method(RakuAST::SubstitutionReplacementThunk, 'infix', [], anon sub infix ($self) { nqp::getattr(nqp::decont($self), RakuAST::SubstitutionReplacementThunk, '$!infix') });
    compose(RakuAST::SubstitutionReplacementThunk);
    parent(RakuAST::CurryThunk, RakuAST::ExpressionThunk);
    parent(RakuAST::CurryThunk, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::CurryThunk, Mu, '$!parameters');
    add-attribute(RakuAST::CurryThunk, Str, '$!original-expression');
    add-method(RakuAST::CurryThunk, 'new', [RakuAST::CurryThunk, '', 0, 0, Str, '$original-expression', 0, 0], anon sub new ($SELF_CONT, $original-expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $original-expression := nqp::decont($original-expression);
#line 2683 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::CurryThunk, '$!parameters', []);
        nqp::bindattr($obj, RakuAST::CurryThunk, '$!original-expression', $original-expression);
        $obj
    
    });
    add-method(RakuAST::CurryThunk, 'thunk-kind', [RakuAST::CurryThunk, '', 0, 0], anon sub thunk-kind ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2690 src/Raku/ast/code.rakumod
        
        'WhateverCode'
    
    });
    add-method(RakuAST::CurryThunk, 'thunk-details', [RakuAST::CurryThunk, '', 0, 0], anon sub thunk-details ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2694 src/Raku/ast/code.rakumod
        
        '⋐' ~ nqp::x('🔆', $SELF.IMPL-NUM-PARAMS)  ~ '⋑'
    
    });
    add-method(RakuAST::CurryThunk, 'IMPL-THUNK-OBJECT-TYPE', [RakuAST::CurryThunk, '', 0, 0], anon sub IMPL-THUNK-OBJECT-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2698 src/Raku/ast/code.rakumod
        
        $SELF.get-implicit-lookups.AT-POS(0).compile-time-value
    
    });
    add-method(RakuAST::CurryThunk, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::CurryThunk, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2702 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('WhateverCode'))
        ])
    
    });
    add-method(RakuAST::CurryThunk, 'IMPL-ADD-PARAM', [RakuAST::CurryThunk, '', 0, 0, Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$name', 1, 1], anon sub IMPL-ADD-PARAM ($SELF_CONT, $resolver!, $context!, :$name?) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
        $name := nqp::decont($name);
#line 2708 src/Raku/ast/code.rakumod
        
        my $param := RakuAST::Parameter.new(
            # $name will usually be undefined, but sometimes we re-use references to existing * targets
            target => RakuAST::ParameterTarget::Whatever.new($name)
        );
        nqp::push(nqp::getattr($SELF, RakuAST::CurryThunk, '$!parameters'), $param);
        $SELF.IMPL-UPDATE-SIGNATURE;
        $SELF.IMPL-CHECK($resolver, $context, (Bool.WHO)<True>);
        $param
    
    });
    add-method(RakuAST::CurryThunk, 'IMPL-NUM-PARAMS', [RakuAST::CurryThunk, '', 0, 0], anon sub IMPL-NUM-PARAMS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2719 src/Raku/ast/code.rakumod
        
        nqp::elems(nqp::getattr($SELF, RakuAST::CurryThunk, '$!parameters'))
    
    });
    add-method(RakuAST::CurryThunk, 'IMPL-PARAMS', [RakuAST::CurryThunk, '', 0, 0], anon sub IMPL-PARAMS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2723 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::CurryThunk, '$!parameters')
    
    });
    add-method(RakuAST::CurryThunk, 'IMPL-LAST-PARAM', [RakuAST::CurryThunk, '', 0, 0], anon sub IMPL-LAST-PARAM ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2727 src/Raku/ast/code.rakumod
        
        nqp::getattr($SELF, RakuAST::CurryThunk, '$!parameters')[nqp::elems(nqp::getattr($SELF, RakuAST::CurryThunk, '$!parameters')) - 1]
    
    });
    add-method(RakuAST::CurryThunk, 'IMPL-THUNK-SIGNATURE', [RakuAST::CurryThunk, '', 0, 0], anon sub IMPL-THUNK-SIGNATURE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2731 src/Raku/ast/code.rakumod
        
        RakuAST::Signature.new(parameters => $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::CurryThunk, '$!parameters')))
    
    });
    add-method(RakuAST::CurryThunk, 'IMPL-THUNK-META-OBJECT-PRODUCED', [RakuAST::CurryThunk, '', 0, 0, Mu, '$code', 0, 0], anon sub IMPL-THUNK-META-OBJECT-PRODUCED ($SELF_CONT, $code!) {
        my $SELF := nqp::decont($SELF_CONT);
        $code := nqp::decont($code);
#line 2735 src/Raku/ast/code.rakumod
        
        nqp::bindattr($code, $SELF.get-implicit-lookups.AT-POS(0).compile-time-value, '$!original-expression', nqp::getattr($SELF, RakuAST::CurryThunk, '$!original-expression'))
    
    });
    compose(RakuAST::CurryThunk);
    parent(RakuAST::BlockThunk, RakuAST::ExpressionThunk);
    parent(RakuAST::BlockThunk, RakuAST::ImplicitDeclarations);
    add-attribute(RakuAST::BlockThunk, RakuAST::Expression, '$!expression');
    add-method(RakuAST::BlockThunk, 'new', [RakuAST::BlockThunk, '', 0, 0, RakuAST::Expression, '$expression', 1, 1], anon sub new ($SELF_CONT, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 2746 src/Raku/ast/code.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::BlockThunk, '$!expression', $expression) if $expression;
        $obj
    
    });
    add-method(RakuAST::BlockThunk, 'thunk-kind', [RakuAST::BlockThunk, '', 0, 0], anon sub thunk-kind ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2752 src/Raku/ast/code.rakumod
        
        'Block thunk'
    
    });
    add-method(RakuAST::BlockThunk, 'thunk-details', [RakuAST::BlockThunk, '', 0, 0], anon sub thunk-details ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2756 src/Raku/ast/code.rakumod
        
        ''
    
    });
    add-method(RakuAST::BlockThunk, 'PRODUCE-IMPLICIT-DECLARATIONS', [RakuAST::BlockThunk, '', 0, 0], anon sub PRODUCE-IMPLICIT-DECLARATIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2760 src/Raku/ast/code.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::VarDeclaration::Implicit::BlockTopic.new:
                parameter => $SELF.signature ?? (Bool.WHO)<False> !! (Bool.WHO)<True>
        ]);
    
    });
    add-method(RakuAST::BlockThunk, 'IMPL-THUNK-OBJECT-TYPE', [RakuAST::BlockThunk, '', 0, 0], anon sub IMPL-THUNK-OBJECT-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2767 src/Raku/ast/code.rakumod
        
        Block
    
    });
    add-method(RakuAST::BlockThunk, 'IMPL-QAST-DECL-CODE', [RakuAST::BlockThunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL-CODE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 2771 src/Raku/ast/code.rakumod
        
        # Form the block itself and link it with the meta-object.
        $SELF.IMPL-QAST-BLOCK($context, :blocktype('declaration_static'), :expression(nqp::getattr($SELF, RakuAST::BlockThunk, '$!expression')));
    
    });
    add-method(RakuAST::BlockThunk, 'PRODUCE-META-OBJECT', [RakuAST::BlockThunk, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2776 src/Raku/ast/code.rakumod
        
        my $code := nqp::create($SELF.IMPL-THUNK-OBJECT-TYPE);
        my $param := nqp::create(Parameter);
        nqp::bindattr_s($param, Parameter, '$!variable_name', '$_');
        nqp::bindattr_i($param, Parameter, '$!flags', 2048 + 16384); # Optional + default from outer
        my $sig := nqp::create(Signature);
        nqp::bindattr($sig, Signature, '@!params', [$param]);
        nqp::bindattr_i($sig, Signature, '$!arity', 0);
        nqp::bindattr($sig, Signature, '$!count', nqp::box_i(1, Int));
        nqp::bindattr($code, Code, '$!signature', $sig);
        nqp::bindattr($sig, Signature, '$!code', $code);
        $SELF.IMPL-THUNK-META-OBJECT-PRODUCED($code);
        $code
    
    });
    compose(RakuAST::BlockThunk);
    parent(RakuAST::CompUnit, RakuAST::LexicalScope);
    parent(RakuAST::CompUnit, RakuAST::SinkBoundary);
    parent(RakuAST::CompUnit, RakuAST::ImplicitLookups);
    parent(RakuAST::CompUnit, RakuAST::ImplicitDeclarations);
    parent(RakuAST::CompUnit, RakuAST::AttachTarget);
    parent(RakuAST::CompUnit, RakuAST::ScopePhaser);
    add-attribute(RakuAST::CompUnit, RakuAST::StatementList, '$!statement-list');
    add-attribute(RakuAST::CompUnit, RakuAST::Block, '$!mainline');
    add-attribute(RakuAST::CompUnit, Str, '$!comp-unit-name');
    add-attribute(RakuAST::CompUnit, Str, '$!setting-name');
    add-attribute(RakuAST::CompUnit, Mu, '$!language-revision');
    add-attribute(RakuAST::CompUnit, Mu, '$!sc');
    add-attribute(RakuAST::CompUnit, int, '$!is-sunk');
    add-attribute(RakuAST::CompUnit, int, '$!is-eval');
    add-attribute(RakuAST::CompUnit, Mu, '$!global-package-how');
    add-attribute(RakuAST::CompUnit, Mu, '$!init-phasers');
    add-attribute(RakuAST::CompUnit, Mu, '$!end-phasers');
    add-attribute(RakuAST::CompUnit, RakuAST::VarDeclaration::Implicit::Doc::Pod, '$!pod');
    add-attribute(RakuAST::CompUnit, RakuAST::VarDeclaration::Implicit::Doc::Data, '$!data');
    add-attribute(RakuAST::CompUnit, RakuAST::VarDeclaration::Implicit::Doc::Finish, '$!finish');
    add-attribute(RakuAST::CompUnit, RakuAST::VarDeclaration::Implicit::Doc::Rakudoc, '$!rakudoc');
    add-attribute(RakuAST::CompUnit, Mu, '$!pod-content');
    add-attribute(RakuAST::CompUnit, Mu, '$!data-content');
    add-attribute(RakuAST::CompUnit, Mu, '$!finish-content');
    add-attribute(RakuAST::CompUnit, Mu, '$!singleton-whatever');
    add-attribute(RakuAST::CompUnit, Mu, '$!singleton-hyper-whatever');
    add-attribute(RakuAST::CompUnit, int, '$!precompilation-mode');
    add-attribute(RakuAST::CompUnit, Mu, '$!export-package');
    add-attribute(RakuAST::CompUnit, Mu, '$!herestub-queue');
    add-attribute(RakuAST::CompUnit, RakuAST::IMPL::QASTContext, '$!context');
    add-method(RakuAST::CompUnit, 'new', [RakuAST::CompUnit, '', 0, 0, Str, '$comp-unit-name', 1, 0, Str, '$setting-name', 1, 1, Bool, '$eval', 1, 1, Mu, '$global-package-how', 1, 1, int, '$language-revision', 1, 1, Bool, '$precompilation-mode', 1, 1, Mu, '$export-package', 1, 1, RakuAST::StatementList, '$statement-list', 1, 1, RakuAST::CompUnit, '$outer-cu', 1, 1], anon sub new ($SELF_CONT, :$comp-unit-name!, :$setting-name?, :$eval?, :$global-package-how?, :$language-revision?, :$precompilation-mode?, :$export-package?, :$statement-list?, :$outer-cu?) {
        my $SELF := nqp::decont($SELF_CONT);
        $comp-unit-name := nqp::decont($comp-unit-name);
        $setting-name := nqp::decont($setting-name);
        $eval := nqp::decont($eval);
        $global-package-how := nqp::decont($global-package-how);
        $language-revision := nqp::decont($language-revision);
        $precompilation-mode := nqp::decont($precompilation-mode);
        $export-package := nqp::decont($export-package);
        $statement-list := nqp::decont($statement-list);
        $outer-cu := nqp::decont($outer-cu);
#line 44 src/Raku/ast/compunit.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!statement-list',
            $statement-list // RakuAST::StatementList.new);

        my $mainline := RakuAST::Block.new();
        $mainline.set-implicit-topic(0);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!mainline', $mainline);

        nqp::bindattr($obj, RakuAST::CompUnit, '$!comp-unit-name',
          $comp-unit-name);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!setting-name',
          $setting-name // Str);
        nqp::bindattr_i($obj, RakuAST::CompUnit, '$!is-eval',
          $eval ?? $outer-cu ?? 2 !! 1 !! 0);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!global-package-how',
          $global-package-how =:= NQPMu
            ?? Perl6::Metamodel::PackageHOW
            !! $global-package-how
        );
        nqp::bindattr($obj, RakuAST::CompUnit, '$!export-package',
          $export-package =:= NQPMu ?? Mu !! $export-package);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!init-phasers', []);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!end-phasers', []);

        nqp::bindattr_i($obj, RakuAST::CompUnit, '$!precompilation-mode',
          $precompilation-mode ?? 1 !! 0);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!pod-content', Array.new);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!data-content', nqp::null);
        nqp::bindattr($obj, RakuAST::CompUnit, '$!herestub-queue', []);

        # If CompUnit's language revision is not set explicitly then guess it
        nqp::bindattr($obj, RakuAST::CompUnit, '$!language-revision',
          $language-revision
            ?? Perl6::Metamodel::Configuration.language_revision_object($language-revision)
            !! nqp::isconcrete(
                 my $setting-rev := nqp::getlexrelcaller(
                   nqp::ctxcallerskipthunks(nqp::ctx()), 'CORE-SETTING-REV'
                 )
               ) ?? $setting-rev
                 !! Perl6::Metamodel::Configuration.language_revision_object(
                      nqp::getcomp("Raku").language_revision)
                    );

        my $sc;
        if $outer-cu {
            my $context             := $outer-cu.context.create-nested;
            $sc                     := $context.sc;
            my $precompilation-mode := $outer-cu.precompilation-mode;

            nqp::bindattr($obj, RakuAST::CompUnit, '$!sc', $sc);
            nqp::bindattr($obj, RakuAST::CompUnit, '$!context', $context);
            nqp::bindattr_i($obj, RakuAST::CompUnit, '$!precompilation-mode',
              $precompilation-mode);
        }
        else {
            $sc := nqp::createsc($comp-unit-name);
            nqp::pushcompsc($sc);
            nqp::bindattr($obj, RakuAST::CompUnit, '$!sc', $sc);
            nqp::bindattr($obj, RakuAST::CompUnit, '$!context',
              RakuAST::IMPL::QASTContext.new(:$sc, :$precompilation-mode));
            nqp::bindattr($obj, RakuAST::CompUnit, '$!pod',
              RakuAST::VarDeclaration::Implicit::Doc::Pod.new);
            nqp::bindattr($obj, RakuAST::CompUnit, '$!data',
              RakuAST::VarDeclaration::Implicit::Doc::Data.new);
            nqp::bindattr($obj, RakuAST::CompUnit, '$!finish',
              RakuAST::VarDeclaration::Implicit::Doc::Finish.new);
            nqp::bindattr($obj, RakuAST::CompUnit, '$!rakudoc',
              RakuAST::VarDeclaration::Implicit::Doc::Rakudoc.new);
        }

        my $file := nqp::getlexdyn('$?FILES');
        nqp::scsetdesc($sc, $file) unless nqp::isnull($file);

        $obj
    
    });
    add-method(RakuAST::CompUnit, 'check', [RakuAST::CompUnit, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub check ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 125 src/Raku/ast/compunit.rakumod
        
        if @*LEADING-DOC {
            $resolver.add-worry:
              $resolver.build-exception:
                'X::Syntax::Doc::Declarator::MissingDeclarand',
                :position<leading>;
        }

        nqp::getattr($SELF, RakuAST::CompUnit, '$!mainline').IMPL-CHECK($resolver, nqp::getattr($SELF, RakuAST::CompUnit, '$!context'), (Bool.WHO)<False>);
        $SELF.IMPL-CHECK($resolver, nqp::getattr($SELF, RakuAST::CompUnit, '$!context'), (Bool.WHO)<False>);

        # Not all RakuAST::Doc objects actually have their PERFORM-CHECK
        # method called on them, causing holes to occur in $=pod (albeit
        # that the blocks that *are* generated, are in the correct order).
        # So run over the array and filter out any undefined elements.
        my int $elems := nqp::getattr($SELF, RakuAST::CompUnit, '$!pod-content').elems;
        my int $i     := $elems;
        my $pod := nqp::getattr($SELF, RakuAST::CompUnit, '$!pod-content');
        while --$i >= 0 {
            $pod.splice($i,1) unless $pod.EXISTS-POS($i);
        }
    
    });
    add-method(RakuAST::CompUnit, 'add-INIT-phaser-for-doc-handling', [RakuAST::CompUnit, '', 0, 0, Any, '$base', 0, 0, Any, '$type', 0, 0], anon sub add-INIT-phaser-for-doc-handling ($SELF_CONT, $base!, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $base := nqp::decont($base);
        $type := nqp::decont($type);
#line 154 src/Raku/ast/compunit.rakumod
        

        # Determine which module to load.  If single element type, then it
        # is $base::To::$type.  If multi-element, those are the name parts
        # to use.
        my @parts := nqp::split('::',$type);
        if nqp::elems(@parts) == 1 {
            nqp::unshift(@parts,'To');
            nqp::unshift(@parts,$base);
        }

        my $name := RakuAST::Name.from-identifier-parts(|@parts);
        nqp::getattr($SELF, RakuAST::CompUnit, '$!statement-list').add-statement: RakuAST::Statement::Expression.new(
          expression => RakuAST::StatementPrefix::Phaser::Init.new(
            RakuAST::Block.new(
              body => RakuAST::Blockoid.new(
                RakuAST::StatementList.new(
                  RakuAST::Statement::Use.new(module-name => $name),
                  RakuAST::Statement::Expression.new(
                    expression => RakuAST::Call::Name.new(
                      name => RakuAST::Name.from-identifier("say"),
                      args => RakuAST::ArgList.new(
                        RakuAST::ApplyPostfix.new(
                          operand => RakuAST::Type::Simple.new($name),
                          postfix => RakuAST::Call::Method.new(
                            name => RakuAST::Name.from-identifier("render"),
                            args => RakuAST::ArgList.new(
                              RakuAST::Var::Doc.new(
                                $base eq 'Pod' ?? "pod" !! "rakudoc"
                              )
                            )
                          )
                        )
                      )
                    )
                  ),
                  RakuAST::Statement::Expression.new(
                    expression => RakuAST::Call::Name.new(
                      name => RakuAST::Name.from-identifier("exit")
                    )
                  )
                )
              )
            )
          )
        )
    
    });
    add-method(RakuAST::CompUnit, 'replace-statement-list', [RakuAST::CompUnit, '', 0, 0, RakuAST::StatementList, '$statement-list', 0, 0], anon sub replace-statement-list ($SELF_CONT, $statement-list!) {
        my $SELF := nqp::decont($SELF_CONT);
        $statement-list := nqp::decont($statement-list);
#line 203 src/Raku/ast/compunit.rakumod
        
        nqp::bindattr($SELF, RakuAST::CompUnit, '$!statement-list', $statement-list);
        Nil
    
    });
    add-method(RakuAST::CompUnit, 'replace-finish-content', [RakuAST::CompUnit, '', 0, 0, Mu, '$finish-content', 0, 0], anon sub replace-finish-content ($SELF_CONT, $finish-content!) {
        my $SELF := nqp::decont($SELF_CONT);
        $finish-content := nqp::decont($finish-content);
#line 209 src/Raku/ast/compunit.rakumod
        
        nqp::bindattr($SELF, RakuAST::CompUnit, '$!finish-content',
          nqp::hllizefor($finish-content, 'Raku'));
        Nil
    
    });
    add-method(RakuAST::CompUnit, 'mark-sunk', [RakuAST::CompUnit, '', 0, 0], anon sub mark-sunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 217 src/Raku/ast/compunit.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::CompUnit, '$!is-sunk', 1);
        Nil
    
    });
    add-method(RakuAST::CompUnit, 'is-boundary-sunk', [RakuAST::CompUnit, '', 0, 0], anon sub is-boundary-sunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 222 src/Raku/ast/compunit.rakumod
         nqp::getattr_i($SELF, RakuAST::CompUnit, '$!is-sunk') ?? (Bool.WHO)<True> !! (Bool.WHO)<False> 
    });
    add-method(RakuAST::CompUnit, 'get-boundary-sink-propagator', [RakuAST::CompUnit, '', 0, 0], anon sub get-boundary-sink-propagator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 224 src/Raku/ast/compunit.rakumod
         nqp::getattr($SELF, RakuAST::CompUnit, '$!statement-list') 
    });
    add-method(RakuAST::CompUnit, 'is-eval', [RakuAST::CompUnit, '', 0, 0], anon sub is-eval ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 228 src/Raku/ast/compunit.rakumod
         nqp::getattr_i($SELF, RakuAST::CompUnit, '$!is-eval') ?? (Bool.WHO)<True> !! (Bool.WHO)<False> 
    });
    add-method(RakuAST::CompUnit, 'attach-target-names', [RakuAST::CompUnit, '', 0, 0], anon sub attach-target-names ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 230 src/Raku/ast/compunit.rakumod
        
        $SELF.IMPL-WRAP-LIST(['compunit'])
    
    });
    add-method(RakuAST::CompUnit, 'clear-attachments', [RakuAST::CompUnit, '', 0, 0], anon sub clear-attachments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 234 src/Raku/ast/compunit.rakumod
        
        nqp::setelems(nqp::getattr($SELF, RakuAST::CompUnit, '$!init-phasers'), 0);
        nqp::setelems(nqp::getattr($SELF, RakuAST::CompUnit, '$!end-phasers'), 0);
        $SELF.clear-handler-attachments();
        Nil
    
    });
    add-method(RakuAST::CompUnit, 'set-pod-content', [RakuAST::CompUnit, '', 0, 0, int, '$i', 0, 0, Any, '$pod', 0, 0], anon sub set-pod-content ($SELF_CONT, $i!, $pod!) {
        my $SELF := nqp::decont($SELF_CONT);
        $i := nqp::decont($i);
        $pod := nqp::decont($pod);
#line 242 src/Raku/ast/compunit.rakumod
        

        $i == -1
             # don't know where to set, so just push
          ?? nqp::getattr($SELF, RakuAST::CompUnit, '$!pod-content').push($pod)
             # set in assigned position
          !! nqp::getattr($SELF, RakuAST::CompUnit, '$!pod-content').ASSIGN-POS($i,$pod);
    
    });
    add-method(RakuAST::CompUnit, 'data-content', [RakuAST::CompUnit, '', 0, 0], anon sub data-content ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 252 src/Raku/ast/compunit.rakumod
        
        nqp::ifnull(
          nqp::getattr($SELF, RakuAST::CompUnit, '$!data-content'),
          nqp::bindattr($SELF,RakuAST::CompUnit,'$!data-content',
            RakuAST::Doc::Block.Hashray
          )
        )
    
    });
    add-method(RakuAST::CompUnit, 'add-phaser', [RakuAST::CompUnit, '', 0, 0, Any, '$phasers', 0, 0, Any, '$phaser', 0, 0], anon sub add-phaser ($SELF_CONT, $phasers!, $phaser!) {
        my $SELF := nqp::decont($SELF_CONT);
        $phasers := nqp::decont($phasers);
        $phaser := nqp::decont($phaser);
#line 262 src/Raku/ast/compunit.rakumod
        
        # Cannot rely on clear-attachments here as a node's attach can be
        # called multiple times while going up and down the tree and
        # clear-attachments will only be called once.
        for $phasers {
            return Nil if nqp::eqaddr($_,$phaser);  # already added
        }
        nqp::push($phasers, $phaser);
        Nil
    
    });
    add-method(RakuAST::CompUnit, 'add-init-phaser', [RakuAST::CompUnit, '', 0, 0, RakuAST::StatementPrefix::Phaser::Init, '$phaser', 0, 0], anon sub add-init-phaser ($SELF_CONT, $phaser!) {
        my $SELF := nqp::decont($SELF_CONT);
        $phaser := nqp::decont($phaser);
#line 273 src/Raku/ast/compunit.rakumod
        
        $SELF.add-phaser(nqp::getattr($SELF, RakuAST::CompUnit, '$!init-phasers'), $phaser);
    
    });
    add-method(RakuAST::CompUnit, 'add-end-phaser', [RakuAST::CompUnit, '', 0, 0, RakuAST::StatementPrefix::Phaser::End, '$phaser', 0, 0], anon sub add-end-phaser ($SELF_CONT, $phaser!) {
        my $SELF := nqp::decont($SELF_CONT);
        $phaser := nqp::decont($phaser);
#line 277 src/Raku/ast/compunit.rakumod
        
        $SELF.add-phaser(nqp::getattr($SELF, RakuAST::CompUnit, '$!end-phasers'), $phaser);
    
    });
    add-method(RakuAST::CompUnit, 'queue-heredoc', [RakuAST::CompUnit, '', 0, 0, Any, '$herestub', 0, 0], anon sub queue-heredoc ($SELF_CONT, $herestub!) {
        my $SELF := nqp::decont($SELF_CONT);
        $herestub := nqp::decont($herestub);
#line 281 src/Raku/ast/compunit.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::CompUnit, '$!herestub-queue'), $herestub);
    
    });
    add-method(RakuAST::CompUnit, 'ensure-singleton-whatever', [RakuAST::CompUnit, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub ensure-singleton-whatever ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 285 src/Raku/ast/compunit.rakumod
        
        unless nqp::isconcrete(nqp::getattr($SELF, RakuAST::CompUnit, '$!singleton-whatever')) {
            nqp::bindattr($SELF,RakuAST::CompUnit,'$!singleton-whatever',
              nqp::create($resolver.setting-constant('Whatever'))
            );
        }
        Nil
    
    });
    add-method(RakuAST::CompUnit, 'singleton-whatever', [RakuAST::CompUnit, '', 0, 0], anon sub singleton-whatever ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 294 src/Raku/ast/compunit.rakumod
         nqp::getattr($SELF, RakuAST::CompUnit, '$!singleton-whatever') 
    });
    add-method(RakuAST::CompUnit, 'ensure-singleton-hyper-whatever', [RakuAST::CompUnit, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub ensure-singleton-hyper-whatever ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 296 src/Raku/ast/compunit.rakumod
        
        unless nqp::isconcrete(nqp::getattr($SELF, RakuAST::CompUnit, '$!singleton-hyper-whatever')) {
            nqp::bindattr($SELF,RakuAST::CompUnit,'$!singleton-hyper-whatever',
              nqp::create($resolver.setting-constant('HyperWhatever'))
            );
        }
        Nil
    
    });
    add-method(RakuAST::CompUnit, 'singleton-hyper-whatever', [RakuAST::CompUnit, '', 0, 0], anon sub singleton-hyper-whatever ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 305 src/Raku/ast/compunit.rakumod
         nqp::getattr($SELF, RakuAST::CompUnit, '$!singleton-hyper-whatever') 
    });
    add-method(RakuAST::CompUnit, 'cleanup', [RakuAST::CompUnit, '', 0, 0], anon sub cleanup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 307 src/Raku/ast/compunit.rakumod
        
        for nqp::getattr($SELF, RakuAST::CompUnit, '$!context').cleanup-tasks {
            $_()
        }
    
    });
    add-method(RakuAST::CompUnit, 'record-precompilation-dependencies', [RakuAST::CompUnit, '', 0, 0], anon sub record-precompilation-dependencies ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 313 src/Raku/ast/compunit.rakumod
        
        nqp::getattr_i($SELF, RakuAST::CompUnit, '$!precompilation-mode') ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::CompUnit, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::CompUnit, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 317 src/Raku/ast/compunit.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier-parts(
                'CompUnit', 'RepositoryRegistry',
            ))
        ])
    
    });
    add-method(RakuAST::CompUnit, 'PRODUCE-IMPLICIT-DECLARATIONS', [RakuAST::CompUnit, '', 0, 0], anon sub PRODUCE-IMPLICIT-DECLARATIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 325 src/Raku/ast/compunit.rakumod
        
        my @decls;
        my sub add(Mu $add) { nqp::push(@decls,$add) }

        # If we're not in an EVAL, we should produce a GLOBAL package and set
        # it as the current package.
        unless nqp::getattr_i($SELF, RakuAST::CompUnit, '$!is-eval') {
            my $global := RakuAST::Package.new(
              how  => nqp::getattr($SELF, RakuAST::CompUnit, '$!global-package-how'),
              name => RakuAST::Name.from-identifier('GLOBAL')
            );

            add($global);
            add(RakuAST::VarDeclaration::Implicit::Constant.new(
              name => 'GLOBALish', value => $global.compile-time-value
            ));
            add(RakuAST::VarDeclaration::Implicit::Constant.new(
              name => 'EXPORT', value => nqp::getattr($SELF, RakuAST::CompUnit, '$!export-package')
            )) unless nqp::eqaddr(nqp::getattr($SELF, RakuAST::CompUnit, '$!export-package'),Mu);
            add(RakuAST::VarDeclaration::Implicit::Constant.new(
              name => '$?PACKAGE', value => $global.compile-time-value
            ));
            add(RakuAST::VarDeclaration::Implicit::Special.new(:name('$/')));
            add(RakuAST::VarDeclaration::Implicit::Special.new(:name('$!')));
            add(RakuAST::VarDeclaration::Implicit::Special.new(:name('$_')));
        }

        # Various markers
        add(RakuAST::VarDeclaration::Implicit::Constant.new(
          name => '!UNIT_MARKER', value => 1
        ));
        #TODO remove this when old frontend is gone
        add(RakuAST::VarDeclaration::Implicit::Constant.new(
            name => '!RAKUAST_MARKER', value => 1
        ));
        add(RakuAST::VarDeclaration::Implicit::Constant.new(
            name => '!EVAL_MARKER', value => 1
        )) if nqp::getattr_i($SELF, RakuAST::CompUnit, '$!is-eval');

        $SELF.IMPL-WRAP-LIST(@decls)
    
    });
    add-method(RakuAST::CompUnit, 'IMPL-TO-QAST-COMP-UNIT', [RakuAST::CompUnit, '', 0, 0, Any, '%options', 0, 0], anon sub IMPL-TO-QAST-COMP-UNIT ($SELF_CONT, *%options) {
        my $SELF := nqp::decont($SELF_CONT);
        %options := nqp::decont(%options);
#line 367 src/Raku/ast/compunit.rakumod
        
        # Create compilation context.
        my $context := nqp::getattr($SELF, RakuAST::CompUnit, '$!context');
        my $top-level :=
            $SELF.IMPL-SET-NODE:
                nqp::getattr($SELF, RakuAST::CompUnit, '$!mainline').IMPL-QAST-FORM-BLOCK($context, :blocktype<declaration_static>);
        $top-level.name('<unit>');
        $top-level.annotate('IN_DECL', nqp::getattr_i($SELF, RakuAST::CompUnit, '$!is-eval') ?? 'eval' !! 'mainline');
        my @pre-deserialize;
        nqp::push(@pre-deserialize, $SELF.IMPL-SETTING-LOADING-QAST($top-level, nqp::getattr($SELF, RakuAST::CompUnit, '$!setting-name')))
            if nqp::getattr($SELF, RakuAST::CompUnit, '$!setting-name');

        unless nqp::getattr_i($SELF, RakuAST::CompUnit, '$!is-eval') {
            my $global_install := QAST::Op.new(
                :op<ifnull>,
                QAST::Op.new(
                    :op<getcurhllsym>,
                    QAST::SVal.new(:value('GLOBAL'))
                ),
                QAST::Op.new(
                    :op('bindcurhllsym'),
                    QAST::SVal.new( :value('GLOBAL') ),
                    QAST::WVal.new( :value($SELF.generated-global) )
                )
            );
            $context.add-fixup-and-deserialize-task(QAST::Stmt.new($global_install));
        }

        # Compile into a QAST::CompUnit.
        $top-level.push($SELF.IMPL-TO-QAST($context));
        nqp::getattr($SELF, RakuAST::CompUnit, '$!mainline').IMPL-LINK-META-OBJECT($context, $top-level);
        $SELF.add-phasers-to-code-object(nqp::getattr($SELF, RakuAST::CompUnit, '$!mainline').meta-object);
        $SELF.add-phasers-handling-code($context, $top-level);

        if !nqp::getattr_i($SELF, RakuAST::CompUnit, '$!precompilation-mode')
            && !$*INSIDE-EVAL
            && +(@*MODULES // []) == 0
            && (my $main := $SELF.find-lexical('&MAIN'))
        {
            $top-level.set_children([QAST::Op.new(
              :op('call'),
              :name('&RUN-MAIN'),
              QAST::WVal.new(:value($main.meta-object)),
              QAST::Stmts.new(|$top-level.list) # run the mainline and get its result
            )]);
        }

        QAST::CompUnit.new:
            $top-level,
            :hll('Raku'),
            :sc(nqp::getattr($SELF, RakuAST::CompUnit, '$!sc')),
            :is_nested(nqp::getattr_i($SELF, RakuAST::CompUnit, '$!is-eval') == 2),
            :code_ref_blocks($context.code-ref-blocks),
            :compilation_mode(nqp::getattr_i($SELF, RakuAST::CompUnit, '$!precompilation-mode')),
            :pre_deserialize(@pre-deserialize),
            :post_deserialize($context.post-deserialize()),
            :repo_conflict_resolver(QAST::Op.new(
                :op('callmethod'), :name('resolve_repossession_conflicts'),
                $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context) )),
            # If this unit is loaded as a module, we want it to automatically
            # execute the mainline code above after all other initializations
            # have occurred.
            :load(QAST::Op.new(
                :op('call'),
                QAST::BVal.new( :value($top-level) ),
            )),
    
    });
    add-method(RakuAST::CompUnit, 'IMPL-SETTING-LOADING-QAST', [RakuAST::CompUnit, '', 0, 0, Mu, '$top-level', 0, 0, Str, '$name', 0, 0], anon sub IMPL-SETTING-LOADING-QAST ($SELF_CONT, $top-level!, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $top-level := nqp::decont($top-level);
        $name := nqp::decont($name);
#line 435 src/Raku/ast/compunit.rakumod
        
        # Use the NQP module loader to load Perl6::ModuleLoader, which
        # is a normal NQP module.
        my $module-loading := QAST::Stmt.new(
            QAST::Op.new(
                :op('loadbytecode'),
                QAST::VM.new(
                    :jvm(QAST::SVal.new( :value('ModuleLoader.class') )),
                    :moar(QAST::SVal.new( :value('ModuleLoader.moarvm') )),
                    :js(QAST::SVal.new( :value('ModuleLoader') ))
                )),
            QAST::Op.new(
                :op('callmethod'), :name('load_module'),
                QAST::Op.new(
                    :op('gethllsym'),
                    QAST::SVal.new( :value('nqp') ),
                    QAST::SVal.new( :value('ModuleLoader') )
                ),
                QAST::SVal.new( :value('Perl6::ModuleLoader') )
            ));

        # Load and put in place the setting after deserialization and on fixup.
        QAST::Stmt.new(
            $module-loading,
            QAST::Op.new(
                :op('forceouterctx'),
                QAST::BVal.new( :value($top-level) ),
                QAST::Op.new(
                    :op('callmethod'), :name('load_setting'),
                    QAST::Op.new(
                        :op('getcurhllsym'),
                        QAST::SVal.new( :value('ModuleLoader') )
                    ),
                    QAST::SVal.new( :value($name) )
                )
            ));
    
    });
    add-method(RakuAST::CompUnit, 'IMPL-TO-QAST', [RakuAST::CompUnit, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 473 src/Raku/ast/compunit.rakumod
        
        my $*CU := $SELF;
        $SELF.IMPL-SET-NODE:
            QAST::Stmts.new(
                QAST::Var.new( :name('__args__'), :scope('local'), :decl('param'), :slurpy(1) ),
                $SELF.IMPL-QAST-DECLS($context),
                $SELF.IMPL-QAST-INIT-PHASERS($context),
                $SELF.IMPL-QAST-END-PHASERS($context),
                $SELF.IMPL-QAST-CTXSAVE($context),
                $SELF.IMPL-WRAP-SCOPE-HANDLER-QAST($context, nqp::getattr($SELF, RakuAST::CompUnit, '$!statement-list').IMPL-TO-QAST($context)),
            )
    
    });
    add-method(RakuAST::CompUnit, 'IMPL-QAST-INIT-PHASERS', [RakuAST::CompUnit, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-INIT-PHASERS ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 486 src/Raku/ast/compunit.rakumod
        
        my $setup := QAST::Stmts.new;
        for nqp::getattr($SELF, RakuAST::CompUnit, '$!init-phasers') {
            my $container := $_.container;
            $context.ensure-sc($container);
            $setup.push(
                QAST::Op.new(
                    :op<bindattr>,
                    QAST::WVal.new( :value($container) ),
                    QAST::WVal.new( :value(Scalar) ),
                    QAST::SVal.new( :value('$!value') ),
                    $_.IMPL-CALLISH-QAST($context)
                )
            );
        }
        $setup
    
    });
    add-method(RakuAST::CompUnit, 'IMPL-QAST-END-PHASERS', [RakuAST::CompUnit, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-END-PHASERS ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 504 src/Raku/ast/compunit.rakumod
        
        my $end-setup := QAST::Stmts.new;
        for nqp::getattr($SELF, RakuAST::CompUnit, '$!end-phasers') {
            $end-setup.push(QAST::Op.new(
                :op('callmethod'), :name('unshift'),
                QAST::Op.new(
                    :op('getcurhllsym'),
                    QAST::SVal.new( :value('@END_PHASERS') ),
                ),
                QAST::WVal.new( :value($_.meta-object) )
            ));
        }
        $end-setup
    
    });
    add-method(RakuAST::CompUnit, 'IMPL-QAST-CTXSAVE', [RakuAST::CompUnit, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-CTXSAVE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 519 src/Raku/ast/compunit.rakumod
        
        QAST::Stmts.new(
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name('ctxsave'), :scope('local'), :decl('var') ),
                QAST::Var.new( :name('$*CTXSAVE'), :scope('contextual') )
            ),
            QAST::Op.new(
                :op('unless'),
                QAST::Op.new(
                    :op('isnull'),
                    QAST::Var.new( :name('ctxsave'), :scope('local') )
                ),
                QAST::Op.new(
                    :op('if'),
                    QAST::Op.new(
                        :op('can'),
                        QAST::Var.new( :name('ctxsave'), :scope('local') ),
                        QAST::SVal.new( :value('ctxsave') )
                    ),
                    QAST::Op.new(
                        :op('callmethod'), :name('ctxsave'),
                        QAST::Var.new( :name('ctxsave'), :scope('local')
                    )))))
    
    });
    add-method(RakuAST::CompUnit, 'generated-global', [RakuAST::CompUnit, '', 0, 0], anon sub generated-global ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 545 src/Raku/ast/compunit.rakumod
        
        nqp::die('No generated global in an EVAL-mode compilation unit') if nqp::getattr_i($SELF, RakuAST::CompUnit, '$!is-eval');
        $SELF.IMPL-UNWRAP-LIST($SELF.get-implicit-declarations)[0].compile-time-value
    
    });
    add-method(RakuAST::CompUnit, 'visit-children', [RakuAST::CompUnit, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 550 src/Raku/ast/compunit.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::CompUnit, '$!statement-list'));
        $visitor(nqp::getattr($SELF, RakuAST::CompUnit, '$!pod'))     if nqp::getattr($SELF, RakuAST::CompUnit, '$!pod');
        $visitor(nqp::getattr($SELF, RakuAST::CompUnit, '$!data'))    if nqp::getattr($SELF, RakuAST::CompUnit, '$!data');
        $visitor(nqp::getattr($SELF, RakuAST::CompUnit, '$!finish'))  if nqp::getattr($SELF, RakuAST::CompUnit, '$!finish');
        $visitor(nqp::getattr($SELF, RakuAST::CompUnit, '$!rakudoc')) if nqp::getattr($SELF, RakuAST::CompUnit, '$!rakudoc');
    
    });
#line 10 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'statement-list', [], anon sub statement-list ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!statement-list') });
#line 13 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'setting-name', [], anon sub setting-name ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!setting-name') });
#line 24 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'rakudoc', [], anon sub rakudoc ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!rakudoc') });
#line 30 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'precompilation-mode', [], anon sub precompilation-mode ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::CompUnit, '$!precompilation-mode') });
#line 25 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'pod-content', [], anon sub pod-content ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!pod-content') });
#line 21 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'pod', [], anon sub pod ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!pod') });
#line 11 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'mainline', [], anon sub mainline ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!mainline') });
#line 14 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'language-revision', [], anon sub language-revision ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!language-revision') });
#line 32 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'herestub-queue', [], anon sub herestub-queue ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!herestub-queue') });
#line 27 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'finish-content', [], anon sub finish-content ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!finish-content') });
#line 23 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'finish', [], anon sub finish ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!finish') });
#line 22 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'data', [], anon sub data ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!data') });
#line 33 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'context', [], anon sub context ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!context') });
#line 12 src/Raku/ast/compunit.rakumod
    add-method(RakuAST::CompUnit, 'comp-unit-name', [], anon sub comp-unit-name ($self) { nqp::getattr(nqp::decont($self), RakuAST::CompUnit, '$!comp-unit-name') });
    compose(RakuAST::CompUnit);
    parent(RakuAST::LiteralBuilder, Any);
    add-attribute(RakuAST::LiteralBuilder, RakuAST::Resolver, '$!resolver');
    add-attribute(RakuAST::LiteralBuilder, Mu, '$!cached-rat');
    add-attribute(RakuAST::LiteralBuilder, int, '$!has-cached-rat');
    add-attribute(RakuAST::LiteralBuilder, Mu, '$!cached-complex');
    add-attribute(RakuAST::LiteralBuilder, int, '$!has-cached-complex');
    add-method(RakuAST::LiteralBuilder, 'new', [RakuAST::LiteralBuilder, '', 0, 0, RakuAST::Resolver, '$resolver', 1, 1], anon sub new ($SELF_CONT, :$resolver?) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 567 src/Raku/ast/compunit.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::LiteralBuilder, '$!resolver', $resolver) if $resolver;
        $obj
    
    });
    add-method(RakuAST::LiteralBuilder, 'set-resolver', [RakuAST::LiteralBuilder, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub set-resolver ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 573 src/Raku/ast/compunit.rakumod
        
        nqp::bindattr($SELF, RakuAST::LiteralBuilder, '$!resolver', $resolver);
    
    });
    add-method(RakuAST::LiteralBuilder, 'intern-int', [RakuAST::LiteralBuilder, '', 0, 0, str, '$chars', 0, 0, int, '$base', 0, 1, Mu, '$error-reporter', 0, 1], anon sub intern-int ($SELF_CONT, $chars!, $base?, $error-reporter?) {
        my $SELF := nqp::decont($SELF_CONT);
        $chars := nqp::decont($chars);
        $base := nqp::decont($base);
        $error-reporter := nqp::decont($error-reporter);
#line 578 src/Raku/ast/compunit.rakumod
        
        # TODO interning
        $SELF.build-int($chars, $base // 10, $error-reporter)
    
    });
    add-method(RakuAST::LiteralBuilder, 'build-int', [RakuAST::LiteralBuilder, '', 0, 0, str, '$source', 0, 0, int, '$base', 0, 0, Mu, '$error-reporter', 0, 1], anon sub build-int ($SELF_CONT, $source!, $base!, $error-reporter?) {
        my $SELF := nqp::decont($SELF_CONT);
        $source := nqp::decont($source);
        $base := nqp::decont($base);
        $error-reporter := nqp::decont($error-reporter);
#line 584 src/Raku/ast/compunit.rakumod
        
        my $res := nqp::radix_I($base, $source, 0, 2, Int);
        unless nqp::iseq_i(nqp::unbox_i(nqp::atpos($res, 2)), nqp::chars($source)) {
            $error-reporter ??
                $error-reporter()
                !! nqp::die("'$source' is not a valid number");
        }
        nqp::atpos($res, 0)
    
    });
    add-method(RakuAST::LiteralBuilder, 'int-type', [RakuAST::LiteralBuilder, '', 0, 0], anon sub int-type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 595 src/Raku/ast/compunit.rakumod
         Int 
    });
    add-method(RakuAST::LiteralBuilder, 'intern-num', [RakuAST::LiteralBuilder, '', 0, 0, str, '$chars', 0, 0], anon sub intern-num ($SELF_CONT, $chars!) {
        my $SELF := nqp::decont($SELF_CONT);
        $chars := nqp::decont($chars);
#line 598 src/Raku/ast/compunit.rakumod
        
        # TODO interning
        $SELF.build-num($chars)
    
    });
    add-method(RakuAST::LiteralBuilder, 'build-num', [RakuAST::LiteralBuilder, '', 0, 0, str, '$chars', 0, 0], anon sub build-num ($SELF_CONT, $chars!) {
        my $SELF := nqp::decont($SELF_CONT);
        $chars := nqp::decont($chars);
#line 604 src/Raku/ast/compunit.rakumod
        
        nqp::box_n(nqp::numify($chars), Num)
    
    });
    add-method(RakuAST::LiteralBuilder, 'num-type', [RakuAST::LiteralBuilder, '', 0, 0], anon sub num-type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 609 src/Raku/ast/compunit.rakumod
         Num 
    });
    add-method(RakuAST::LiteralBuilder, 'intern-str', [RakuAST::LiteralBuilder, '', 0, 0, str, '$chars', 0, 0], anon sub intern-str ($SELF_CONT, $chars!) {
        my $SELF := nqp::decont($SELF_CONT);
        $chars := nqp::decont($chars);
#line 612 src/Raku/ast/compunit.rakumod
        
        # TODO interning
        $SELF.build-str($chars)
    
    });
    add-method(RakuAST::LiteralBuilder, 'build-str', [RakuAST::LiteralBuilder, '', 0, 0, str, '$chars', 0, 0], anon sub build-str ($SELF_CONT, $chars!) {
        my $SELF := nqp::decont($SELF_CONT);
        $chars := nqp::decont($chars);
#line 618 src/Raku/ast/compunit.rakumod
        
        nqp::box_s($chars, Str)
    
    });
    add-method(RakuAST::LiteralBuilder, 'intern-decimal', [RakuAST::LiteralBuilder, '', 0, 0, Any, '$whole-part', 0, 0, Any, '$fractional-part', 0, 0], anon sub intern-decimal ($SELF_CONT, $whole-part!, $fractional-part!) {
        my $SELF := nqp::decont($SELF_CONT);
        $whole-part := nqp::decont($whole-part);
        $fractional-part := nqp::decont($fractional-part);
#line 623 src/Raku/ast/compunit.rakumod
        
        # TODO interning
        $SELF.build-decimal($whole-part, $fractional-part)
    
    });
    add-method(RakuAST::LiteralBuilder, 'build-decimal', [RakuAST::LiteralBuilder, '', 0, 0, Mu, '$whole-part', 0, 0, Mu, '$fractional-part', 0, 0], anon sub build-decimal ($SELF_CONT, $whole-part!, $fractional-part!) {
        my $SELF := nqp::decont($SELF_CONT);
        $whole-part := nqp::decont($whole-part);
        $fractional-part := nqp::decont($fractional-part);
#line 629 src/Raku/ast/compunit.rakumod
        
        # Whole part may be provided as an Int already, or may be missing.
        my $parti;
        if nqp::isconcrete($whole-part) {
            if nqp::istype($whole-part, Int) {
                $parti := $whole-part;
            }
            else {
                $parti := $SELF.intern-int($whole-part);
            }
        }
        else {
            $parti := $SELF.intern-int('0');
        }

        # Now deal with the fractional part; this may also come as an Int
        # denominator.
        my $partf;
        if nqp::istype($fractional-part, Int) {
            $partf := $fractional-part;
        }
        elsif nqp::chars($fractional-part) {
            $partf := nqp::radix_I(10, $fractional-part, 0, 4, Int);
            my $base := nqp::pow_I(nqp::box_i(10, Int), $partf[1], Num, Int);
            $parti := nqp::mul_I($parti, $base, Int);
            $parti := nqp::add_I($parti, $partf[0], Int);
            $partf := $base;
        } else {
            $partf := $SELF.intern-int('1');
        }

        $SELF.build-rat($parti, $partf)
    
    });
    add-method(RakuAST::LiteralBuilder, 'intern-rat', [RakuAST::LiteralBuilder, '', 0, 0, Any, '$numerator', 0, 0, Any, '$denominator', 0, 0], anon sub intern-rat ($SELF_CONT, $numerator!, $denominator!) {
        my $SELF := nqp::decont($SELF_CONT);
        $numerator := nqp::decont($numerator);
        $denominator := nqp::decont($denominator);
#line 664 src/Raku/ast/compunit.rakumod
        
        # TODO interning
        $SELF.build-rat($numerator, $denominator)
    
    });
    add-method(RakuAST::LiteralBuilder, 'build-rat', [RakuAST::LiteralBuilder, '', 0, 0, Mu, '$numerator', 0, 0, Mu, '$denominator', 0, 0], anon sub build-rat ($SELF_CONT, $numerator!, $denominator!) {
        my $SELF := nqp::decont($SELF_CONT);
        $numerator := nqp::decont($numerator);
        $denominator := nqp::decont($denominator);
#line 670 src/Raku/ast/compunit.rakumod
        
        unless nqp::getattr_i($SELF, RakuAST::LiteralBuilder, '$!has-cached-rat') {
            nqp::bindattr($SELF,RakuAST::LiteralBuilder,'$!cached-rat',
              nqp::getattr($SELF, RakuAST::LiteralBuilder, '$!resolver').setting-constant('Rat'));
            nqp::bindattr_i($SELF,RakuAST::LiteralBuilder,'$!has-cached-rat',1);
        }
        nqp::getattr($SELF, RakuAST::LiteralBuilder, '$!cached-rat').new($numerator, $denominator)
    
    });
    add-method(RakuAST::LiteralBuilder, 'intern-complex', [RakuAST::LiteralBuilder, '', 0, 0, Any, '$real-part', 0, 0, Any, '$imaginary-part', 0, 0], anon sub intern-complex ($SELF_CONT, $real-part!, $imaginary-part!) {
        my $SELF := nqp::decont($SELF_CONT);
        $real-part := nqp::decont($real-part);
        $imaginary-part := nqp::decont($imaginary-part);
#line 680 src/Raku/ast/compunit.rakumod
        
        # TODO interning
        $SELF.build-complex($real-part, $imaginary-part)
    
    });
    add-method(RakuAST::LiteralBuilder, 'build-complex', [RakuAST::LiteralBuilder, '', 0, 0, str, '$real-part', 0, 0, str, '$imaginary-part', 0, 0], anon sub build-complex ($SELF_CONT, $real-part!, $imaginary-part!) {
        my $SELF := nqp::decont($SELF_CONT);
        $real-part := nqp::decont($real-part);
        $imaginary-part := nqp::decont($imaginary-part);
#line 686 src/Raku/ast/compunit.rakumod
        
        my num $real := $real-part
          ?? nqp::box_n(nqp::numify($real-part), Num)
          !! 0e0;
        my num $imaginary := $imaginary-part
          ?? nqp::box_n(nqp::numify($imaginary-part), Num)
          !! 1e0;

        # Produce the Complex object.
        unless nqp::getattr_i($SELF, RakuAST::LiteralBuilder, '$!has-cached-complex') {
            nqp::bindattr($SELF, RakuAST::LiteralBuilder, '$!cached-complex',
              nqp::getattr($SELF, RakuAST::LiteralBuilder, '$!resolver').setting-constant('Complex'));
            nqp::bindattr_i($SELF,RakuAST::LiteralBuilder,'$!has-cached-complex',1);
        }
        nqp::getattr($SELF, RakuAST::LiteralBuilder, '$!cached-complex').new($real, $imaginary)
    
    });
    compose(RakuAST::LiteralBuilder);
    parent(RakuAST::StatementPrefix, RakuAST::Term);
    add-attribute(RakuAST::StatementPrefix, RakuAST::Blorst, '$!blorst');
    add-method(RakuAST::StatementPrefix, 'new', [RakuAST::StatementPrefix, '', 0, 0, RakuAST::Blorst, '$blorst', 0, 0], anon sub new ($SELF_CONT, $blorst!) {
        my $SELF := nqp::decont($SELF_CONT);
        $blorst := nqp::decont($blorst);
#line 7 src/Raku/ast/statementprefixes.rakumod
        
        my $obj := nqp::create($SELF);
        unless $SELF.allowed-on-for-statement {
            if nqp::istype($blorst, RakuAST::Statement::For) {
                nqp::die('Do not use this statement prefix on a RakuAST::Statement::For; ' ~
                    'instead, set the mode on that node');
            }
        }
        nqp::bindattr($obj, RakuAST::StatementPrefix, '$!blorst', $blorst);
        $obj
    
    });
    add-method(RakuAST::StatementPrefix, 'allowed-on-for-statement', [RakuAST::StatementPrefix, '', 0, 0], anon sub allowed-on-for-statement ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 19 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::StatementPrefix, 'IMPL-CALLISH-QAST', [RakuAST::StatementPrefix, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-CALLISH-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 21 src/Raku/ast/statementprefixes.rakumod
        
        if nqp::istype(nqp::getattr($SELF, RakuAST::StatementPrefix, '$!blorst'), RakuAST::Block) {
            nqp::getattr($SELF, RakuAST::StatementPrefix, '$!blorst').IMPL-QAST-BLOCK($context, :blocktype<declaration_static>);
            QAST::Op.new( :op('call'), nqp::getattr($SELF, RakuAST::StatementPrefix, '$!blorst').IMPL-TO-QAST($context) )
        }
        else {
            nqp::getattr($SELF, RakuAST::StatementPrefix, '$!blorst').IMPL-TO-QAST($context)
        }
    
    });
    add-method(RakuAST::StatementPrefix, 'visit-children', [RakuAST::StatementPrefix, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 31 src/Raku/ast/statementprefixes.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::StatementPrefix, '$!blorst'));
    
    });
#line 5 src/Raku/ast/statementprefixes.rakumod
    add-method(RakuAST::StatementPrefix, 'blorst', [], anon sub blorst ($self) { nqp::getattr(nqp::decont($self), RakuAST::StatementPrefix, '$!blorst') });
    compose(RakuAST::StatementPrefix);
    parent(RakuAST::StatementPrefix::Do, RakuAST::StatementPrefix);
    parent(RakuAST::StatementPrefix::Do, RakuAST::SinkPropagator);
    add-method(RakuAST::StatementPrefix::Do, 'type', [RakuAST::StatementPrefix::Do, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 41 src/Raku/ast/statementprefixes.rakumod
         "do" 
    });
    add-method(RakuAST::StatementPrefix::Do, 'propagate-sink', [RakuAST::StatementPrefix::Do, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 43 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.apply-sink($is-sunk);
    
    });
    add-method(RakuAST::StatementPrefix::Do, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Do, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 47 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.IMPL-CALLISH-QAST($context)
    
    });
    compose(RakuAST::StatementPrefix::Do);
    parent(RakuAST::StatementPrefix::Quietly, RakuAST::StatementPrefix);
    parent(RakuAST::StatementPrefix::Quietly, RakuAST::SinkPropagator);
    add-method(RakuAST::StatementPrefix::Quietly, 'type', [RakuAST::StatementPrefix::Quietly, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 57 src/Raku/ast/statementprefixes.rakumod
         "quietly" 
    });
    add-method(RakuAST::StatementPrefix::Quietly, 'propagate-sink', [RakuAST::StatementPrefix::Quietly, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 59 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.apply-sink($is-sunk);
    
    });
    add-method(RakuAST::StatementPrefix::Quietly, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Quietly, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 63 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Op.new(
            :op('handle'),
            $SELF.IMPL-CALLISH-QAST($context),
            'WARN',
            QAST::Op.new( :op('resume'), QAST::Op.new( :op('exception') ) )
        )
    
    });
    compose(RakuAST::StatementPrefix::Quietly);
    parent(RakuAST::StatementPrefix::Race, RakuAST::StatementPrefix);
    add-method(RakuAST::StatementPrefix::Race, 'type', [RakuAST::StatementPrefix::Race, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 77 src/Raku/ast/statementprefixes.rakumod
         "race" 
    });
    add-method(RakuAST::StatementPrefix::Race, 'allowed-on-for-statement', [RakuAST::StatementPrefix::Race, '', 0, 0], anon sub allowed-on-for-statement ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 79 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::StatementPrefix::Race, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Race, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 81 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Op.new(
            :op('callmethod'), :name('race'),
            $SELF.IMPL-CALLISH-QAST($context),
        )
    
    });
    compose(RakuAST::StatementPrefix::Race);
    parent(RakuAST::StatementPrefix::Hyper, RakuAST::StatementPrefix);
    add-method(RakuAST::StatementPrefix::Hyper, 'type', [RakuAST::StatementPrefix::Hyper, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 93 src/Raku/ast/statementprefixes.rakumod
         "hyper" 
    });
    add-method(RakuAST::StatementPrefix::Hyper, 'allowed-on-for-statement', [RakuAST::StatementPrefix::Hyper, '', 0, 0], anon sub allowed-on-for-statement ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 95 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::StatementPrefix::Hyper, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Hyper, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 97 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Op.new(
            :op('callmethod'), :name('hyper'),
            $SELF.IMPL-CALLISH-QAST($context),
        )
    
    });
    compose(RakuAST::StatementPrefix::Hyper);
    parent(RakuAST::StatementPrefix::Lazy, RakuAST::StatementPrefix);
    add-method(RakuAST::StatementPrefix::Lazy, 'type', [RakuAST::StatementPrefix::Lazy, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 109 src/Raku/ast/statementprefixes.rakumod
         "lazy" 
    });
    add-method(RakuAST::StatementPrefix::Lazy, 'allowed-on-for-statement', [RakuAST::StatementPrefix::Lazy, '', 0, 0], anon sub allowed-on-for-statement ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 111 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::StatementPrefix::Lazy, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Lazy, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 113 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Op.new(
            :op('callmethod'), :name('lazy'),
            $SELF.IMPL-CALLISH-QAST($context),
        )
    
    });
    compose(RakuAST::StatementPrefix::Lazy);
    parent(RakuAST::StatementPrefix::Eager, RakuAST::StatementPrefix);
    add-method(RakuAST::StatementPrefix::Eager, 'type', [RakuAST::StatementPrefix::Eager, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 125 src/Raku/ast/statementprefixes.rakumod
         "eager" 
    });
    add-method(RakuAST::StatementPrefix::Eager, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Eager, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 127 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Op.new(
            :op('callmethod'), :name('eager'),
            $SELF.IMPL-CALLISH-QAST($context),
        )
    
    });
    compose(RakuAST::StatementPrefix::Eager);
    parent(RakuAST::StatementPrefix::Try, RakuAST::StatementPrefix);
    parent(RakuAST::StatementPrefix::Try, RakuAST::SinkPropagator);
    parent(RakuAST::StatementPrefix::Try, RakuAST::ImplicitLookups);
    add-method(RakuAST::StatementPrefix::Try, 'type', [RakuAST::StatementPrefix::Try, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 141 src/Raku/ast/statementprefixes.rakumod
         "try" 
    });
    add-method(RakuAST::StatementPrefix::Try, 'propagate-sink', [RakuAST::StatementPrefix::Try, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 143 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.apply-sink($is-sunk);
    
    });
    add-method(RakuAST::StatementPrefix::Try, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::StatementPrefix::Try, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 147 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Nil')),
            RakuAST::Var::Lexical.new('$!'),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Failure')),
        ])
    
    });
    add-method(RakuAST::StatementPrefix::Try, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Try, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 155 src/Raku/ast/statementprefixes.rakumod
        
        # If it's a block that already has a CATCH handler, just run it.
        my $blorst := $SELF.blorst;
        if nqp::istype($blorst, RakuAST::Block) && $blorst.IMPL-HAS-CATCH-HANDLER {
            $SELF.IMPL-CALLISH-QAST($context)
        }

        # Otherwise, need to wrap it in exception handler logic.
        else {
            my $lookups := $SELF.get-implicit-lookups;
            my $nil     := $lookups.AT-POS(0).IMPL-TO-QAST($context);
            my $bang    := $lookups.AT-POS(1).IMPL-TO-QAST($context);
            my $Failure := $lookups.AT-POS(2).IMPL-TO-QAST($context);

            my $tmp := QAST::Node.unique('fatalizee');
            my $qast := $SELF.IMPL-CALLISH-QAST($context);
            QAST::Op.new(
                :op('handle'),

                # Success path puts Nil into $! and evaluates to the block.
                QAST::Stmt.new(
                    :resultchild(0),
                    QAST::Stmts.new(
                        :resultchild(0),
                        QAST::Op.new(
                            :op('bind'),
                            QAST::Var.new( :name($tmp), :scope('local'), :decl('var') ),
                            $qast
                        ),
                        QAST::Op.new(
                            :op('if'),
                            QAST::Op.new(
                                :op('istype'),
                                QAST::Var.new( :name($tmp), :scope('local') ),
                                $Failure,
                            ),
                            QAST::Op.new(
                                :op('callmethod'), :name('sink'),
                                QAST::Var.new( :name($tmp), :scope('local') )
                            )
                        )),
                    QAST::Op.new( :op('p6store'), $bang, $nil )
                ),

                # On failure, capture the exception object into $!.
                'CATCH', QAST::Stmts.new(
                    QAST::Op.new(
                        :op('p6store'),
                        $bang,
                        QAST::Op.new(
                            :name<&EXCEPTION>, :op<call>,
                            QAST::Op.new( :op('exception') )
                        ),
                    ),
                    $nil
                )
            )
        }
    
    });
    compose(RakuAST::StatementPrefix::Try);
    parent(RakuAST::StatementPrefix::Thunky, RakuAST::StatementPrefix);
    parent(RakuAST::StatementPrefix::Thunky, RakuAST::Meta);
    parent(RakuAST::StatementPrefix::Thunky, RakuAST::Code);
    parent(RakuAST::StatementPrefix::Thunky, RakuAST::BeginTime);
    add-method(RakuAST::StatementPrefix::Thunky, 'is-begin-performed-before-children', [RakuAST::StatementPrefix::Thunky, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 225 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::StatementPrefix::Thunky, 'PERFORM-BEGIN', [RakuAST::StatementPrefix::Thunky, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 227 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.IMPL-STUB-CODE($resolver, $context);

        Nil
    
    });
    add-method(RakuAST::StatementPrefix::Thunky, 'PRODUCE-META-OBJECT', [RakuAST::StatementPrefix::Thunky, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 233 src/Raku/ast/statementprefixes.rakumod
        
        if nqp::istype($SELF.blorst, RakuAST::Block) {
            # Block, already has a meta-object.
            $SELF.blorst.meta-object
        }
        else {
            # Create code object with default empty signature.
            my $signature := nqp::create(Signature);
            nqp::bindattr($signature, Signature, '@!params', nqp::list());
            my $code := nqp::create(Code);
            nqp::bindattr($code, Code, '$!signature', $signature);
            $code
        }
    
    });
    add-method(RakuAST::StatementPrefix::Thunky, 'IMPL-QAST-FORM-BLOCK', [RakuAST::StatementPrefix::Thunky, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-FORM-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 249 src/Raku/ast/statementprefixes.rakumod
        
        if nqp::istype($SELF.blorst, RakuAST::Block) {
            $SELF.blorst.IMPL-QAST-FORM-BLOCK($context, :$blocktype, :$expression)
        }
        else {
            my $block := QAST::Block.new(
                :blocktype('declaration_static'),
                QAST::Stmts.new(
                    $SELF.blorst.IMPL-TO-QAST($context)
                ));
            $block.arity(0);
            $block
        }
    
    });
    add-method(RakuAST::StatementPrefix::Thunky, 'IMPL-QAST-BLOCK', [RakuAST::StatementPrefix::Thunky, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 265 src/Raku/ast/statementprefixes.rakumod
        
        if nqp::istype($SELF.blorst, RakuAST::Block) {
            $SELF.blorst.IMPL-QAST-BLOCK($context, :$blocktype, :$expression)
        }
        else {
            unless (nqp::getattr($SELF, RakuAST::Code, '$!qast-block')) {
                $SELF.IMPL-FINISH-CODE-OBJECT($context, :$blocktype, :$expression);
            }
            nqp::getattr($SELF, RakuAST::Code, '$!qast-block')
        }
    
    });
    add-method(RakuAST::StatementPrefix::Thunky, 'IMPL-QAST-DECL-CODE', [RakuAST::StatementPrefix::Thunky, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL-CODE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 277 src/Raku/ast/statementprefixes.rakumod
        
        if nqp::istype($SELF.blorst, RakuAST::Block) {
            # Block already, so we need add nothing.
            QAST::Op.new( :op('null') )
        }
        else {
            $SELF.IMPL-QAST-BLOCK($context, :blocktype('declaration_static'))
        }
    
    });
    compose(RakuAST::StatementPrefix::Thunky);
    parent(RakuAST::StatementPrefix::Gather, RakuAST::StatementPrefix::Thunky);
    parent(RakuAST::StatementPrefix::Gather, RakuAST::SinkPropagator);
    add-method(RakuAST::StatementPrefix::Gather, 'type', [RakuAST::StatementPrefix::Gather, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 293 src/Raku/ast/statementprefixes.rakumod
         "gather" 
    });
    add-method(RakuAST::StatementPrefix::Gather, 'propagate-sink', [RakuAST::StatementPrefix::Gather, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 295 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.apply-sink((Bool.WHO)<True>);
    
    });
    add-method(RakuAST::StatementPrefix::Gather, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Gather, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 299 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Op.new( :op('call'), :name('&GATHER'), $SELF.IMPL-CLOSURE-QAST($context) )
    
    });
    compose(RakuAST::StatementPrefix::Gather);
    parent(RakuAST::StatementPrefix::Blorst, RakuAST::StatementPrefix::Thunky);
    parent(RakuAST::StatementPrefix::Blorst, RakuAST::SinkPropagator);
    parent(RakuAST::StatementPrefix::Blorst, RakuAST::ImplicitBlockSemanticsProvider);
    add-method(RakuAST::StatementPrefix::Blorst, 'propagate-sink', [RakuAST::StatementPrefix::Blorst, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 310 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.apply-sink((Bool.WHO)<False>);
    
    });
    add-method(RakuAST::StatementPrefix::Blorst, 'apply-implicit-block-semantics', [RakuAST::StatementPrefix::Blorst, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 314 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.set-fresh-variables(:match, :exception)
          if nqp::istype($SELF.blorst, RakuAST::Block);
    
    });
    add-method(RakuAST::StatementPrefix::Blorst, 'IMPL-QAST-FORM-BLOCK', [RakuAST::StatementPrefix::Blorst, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 1], anon sub IMPL-QAST-FORM-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 323 src/Raku/ast/statementprefixes.rakumod
        
        if nqp::istype($SELF.blorst, RakuAST::Block) {
            $SELF.blorst.IMPL-QAST-FORM-BLOCK($context, :$blocktype, :$expression)
        }
        else {
            my $block := QAST::Block.new(
              :blocktype('declaration_static'),
              QAST::Stmts.new(
                RakuAST::VarDeclaration::Implicit::Special.new(:name('$/')).IMPL-QAST-DECL($context),
                RakuAST::VarDeclaration::Implicit::Special.new(:name('$!')).IMPL-QAST-DECL($context),
                $SELF.blorst.IMPL-TO-QAST($context)
              ));
            $block.arity(0);
            $block
        }
    
    });
    add-method(RakuAST::StatementPrefix::Blorst, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Blorst, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 340 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Op.new(:op<call>,
          :name('&' ~ nqp::uc($SELF.type)),
          $SELF.IMPL-CLOSURE-QAST($context)
        )
    
    });
    compose(RakuAST::StatementPrefix::Blorst);
    parent(RakuAST::StatementPrefix::Once, RakuAST::StatementPrefix::Blorst);
    parent(RakuAST::StatementPrefix::Once, RakuAST::ImplicitDeclarations);
    add-attribute(RakuAST::StatementPrefix::Once, str, '$!state-name');
    add-method(RakuAST::StatementPrefix::Once, 'type', [RakuAST::StatementPrefix::Once, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 355 src/Raku/ast/statementprefixes.rakumod
         "once" 
    });
    add-method(RakuAST::StatementPrefix::Once, 'PRODUCE-IMPLICIT-DECLARATIONS', [RakuAST::StatementPrefix::Once, '', 0, 0], anon sub PRODUCE-IMPLICIT-DECLARATIONS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 357 src/Raku/ast/statementprefixes.rakumod
        
        my $state-name := QAST::Node.unique('once_');
        nqp::bindattr_s($SELF, RakuAST::StatementPrefix::Once, '$!state-name', $state-name);

        $SELF.IMPL-WRAP-LIST([
            RakuAST::VarDeclaration::Implicit::State.new($state-name)
        ])
    
    });
    add-method(RakuAST::StatementPrefix::Once, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Once, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 366 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Op.new(:op<decont>,
          QAST::Op.new(:op<if>,
            QAST::Op.new(:op<p6stateinit>),
            QAST::Op.new(:op<p6store>,
              QAST::Var.new(:name(nqp::getattr_s($SELF, RakuAST::StatementPrefix::Once, '$!state-name')), :scope<lexical>),
              QAST::Op.new(:op<call>, $SELF.IMPL-CLOSURE-QAST($context))
            ),
            QAST::Var.new(:name(nqp::getattr_s($SELF, RakuAST::StatementPrefix::Once, '$!state-name')), :scope<lexical>)
          )
        )
    
    });
    compose(RakuAST::StatementPrefix::Once);
    parent(RakuAST::StatementPrefix::Start, RakuAST::StatementPrefix::Blorst);
    parent(RakuAST::StatementPrefix::Start, RakuAST::ImplicitLookups);
    add-method(RakuAST::StatementPrefix::Start, 'type', [RakuAST::StatementPrefix::Start, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 385 src/Raku/ast/statementprefixes.rakumod
         "start" 
    });
    add-method(RakuAST::StatementPrefix::Start, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::StatementPrefix::Start, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 387 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Promise')),
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('True')),
        ])
    
    });
    add-method(RakuAST::StatementPrefix::Start, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Start, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 394 src/Raku/ast/statementprefixes.rakumod
        
        my $lookups := $SELF.get-implicit-lookups;
        my $qast := QAST::Op.new(
            :op('callmethod'), :name('start'),
            $lookups.AT-POS(0).IMPL-TO-QAST($context),
            $SELF.IMPL-CLOSURE-QAST($context)
        );
        unless $context.lang-version eq 'c' {
            my $true := $lookups.AT-POS(1).IMPL-TO-QAST($context);
            $true.named('report-broken-if-sunk');
            $qast.push($true);
        }
        $qast
    
    });
    compose(RakuAST::StatementPrefix::Start);
    parent(RakuAST::StatementPrefix::React, RakuAST::StatementPrefix::Blorst);
    add-method(RakuAST::StatementPrefix::React, 'type', [RakuAST::StatementPrefix::React, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 414 src/Raku/ast/statementprefixes.rakumod
         "react" 
    });
    compose(RakuAST::StatementPrefix::React);
    parent(RakuAST::StatementPrefix::Supply, RakuAST::StatementPrefix::Blorst);
    add-method(RakuAST::StatementPrefix::Supply, 'type', [RakuAST::StatementPrefix::Supply, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 421 src/Raku/ast/statementprefixes.rakumod
         "supply" 
    });
    compose(RakuAST::StatementPrefix::Supply);
    parent(RakuAST::StatementPrefix::Phaser, RakuAST::StatementPrefix);
    add-method(RakuAST::StatementPrefix::Phaser, 'dump-markers', [RakuAST::StatementPrefix::Phaser, '', 0, 0], anon sub dump-markers ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 428 src/Raku/ast/statementprefixes.rakumod
         '🛸' 
    });
    compose(RakuAST::StatementPrefix::Phaser);
    parent(RakuAST::StatementPrefix::Phaser::Sinky, RakuAST::StatementPrefix::Phaser);
    parent(RakuAST::StatementPrefix::Phaser::Sinky, RakuAST::ImplicitLookups);
    parent(RakuAST::StatementPrefix::Phaser::Sinky, RakuAST::SinkPropagator);
    add-method(RakuAST::StatementPrefix::Phaser::Sinky, 'propagate-sink', [RakuAST::StatementPrefix::Phaser::Sinky, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 437 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.apply-sink((Bool.WHO)<True>);
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Sinky, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::StatementPrefix::Phaser::Sinky, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 441 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Nil')),
        ])
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Sinky, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Phaser::Sinky, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 447 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context);
    
    });
    compose(RakuAST::StatementPrefix::Phaser::Sinky);
    parent(RakuAST::StatementPrefix::Phaser::Begin, RakuAST::StatementPrefix::Phaser);
    parent(RakuAST::StatementPrefix::Phaser::Begin, RakuAST::StatementPrefix::Thunky);
    parent(RakuAST::StatementPrefix::Phaser::Begin, RakuAST::BeginTime);
    add-attribute(RakuAST::StatementPrefix::Phaser::Begin, Mu, '$!value');
    add-method(RakuAST::StatementPrefix::Phaser::Begin, 'type', [RakuAST::StatementPrefix::Phaser::Begin, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 460 src/Raku/ast/statementprefixes.rakumod
         "BEGIN" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Begin, 'PERFORM-BEGIN', [RakuAST::StatementPrefix::Phaser::Begin, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 463 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.IMPL-STUB-CODE($resolver, $context);

        nqp::bindattr_i($SELF, RakuAST::BeginTime, '$!begin-performed', 1); # avoid infinite loop
        my $producer := $SELF.IMPL-BEGIN-TIME-EVALUATE($SELF,$resolver,$context);
        nqp::bindattr($SELF, RakuAST::StatementPrefix::Phaser::Begin,
          '$!value', $producer());
        Nil
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Begin, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Phaser::Begin, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 473 src/Raku/ast/statementprefixes.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::StatementPrefix::Phaser::Begin, '$!value');
        $context.ensure-sc($value);
        QAST::WVal.new(:$value)
    
    });
    compose(RakuAST::StatementPrefix::Phaser::Begin);
    parent(RakuAST::StatementPrefix::Phaser::Check, RakuAST::StatementPrefix::Phaser);
    parent(RakuAST::StatementPrefix::Phaser::Check, RakuAST::CheckTime);
    add-attribute(RakuAST::StatementPrefix::Phaser::Check, Mu, '$!value');
    add-method(RakuAST::StatementPrefix::Phaser::Check, 'type', [RakuAST::StatementPrefix::Phaser::Check, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 487 src/Raku/ast/statementprefixes.rakumod
         "CHECK" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Check, 'new', [RakuAST::StatementPrefix::Phaser::Check, '', 0, 0, RakuAST::Blorst, '$blorst', 0, 0], anon sub new ($SELF_CONT, $blorst!) {
        my $SELF := nqp::decont($SELF_CONT);
        $blorst := nqp::decont($blorst);
#line 489 src/Raku/ast/statementprefixes.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::StatementPrefix, '$!blorst', $blorst);
        $obj
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Check, 'PERFORM-CHECK', [RakuAST::StatementPrefix::Phaser::Check, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 495 src/Raku/ast/statementprefixes.rakumod
        
        my $producer := RakuAST::BeginTime.IMPL-BEGIN-TIME-EVALUATE(
          nqp::getattr($SELF, RakuAST::StatementPrefix, '$!blorst'),
          $resolver, $context);

        nqp::bindattr($SELF, RakuAST::StatementPrefix::Phaser::Check, '$!value',
          nqp::istype($producer,Code) ?? $producer() !! $producer);
        Nil
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Check, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Phaser::Check, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 505 src/Raku/ast/statementprefixes.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::StatementPrefix::Phaser::Check, '$!value');
        $context.ensure-sc($value);
        QAST::WVal.new(:$value)
    
    });
    compose(RakuAST::StatementPrefix::Phaser::Check);
    parent(RakuAST::StatementPrefix::Phaser::Init, RakuAST::StatementPrefix::Phaser);
    parent(RakuAST::StatementPrefix::Phaser::Init, RakuAST::Attaching);
    add-attribute(RakuAST::StatementPrefix::Phaser::Init, Scalar, '$!container');
    add-method(RakuAST::StatementPrefix::Phaser::Init, 'type', [RakuAST::StatementPrefix::Phaser::Init, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 519 src/Raku/ast/statementprefixes.rakumod
         "INIT" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Init, 'new', [RakuAST::StatementPrefix::Phaser::Init, '', 0, 0, RakuAST::Blorst, '$blorst', 0, 0], anon sub new ($SELF_CONT, $blorst!) {
        my $SELF := nqp::decont($SELF_CONT);
        $blorst := nqp::decont($blorst);
#line 521 src/Raku/ast/statementprefixes.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::StatementPrefix, '$!blorst', $blorst);
        nqp::bindattr($obj, RakuAST::StatementPrefix::Phaser::Init, '$!container', nqp::create(Scalar));
        $obj
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Init, 'attach', [RakuAST::StatementPrefix::Phaser::Init, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 528 src/Raku/ast/statementprefixes.rakumod
        
        $resolver.find-attach-target('compunit').add-init-phaser($SELF);
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Init, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Phaser::Init, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 532 src/Raku/ast/statementprefixes.rakumod
        
        my $container := nqp::getattr($SELF, RakuAST::StatementPrefix::Phaser::Init, '$!container');
        $context.ensure-sc($container);
        QAST::WVal.new( :value($container) )
    
    });
#line 517 src/Raku/ast/statementprefixes.rakumod
    add-method(RakuAST::StatementPrefix::Phaser::Init, 'container', [], anon sub container ($self) { nqp::getattr(nqp::decont($self), RakuAST::StatementPrefix::Phaser::Init, '$!container') });
    compose(RakuAST::StatementPrefix::Phaser::Init);
    parent(RakuAST::StatementPrefix::Phaser::Enter, RakuAST::StatementPrefix::Phaser);
    parent(RakuAST::StatementPrefix::Phaser::Enter, RakuAST::StatementPrefix::Thunky);
    parent(RakuAST::StatementPrefix::Phaser::Enter, RakuAST::Attaching);
    add-attribute(RakuAST::StatementPrefix::Phaser::Enter, str, '$!result-name');
    add-method(RakuAST::StatementPrefix::Phaser::Enter, 'type', [RakuAST::StatementPrefix::Phaser::Enter, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 547 src/Raku/ast/statementprefixes.rakumod
         "ENTER" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Enter, 'new', [RakuAST::StatementPrefix::Phaser::Enter, '', 0, 0, RakuAST::Blorst, '$blorst', 0, 0], anon sub new ($SELF_CONT, $blorst!) {
        my $SELF := nqp::decont($SELF_CONT);
        $blorst := nqp::decont($blorst);
#line 549 src/Raku/ast/statementprefixes.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::StatementPrefix, '$!blorst', $blorst);
        $obj
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Enter, 'attach', [RakuAST::StatementPrefix::Phaser::Enter, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 555 src/Raku/ast/statementprefixes.rakumod
        
        nqp::bindattr_s($SELF, RakuAST::StatementPrefix::Phaser::Enter, '$!result-name',
            ($resolver.find-attach-target('block')
              // $resolver.find-attach-target('compunit')
            ).add-enter-phaser($SELF)
        );
        nqp::bindattr($SELF, RakuAST::Code, '$!resolver', $resolver.clone);
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Enter, 'IMPL-RESULT-NAME', [RakuAST::StatementPrefix::Phaser::Enter, '', 0, 0], anon sub IMPL-RESULT-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 564 src/Raku/ast/statementprefixes.rakumod
        
        nqp::getattr_s($SELF, RakuAST::StatementPrefix::Phaser::Enter, '$!result-name')
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Enter, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Phaser::Enter, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 568 src/Raku/ast/statementprefixes.rakumod
        
        nqp::die("ENTER phaser not attached but result accessed") unless nqp::getattr_s($SELF, RakuAST::StatementPrefix::Phaser::Enter, '$!result-name');
        QAST::Var.new(:name(nqp::getattr_s($SELF, RakuAST::StatementPrefix::Phaser::Enter, '$!result-name')), :scope<local>)
    
    });
    compose(RakuAST::StatementPrefix::Phaser::Enter);
    parent(RakuAST::StatementPrefix::Phaser::End, RakuAST::StatementPrefix::Phaser::Sinky);
    parent(RakuAST::StatementPrefix::Phaser::End, RakuAST::StatementPrefix::Thunky);
    parent(RakuAST::StatementPrefix::Phaser::End, RakuAST::Attaching);
    add-method(RakuAST::StatementPrefix::Phaser::End, 'type', [RakuAST::StatementPrefix::Phaser::End, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 580 src/Raku/ast/statementprefixes.rakumod
         "END" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::End, 'attach', [RakuAST::StatementPrefix::Phaser::End, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 582 src/Raku/ast/statementprefixes.rakumod
        
        $resolver.find-attach-target('compunit').add-end-phaser($SELF);
        nqp::bindattr($SELF, RakuAST::Code, '$!resolver', $resolver.clone);
    
    });
    compose(RakuAST::StatementPrefix::Phaser::End);
    parent(RakuAST::StatementPrefix::Phaser::Quit, RakuAST::StatementPrefix::Phaser::Sinky);
    parent(RakuAST::StatementPrefix::Phaser::Quit, RakuAST::Attaching);
    add-method(RakuAST::StatementPrefix::Phaser::Quit, 'type', [RakuAST::StatementPrefix::Phaser::Quit, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 593 src/Raku/ast/statementprefixes.rakumod
         "QUIT" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Quit, 'attach', [RakuAST::StatementPrefix::Phaser::Quit, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 595 src/Raku/ast/statementprefixes.rakumod
        
        $resolver.find-attach-target('block').add-phaser("QUIT", $SELF);
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Quit, 'meta-object', [RakuAST::StatementPrefix::Phaser::Quit, '', 0, 0], anon sub meta-object ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 599 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.meta-object
    
    });
    compose(RakuAST::StatementPrefix::Phaser::Quit);
    parent(RakuAST::StatementPrefix::Phaser::Block, RakuAST::StatementPrefix::Phaser::Sinky);
    parent(RakuAST::StatementPrefix::Phaser::Block, RakuAST::StatementPrefix::Thunky);
    parent(RakuAST::StatementPrefix::Phaser::Block, RakuAST::Attaching);
    add-method(RakuAST::StatementPrefix::Phaser::Block, 'attach', [RakuAST::StatementPrefix::Phaser::Block, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 610 src/Raku/ast/statementprefixes.rakumod
        
        $resolver.find-attach-target('block').add-phaser(
          $SELF.type, $SELF, :has-exit-handler($SELF.exit-handler));
        nqp::bindattr($SELF, RakuAST::Code, '$!resolver', $resolver.clone);
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::Block, 'exit-handler', [RakuAST::StatementPrefix::Phaser::Block, '', 0, 0], anon sub exit-handler ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 616 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<False> 
    });
    compose(RakuAST::StatementPrefix::Phaser::Block);
    parent(RakuAST::StatementPrefix::Phaser::First, RakuAST::StatementPrefix::Phaser::Block);
    parent(RakuAST::StatementPrefix::Phaser::First, RakuAST::BeginTime);
    add-attribute(RakuAST::StatementPrefix::Phaser::First, str, '$!value-var-name');
    add-attribute(RakuAST::StatementPrefix::Phaser::First, RakuAST::Blorst, '$!original-blorst');
    add-method(RakuAST::StatementPrefix::Phaser::First, 'type', [RakuAST::StatementPrefix::Phaser::First, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 624 src/Raku/ast/statementprefixes.rakumod
         "FIRST" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::First, 'original-blorst', [RakuAST::StatementPrefix::Phaser::First, '', 0, 0], anon sub original-blorst ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 640 src/Raku/ast/statementprefixes.rakumod
        
        nqp::getattr($SELF, RakuAST::StatementPrefix::Phaser::First, '$!original-blorst') // nqp::getattr($SELF, RakuAST::StatementPrefix, '$!blorst')
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::First, 'is-begin-performed-before-children', [RakuAST::StatementPrefix::Phaser::First, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 644 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::StatementPrefix::Phaser::First, 'is-begin-performed-after-children', [RakuAST::StatementPrefix::Phaser::First, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 645 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::StatementPrefix::Phaser::First, 'propagate-sink', [RakuAST::StatementPrefix::Phaser::First, '', 0, 0, Bool, '$is-sunk', 0, 0], anon sub propagate-sink ($SELF_CONT, $is-sunk!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-sunk := nqp::decont($is-sunk);
#line 649 src/Raku/ast/statementprefixes.rakumod
        
        $SELF.blorst.apply-sink((Bool.WHO)<False>)
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::First, 'PERFORM-BEGIN', [RakuAST::StatementPrefix::Phaser::First, '', 0, 0, Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 653 src/Raku/ast/statementprefixes.rakumod
        
        my $blorst := nqp::getattr($SELF, RakuAST::StatementPrefix, '$!blorst');
        nqp::bindattr($SELF, RakuAST::StatementPrefix::Phaser::First, '$!original-blorst', $blorst);

        my $True := RakuAST::Term::Name.new(RakuAST::Name.from-identifier('True'));

        my $attach-block := $resolver.find-attach-target('block');
        my $trigger-name := QAST::Node.unique('!first_block_triggered');
        my $trigger-var := RakuAST::VarDeclaration::Implicit::State.new: $trigger-name;
        my $trigger-lookup := $trigger-var.generate-lookup;
        $attach-block.add-generated-lexical-declaration($trigger-var);

        my $value-name := QAST::Node.unique('!first_block_value');
        my $value-var := RakuAST::VarDeclaration::Implicit::State.new: $value-name;
        my $value-lookup := $value-var.generate-lookup;
        $attach-block.add-generated-lexical-declaration($value-var);
        nqp::bindattr_s($SELF, RakuAST::StatementPrefix::Phaser::First, '$!value-var-name', $value-name);

        $blorst := $blorst.as-block;
        $blorst :=
            RakuAST::Block.new:
                :body(RakuAST::Blockoid.new:
                    RakuAST::StatementList.new:
                        RakuAST::Statement::Unless.new:
                            :condition($trigger-lookup),
                            :body(RakuAST::Block.new:
                                :body(RakuAST::Blockoid.new:
                                    RakuAST::StatementList.new:
                                        RakuAST::Statement::Expression.new(
                                            :expression(RakuAST::ApplyInfix.new:
                                                :infix(RakuAST::Assignment.new(:item)),
                                                :left($value-lookup),
                                                :right(RakuAST::ApplyPostfix.new:
                                                    :postfix(RakuAST::Call::Term.new),
                                                    :operand($blorst)))), # 🛸 ... the actual FIRST code
                                        RakuAST::Statement::Expression.new(
                                            :expression(RakuAST::ApplyInfix.new:
                                                :infix(RakuAST::Assignment.new(:item)),
                                                :left($trigger-lookup),
                                                :right($True))))));

        nqp::bindattr($SELF, RakuAST::StatementPrefix, '$!blorst', $blorst);
    
    });
    add-method(RakuAST::StatementPrefix::Phaser::First, 'IMPL-EXPR-QAST', [RakuAST::StatementPrefix::Phaser::First, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 697 src/Raku/ast/statementprefixes.rakumod
        
        QAST::Var.new(:name(nqp::getattr_s($SELF, RakuAST::StatementPrefix::Phaser::First, '$!value-var-name')), :scope<lexical>);
    
    });
    compose(RakuAST::StatementPrefix::Phaser::First);
    parent(RakuAST::StatementPrefix::Phaser::Next, RakuAST::StatementPrefix::Phaser::Block);
    add-method(RakuAST::StatementPrefix::Phaser::Next, 'type', [RakuAST::StatementPrefix::Phaser::Next, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 706 src/Raku/ast/statementprefixes.rakumod
         "NEXT" 
    });
    compose(RakuAST::StatementPrefix::Phaser::Next);
    parent(RakuAST::StatementPrefix::Phaser::Last, RakuAST::StatementPrefix::Phaser::Block);
    add-method(RakuAST::StatementPrefix::Phaser::Last, 'type', [RakuAST::StatementPrefix::Phaser::Last, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 713 src/Raku/ast/statementprefixes.rakumod
         "LAST" 
    });
    compose(RakuAST::StatementPrefix::Phaser::Last);
    parent(RakuAST::StatementPrefix::Phaser::Leave, RakuAST::StatementPrefix::Phaser::Block);
    add-method(RakuAST::StatementPrefix::Phaser::Leave, 'type', [RakuAST::StatementPrefix::Phaser::Leave, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 720 src/Raku/ast/statementprefixes.rakumod
         "LEAVE" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Leave, 'exit-handler', [RakuAST::StatementPrefix::Phaser::Leave, '', 0, 0], anon sub exit-handler ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 721 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::StatementPrefix::Phaser::Leave);
    parent(RakuAST::StatementPrefix::Phaser::Keep, RakuAST::StatementPrefix::Phaser::Block);
    add-method(RakuAST::StatementPrefix::Phaser::Keep, 'type', [RakuAST::StatementPrefix::Phaser::Keep, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 728 src/Raku/ast/statementprefixes.rakumod
         "KEEP" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Keep, 'exit-handler', [RakuAST::StatementPrefix::Phaser::Keep, '', 0, 0], anon sub exit-handler ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 729 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::StatementPrefix::Phaser::Keep);
    parent(RakuAST::StatementPrefix::Phaser::Pre, RakuAST::StatementPrefix::Phaser::Block);
    add-method(RakuAST::StatementPrefix::Phaser::Pre, 'type', [RakuAST::StatementPrefix::Phaser::Pre, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 737 src/Raku/ast/statementprefixes.rakumod
         "PRE" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Pre, 'new', [RakuAST::StatementPrefix::Phaser::Pre, '', 0, 0, RakuAST::Blorst, '$blorst', 0, 0, Str, '$condition', 0, 1], anon sub new ($SELF_CONT, $blorst!, $condition?) {
        my $SELF := nqp::decont($SELF_CONT);
        $blorst := nqp::decont($blorst);
        $condition := nqp::decont($condition);
#line 739 src/Raku/ast/statementprefixes.rakumod
        
        my $obj := nqp::create($SELF);

        # The PRE phaser needs extra code to get the required
        # functionality, so this converts a given
        #     foo
        # into
        #     X::Phaser::PrePost.new(:value(~foo)).throw unless foo
        nqp::bindattr($obj, RakuAST::StatementPrefix, '$!blorst',
          RakuAST::Statement::Expression.new(
            expression => RakuAST::ApplyPostfix.new(
              operand => RakuAST::ApplyPostfix.new(
                operand => RakuAST::Type::Simple.new(
                  RakuAST::Name.from-identifier-parts(
                    'X','Phaser','PrePost'
                  )
                ),
                postfix => RakuAST::Call::Method.new(
                  name => RakuAST::Name.from-identifier('new'),
                  args => RakuAST::ArgList.new(
                    RakuAST::ColonPair::Value.new(
                      key   => 'condition',
                      value => RakuAST::StrLiteral.new(
                        $condition
                          ?? nqp::hllizefor($condition, 'Raku')
                          !! $blorst.origin ?? $blorst.origin.Str !! $blorst.DEPARSE
                      )
                    )
                  )
                )
              ),
              postfix => RakuAST::Call::Method.new(
                name => RakuAST::Name.from-identifier('throw')
              )
            ),
            condition-modifier => RakuAST::StatementModifier::Unless.new(
              nqp::istype($blorst, RakuAST::Block)
                ?? RakuAST::ApplyPostfix.new(
                     operand => $blorst,
                     postfix => RakuAST::Call::Term.new
                   )
                !! $blorst
            )
          )
        );

        $obj
    
    });
    compose(RakuAST::StatementPrefix::Phaser::Pre);
    parent(RakuAST::StatementPrefix::Phaser::Post, RakuAST::StatementPrefix::Phaser::Block);
    add-method(RakuAST::StatementPrefix::Phaser::Post, 'type', [RakuAST::StatementPrefix::Phaser::Post, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 793 src/Raku/ast/statementprefixes.rakumod
         "POST" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Post, 'exit-handler', [RakuAST::StatementPrefix::Phaser::Post, '', 0, 0], anon sub exit-handler ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 794 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Post, 'new', [RakuAST::StatementPrefix::Phaser::Post, '', 0, 0, RakuAST::Blorst, '$blorst', 0, 0, Str, '$condition', 0, 1], anon sub new ($SELF_CONT, $blorst!, $condition?) {
        my $SELF := nqp::decont($SELF_CONT);
        $blorst := nqp::decont($blorst);
        $condition := nqp::decont($condition);
#line 796 src/Raku/ast/statementprefixes.rakumod
        
        my $obj  := nqp::create($SELF);

        # The POST phaser needs extra code to get the required
        # functionality, so this converts a given
        #     foo
        # into
        #     {
        #         X::Phaser::PrePost.new(:value(~foo), :phaser<POST>).throw
        #           unless foo
        #     }
        nqp::bindattr($obj, RakuAST::StatementPrefix, '$!blorst',
          RakuAST::Block.new(
            body => RakuAST::Blockoid.new(
              RakuAST::StatementList.new(
                RakuAST::Statement::Expression.new(
                  expression => RakuAST::ApplyPostfix.new(
                    operand => RakuAST::ApplyPostfix.new(
                      operand => RakuAST::Type::Simple.new(
                        RakuAST::Name.from-identifier-parts(
                          'X','Phaser','PrePost'
                        )
                      ),
                      postfix => RakuAST::Call::Method.new(
                        name => RakuAST::Name.from-identifier('new'),
                        args => RakuAST::ArgList.new(
                          RakuAST::ColonPair::Value.new(
                            key   => 'phaser',
                            value => RakuAST::StrLiteral.new(
                              nqp::hllizefor("POST", 'Raku')
                            )
                          ),
                          RakuAST::ColonPair::Value.new(
                            key   => 'condition',
                            value => RakuAST::StrLiteral.new(
                              $condition
                                ?? nqp::hllizefor($condition, 'Raku')
                                !! $blorst.origin
                                  ?? $blorst.origin.Str
                                  !! $blorst.DEPARSE
                            )
                          )
                        )
                      )
                    ),
                    postfix => RakuAST::Call::Method.new(
                      name => RakuAST::Name.from-identifier('throw')
                    )
                  ),
                  condition-modifier => RakuAST::StatementModifier::Unless.new(
                    nqp::istype($blorst, RakuAST::Block)
                      ?? RakuAST::ApplyPostfix.new(
                           operand => $blorst,
                           postfix => RakuAST::Call::Term.new
                         )
                      !! nqp::istype($blorst, RakuAST::Statement::Expression)
                        ?? $blorst.expression
                        !! $blorst
                  )
                )
              )
            )
          )
        );

        $obj
    
    });
    compose(RakuAST::StatementPrefix::Phaser::Post);
    parent(RakuAST::StatementPrefix::Phaser::Undo, RakuAST::StatementPrefix::Phaser::Block);
    add-method(RakuAST::StatementPrefix::Phaser::Undo, 'type', [RakuAST::StatementPrefix::Phaser::Undo, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 869 src/Raku/ast/statementprefixes.rakumod
         "UNDO" 
    });
    add-method(RakuAST::StatementPrefix::Phaser::Undo, 'exit-handler', [RakuAST::StatementPrefix::Phaser::Undo, '', 0, 0], anon sub exit-handler ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 870 src/Raku/ast/statementprefixes.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::StatementPrefix::Phaser::Undo);
    parent(RakuAST::StatementPrefix::Phaser::Close, RakuAST::StatementPrefix::Phaser::Block);
    add-method(RakuAST::StatementPrefix::Phaser::Close, 'type', [RakuAST::StatementPrefix::Phaser::Close, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 877 src/Raku/ast/statementprefixes.rakumod
         "CLOSE" 
    });
    compose(RakuAST::StatementPrefix::Phaser::Close);
    parent(RakuAST::StatementModifier, RakuAST::Node);
    add-attribute(RakuAST::StatementModifier, RakuAST::Expression, '$!expression');
    add-method(RakuAST::StatementModifier, 'new', [RakuAST::StatementModifier, '', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub new ($SELF_CONT, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 7 src/Raku/ast/statement-mods.rakumod
        
        my $obj := nqp::create($SELF);
        $obj.set-expression($expression);
        $obj
    
    });
    add-method(RakuAST::StatementModifier, 'set-expression', [RakuAST::StatementModifier, '', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub set-expression ($SELF_CONT, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $expression := nqp::decont($expression);
#line 13 src/Raku/ast/statement-mods.rakumod
        
        nqp::bindattr($SELF, RakuAST::StatementModifier, '$!expression',
            $expression // RakuAST::Expression);
        Nil
    
    });
    add-method(RakuAST::StatementModifier, 'visit-children', [RakuAST::StatementModifier, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 19 src/Raku/ast/statement-mods.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::StatementModifier, '$!expression'));
    
    });
#line 5 src/Raku/ast/statement-mods.rakumod
    add-method(RakuAST::StatementModifier, 'expression', [], anon sub expression ($self) { nqp::getattr(nqp::decont($self), RakuAST::StatementModifier, '$!expression') });
    compose(RakuAST::StatementModifier);
    parent(RakuAST::StatementModifier::Condition, RakuAST::StatementModifier);
    parent(RakuAST::StatementModifier::Condition, RakuAST::ImplicitLookups);
    add-method(RakuAST::StatementModifier::Condition, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::StatementModifier::Condition, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 29 src/Raku/ast/statement-mods.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Empty'))
        ])
    
    });
    add-method(RakuAST::StatementModifier::Condition, 'IMPL-EMPTY', [RakuAST::StatementModifier::Condition, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EMPTY ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 35 src/Raku/ast/statement-mods.rakumod
        
        $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::StatementModifier::Condition, 'expression-thunk', [RakuAST::StatementModifier::Condition, '', 0, 0], anon sub expression-thunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 39 src/Raku/ast/statement-mods.rakumod
        
        RakuAST::StatementModifier::Condition::Thunk.new($SELF)
    
    });
    compose(RakuAST::StatementModifier::Condition);
    parent(RakuAST::StatementModifier::If, RakuAST::StatementModifier::Condition);
    add-method(RakuAST::StatementModifier::If, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::If, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
#line 48 src/Raku/ast/statement-mods.rakumod
        
        QAST::Op.new(
            :op('if'),
            $SELF.expression.IMPL-TO-QAST($context),
            $statement-qast,
            $SELF.IMPL-EMPTY($context)
        )
    
    });
    compose(RakuAST::StatementModifier::If);
    parent(RakuAST::StatementModifier::Unless, RakuAST::StatementModifier::Condition);
    add-method(RakuAST::StatementModifier::Unless, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::Unless, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
#line 62 src/Raku/ast/statement-mods.rakumod
        
        QAST::Op.new(
            :op('unless'),
            $SELF.expression.IMPL-TO-QAST($context),
            $statement-qast,
            $SELF.IMPL-EMPTY($context)
        )
    
    });
    compose(RakuAST::StatementModifier::Unless);
    parent(RakuAST::StatementModifier::When, RakuAST::StatementModifier::Condition);
    add-method(RakuAST::StatementModifier::When, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::When, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
#line 76 src/Raku/ast/statement-mods.rakumod
        
        QAST::Op.new(
            :op('if'),
            QAST::Op.new(
                :op('callmethod'), :name('ACCEPTS'),
                $SELF.expression.IMPL-TO-QAST($context),
                QAST::Var.new( :name('$_'), :scope('lexical') )
            ),
            $statement-qast,
            $SELF.IMPL-EMPTY($context)
        )
    
    });
    compose(RakuAST::StatementModifier::When);
    parent(RakuAST::StatementModifier::With, RakuAST::StatementModifier::Condition);
    add-method(RakuAST::StatementModifier::With, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::With, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
#line 94 src/Raku/ast/statement-mods.rakumod
        
        if nqp::istype($statement-qast, QAST::Block) {
            # It's a block, so just use the `with` compilation.
            QAST::Op.new(
                :op('with'),
                $SELF.expression.IMPL-TO-QAST($context),
                $statement-qast,
                $SELF.IMPL-EMPTY($context)
            )
        }
        else {
            # A non-block statement. Compile more cheaply by making a temporary
            # $_ to avoid a wrapping block.
            my $tested := QAST::Node.unique('with_tested');
            QAST::Op.new(
                :op('if'),
                QAST::Op.new(
                    :op('callmethod'), :name('defined'),
                    QAST::Op.new(
                        :op('bind'),
                        QAST::Var.new( :name($tested), :scope('local'), :decl('var') ),
                        $SELF.expression.IMPL-TO-QAST($context),
                    ),
                ),
                $SELF.IMPL-TEMPORARIZE-TOPIC(
                    QAST::Var.new( :name($tested), :scope('local') ),
                    $statement-qast
                ),
                $SELF.IMPL-EMPTY($context)
            )
        }
    
    });
    compose(RakuAST::StatementModifier::With);
    parent(RakuAST::StatementModifier::Without, RakuAST::StatementModifier::Condition);
    add-method(RakuAST::StatementModifier::Without, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::Without, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
#line 132 src/Raku/ast/statement-mods.rakumod
        
        my $tested := QAST::Node.unique('without_tested');
        QAST::Op.new(
            :op('unless'),
            QAST::Op.new(
                :op('callmethod'), :name('defined'),
                QAST::Op.new(
                    :op('bind'),
                    QAST::Var.new( :name($tested), :scope('local'), :decl('var') ),
                    $SELF.expression.IMPL-TO-QAST($context),
                ),
            ),
            $SELF.IMPL-TEMPORARIZE-TOPIC(
                QAST::Var.new( :name($tested), :scope('local') ),
                $statement-qast
            ),
            $SELF.IMPL-EMPTY($context)
        )
    
    });
    compose(RakuAST::StatementModifier::Without);
    parent(RakuAST::StatementModifier::Loop, RakuAST::StatementModifier);
    add-method(RakuAST::StatementModifier::Loop, 'expression-thunk', [RakuAST::StatementModifier::Loop, '', 0, 0], anon sub expression-thunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 157 src/Raku/ast/statement-mods.rakumod
         Nil 
    });
    compose(RakuAST::StatementModifier::Loop);
    parent(RakuAST::StatementModifier::While, RakuAST::StatementModifier::Loop);
    add-method(RakuAST::StatementModifier::While, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::While, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0, Bool, '$sink', 1, 1], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!, :$sink?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
        $sink := nqp::decont($sink);
#line 164 src/Raku/ast/statement-mods.rakumod
        
        if $sink {
            QAST::Op.new(
                :op('while'),
                $SELF.expression.IMPL-TO-QAST($context),
                $statement-qast
            )
        }
        else {
            nqp::die('non-sink statement modifier while NYI');
        }
    
    });
    compose(RakuAST::StatementModifier::While);
    parent(RakuAST::StatementModifier::Until, RakuAST::StatementModifier::Loop);
    add-method(RakuAST::StatementModifier::Until, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::Until, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0, Bool, '$sink', 1, 1], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!, :$sink?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
        $sink := nqp::decont($sink);
#line 182 src/Raku/ast/statement-mods.rakumod
        
        if $sink {
            QAST::Op.new(
                :op('until'),
                $SELF.expression.IMPL-TO-QAST($context),
                $statement-qast
            )
        }
        else {
            nqp::die('non-sink statement modifier until NYI');
        }
    
    });
    compose(RakuAST::StatementModifier::Until);
    parent(RakuAST::StatementModifier::Given, RakuAST::StatementModifier::Loop);
    add-method(RakuAST::StatementModifier::Given, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::Given, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0, Bool, '$sink', 1, 1], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!, :$sink?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
        $sink := nqp::decont($sink);
#line 200 src/Raku/ast/statement-mods.rakumod
        
        $SELF.IMPL-TEMPORARIZE-TOPIC(
            $SELF.expression.IMPL-TO-QAST($context),
            $statement-qast
        )
    
    });
    compose(RakuAST::StatementModifier::Given);
    parent(RakuAST::StatementModifier::For, RakuAST::StatementModifier::Loop);
    parent(RakuAST::StatementModifier::For, RakuAST::ForLoopImplementation);
    add-method(RakuAST::StatementModifier::For, 'IMPL-WRAP-QAST', [RakuAST::StatementModifier::For, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$statement-qast', 0, 0, Bool, '$sink', 1, 1], anon sub IMPL-WRAP-QAST ($SELF_CONT, $context!, $statement-qast!, :$sink?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $statement-qast := nqp::decont($statement-qast);
        $sink := nqp::decont($sink);
#line 213 src/Raku/ast/statement-mods.rakumod
        
        my $expression := $SELF.expression;
        my $expression-qast := $expression.IMPL-TO-QAST($context);

        nqp::istype($expression, RakuAST::QuotedRegex)
                        ??
            $SELF.IMPL-TEMPORARIZE-TOPIC(
                $expression-qast,
                $SELF.IMPL-FOR-QAST(
                    $context, 'serial',
                    ($sink ?? 'sink' !! 'eager'),
                    $expression-qast,
                    $statement-qast))
                        !!
             $SELF.IMPL-FOR-QAST(
                $context, 'serial',
                ($sink ?? 'sink' !! 'eager'),
                $expression-qast,
                $statement-qast)
    
    });
    add-method(RakuAST::StatementModifier::For, 'expression-thunk', [RakuAST::StatementModifier::For, '', 0, 0], anon sub expression-thunk ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 234 src/Raku/ast/statement-mods.rakumod
        
        RakuAST::StatementModifier::For::Thunk.new
    
    });
    compose(RakuAST::StatementModifier::For);
    parent(RakuAST::StatementModifier::For::Thunk, RakuAST::ExpressionThunk);
    add-method(RakuAST::StatementModifier::For::Thunk, 'IMPL-THUNK-SIGNATURE', [RakuAST::StatementModifier::For::Thunk, '', 0, 0], anon sub IMPL-THUNK-SIGNATURE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 243 src/Raku/ast/statement-mods.rakumod
        
        RakuAST::Signature.new(parameters => [
            RakuAST::Parameter.new(
                target => RakuAST::ParameterTarget::Var.new('$_'),
                traits => [
                    RakuAST::Trait::Is.new(name => RakuAST::Name.from-identifier('raw'))
                ]
            )
        ])
    
    });
    compose(RakuAST::StatementModifier::For::Thunk);
    parent(RakuAST::StatementModifier::Condition::Thunk, RakuAST::ExpressionThunk);
    add-attribute(RakuAST::StatementModifier::Condition::Thunk, RakuAST::StatementModifier::Condition, '$!condition');
    add-method(RakuAST::StatementModifier::Condition::Thunk, 'new', [RakuAST::StatementModifier::Condition::Thunk, '', 0, 0, RakuAST::StatementModifier::Condition, '$condition', 0, 0], anon sub new ($SELF_CONT, $condition!) {
        my $SELF := nqp::decont($SELF_CONT);
        $condition := nqp::decont($condition);
#line 260 src/Raku/ast/statement-mods.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::StatementModifier::Condition::Thunk, '$!condition', $condition);
        $obj
    
    });
    add-method(RakuAST::StatementModifier::Condition::Thunk, 'IMPL-THUNK-CODE-QAST', [RakuAST::StatementModifier::Condition::Thunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$target', 0, 0, RakuAST::Expression, '$expression', 0, 0], anon sub IMPL-THUNK-CODE-QAST ($SELF_CONT, $context!, $target!, $expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $target := nqp::decont($target);
        $expression := nqp::decont($expression);
#line 267 src/Raku/ast/statement-mods.rakumod
        

        #TODO handle inner thunks
        $target.push(nqp::getattr($SELF, RakuAST::StatementModifier::Condition::Thunk, '$!condition').IMPL-WRAP-QAST($context, $expression.IMPL-EXPR-QAST($context)));
    
    });
    add-method(RakuAST::StatementModifier::Condition::Thunk, 'IMPL-THUNK-VALUE-QAST', [RakuAST::StatementModifier::Condition::Thunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-THUNK-VALUE-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 273 src/Raku/ast/statement-mods.rakumod
        
        Nil
    
    });
    add-method(RakuAST::StatementModifier::Condition::Thunk, 'is-begin-performed-before-children', [RakuAST::StatementModifier::Condition::Thunk, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 277 src/Raku/ast/statement-mods.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::StatementModifier::Condition::Thunk, 'is-begin-performed-after-children', [RakuAST::StatementModifier::Condition::Thunk, '', 0, 0], anon sub is-begin-performed-after-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 278 src/Raku/ast/statement-mods.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::StatementModifier::Condition::Thunk, 'PERFORM-BEGIN', [RakuAST::StatementModifier::Condition::Thunk, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 280 src/Raku/ast/statement-mods.rakumod
        
        Nil
    
    });
    add-method(RakuAST::StatementModifier::Condition::Thunk, 'PRODUCE-META-OBJECT', [RakuAST::StatementModifier::Condition::Thunk, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 284 src/Raku/ast/statement-mods.rakumod
        
        Nil
    
    });
    add-method(RakuAST::StatementModifier::Condition::Thunk, 'IMPL-QAST-FORM-BLOCK', [RakuAST::StatementModifier::Condition::Thunk, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, str, '$blocktype', 1, 1, RakuAST::Expression, '$expression', 1, 0], anon sub IMPL-QAST-FORM-BLOCK ($SELF_CONT, $context!, :$blocktype?, :$expression!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $blocktype := nqp::decont($blocktype);
        $expression := nqp::decont($expression);
#line 289 src/Raku/ast/statement-mods.rakumod
        
        nqp::die('must not call this ' ~ nqp::getattr($SELF, RakuAST::StatementModifier::Condition::Thunk, '$!condition').dump);
    
    });
    compose(RakuAST::StatementModifier::Condition::Thunk);
    parent(RakuAST::Signature, RakuAST::Meta);
    parent(RakuAST::Signature, RakuAST::ImplicitLookups);
    parent(RakuAST::Signature, RakuAST::Attaching);
    parent(RakuAST::Signature, RakuAST::Term);
    add-attribute(RakuAST::Signature, List, '$!parameters');
    add-attribute(RakuAST::Signature, RakuAST::Node, '$!returns');
    add-attribute(RakuAST::Signature, int, '$!is-on-method');
    add-attribute(RakuAST::Signature, int, '$!is-on-named-method');
    add-attribute(RakuAST::Signature, int, '$!is-on-meta-method');
    add-attribute(RakuAST::Signature, int, '$!is-on-role-method');
    add-attribute(RakuAST::Signature, int, '$!is-on-role-body');
    add-attribute(RakuAST::Signature, RakuAST::Package, '$!method-package');
    add-attribute(RakuAST::Signature, RakuAST::Parameter, '$!implicit-invocant');
    add-attribute(RakuAST::Signature, RakuAST::Parameter, '$!implicit-slurpy-hash');
    add-attribute(RakuAST::Signature, Mu, '$!ins_params');
    add-method(RakuAST::Signature, 'new', [RakuAST::Signature, '', 0, 0, List, '$parameters', 1, 1, RakuAST::Node, '$returns', 1, 1], anon sub new ($SELF_CONT, :$parameters?, :$returns?) {
        my $SELF := nqp::decont($SELF_CONT);
        $parameters := nqp::decont($parameters);
        $returns := nqp::decont($returns);
#line 20 src/Raku/ast/signature.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Signature, '$!parameters',
          $SELF.IMPL-UNWRAP-LIST($parameters)
        ) if $parameters;
        nqp::bindattr($obj, RakuAST::Signature, '$!returns', $returns // RakuAST::Node);
        nqp::bindattr_i($obj, RakuAST::Signature, '$!is-on-method', 0);
        nqp::bindattr_i($obj, RakuAST::Signature, '$!is-on-named-method', 0);
        nqp::bindattr_i($obj, RakuAST::Signature, '$!is-on-meta-method', 0);
        nqp::bindattr_i($obj, RakuAST::Signature, '$!is-on-role-body', 0);
        nqp::bindattr_i($obj, RakuAST::Signature, '$!is-on-role-method', 0);
        $obj
    
    });
    add-method(RakuAST::Signature, 'parameters', [RakuAST::Signature, '', 0, 0], anon sub parameters ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 34 src/Raku/ast/signature.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Signature, '$!parameters') // [])
    
    });
    add-method(RakuAST::Signature, 'parameters-initialized', [RakuAST::Signature, '', 0, 0], anon sub parameters-initialized ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 37 src/Raku/ast/signature.rakumod
        
        nqp::isconcrete(nqp::getattr($SELF, RakuAST::Signature, '$!parameters')) ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Signature, 'attach', [RakuAST::Signature, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 41 src/Raku/ast/signature.rakumod
        
        # If we're the signature for a method...
        if nqp::getattr_i($SELF, RakuAST::Signature, '$!is-on-method') {
            # ... retrieve the enclosing package so we can set an implicit
            # invocant parameter up correctly.
            nqp::bindattr($SELF, RakuAST::Signature, '$!method-package',
                $resolver.find-attach-target('package'));
        }
    
    });
    add-method(RakuAST::Signature, 'set-is-on-method', [RakuAST::Signature, '', 0, 0, Bool, '$is-on-method', 0, 0], anon sub set-is-on-method ($SELF_CONT, $is-on-method!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-on-method := nqp::decont($is-on-method);
#line 51 src/Raku/ast/signature.rakumod
        
        # Stash away the fact whether we should generate implicit parameters
        nqp::bindattr_i($SELF, RakuAST::Signature, '$!is-on-method', $is-on-method ?? 1 !! 0);
    
    });
    add-method(RakuAST::Signature, 'set-is-on-named-method', [RakuAST::Signature, '', 0, 0, Bool, '$is-on-named-method', 0, 0], anon sub set-is-on-named-method ($SELF_CONT, $is-on-named-method!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-on-named-method := nqp::decont($is-on-named-method);
#line 56 src/Raku/ast/signature.rakumod
        
        # Stash away the fact whether we should put a type constraint on the implicit invocant
        nqp::bindattr_i($SELF, RakuAST::Signature, '$!is-on-named-method', $is-on-named-method ?? 1 !! 0);
    
    });
    add-method(RakuAST::Signature, 'set-is-on-meta-method', [RakuAST::Signature, '', 0, 0, Bool, '$is-on-meta-method', 0, 0], anon sub set-is-on-meta-method ($SELF_CONT, $is-on-meta-method!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-on-meta-method := nqp::decont($is-on-meta-method);
#line 61 src/Raku/ast/signature.rakumod
        
        # Stash away the fact whether we should put a type constraint on the implicit invocant
        nqp::bindattr_i($SELF, RakuAST::Signature, '$!is-on-meta-method', $is-on-meta-method ?? 1 !! 0);
    
    });
    add-method(RakuAST::Signature, 'set-is-on-role-method', [RakuAST::Signature, '', 0, 0, Bool, '$is-on-role-method', 0, 0], anon sub set-is-on-role-method ($SELF_CONT, $is-on-role-method!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-on-role-method := nqp::decont($is-on-role-method);
#line 66 src/Raku/ast/signature.rakumod
        
        # We need to know this later when drafting the type for the implicit invocant
        nqp::bindattr_i($SELF, RakuAST::Signature, '$!is-on-role-method', $is-on-role-method ?? 1 !! 0);
    
    });
    add-method(RakuAST::Signature, 'set-is-on-role-body', [RakuAST::Signature, '', 0, 0, Bool, '$is-on-role-body', 0, 0], anon sub set-is-on-role-body ($SELF_CONT, $is-on-role-body!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-on-role-body := nqp::decont($is-on-role-body);
#line 71 src/Raku/ast/signature.rakumod
        
        # Stash away the fact whether we should generate implicit parameters
        nqp::bindattr_i($SELF, RakuAST::Signature, '$!is-on-role-body', $is-on-role-body ?? 1 !! 0);
    
    });
    add-method(RakuAST::Signature, 'provides-return-value', [RakuAST::Signature, '', 0, 0], anon sub provides-return-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 76 src/Raku/ast/signature.rakumod
        
        if nqp::getattr($SELF, RakuAST::Signature, '$!returns') {
            my $value := $SELF.IMPL-RETURN-VALUE();
            nqp::isconcrete($value) || nqp::eqaddr($value, Nil) ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
        }
        else {
            (Bool.WHO)<False>
        }
    
    });
    add-method(RakuAST::Signature, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Signature, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 86 src/Raku/ast/signature.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('Mu')),
            RakuAST::Var::Compiler::Lookup.new('$?CLASS')
        ])
    
    });
    add-method(RakuAST::Signature, 'IMPL-HAS-PARAMETER', [RakuAST::Signature, '', 0, 0, Str, '$name', 0, 0], anon sub IMPL-HAS-PARAMETER ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 93 src/Raku/ast/signature.rakumod
        
        return (Bool.WHO)<True> if $name eq '%_' && nqp::getattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash');
        if nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
            for nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
                return (Bool.WHO)<True> if $_.target && $_.target.lexical-name eq $name;
            }
        }
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::Signature, 'IMPL-ENSURE-IMPLICITS', [RakuAST::Signature, '', 0, 0], anon sub IMPL-ENSURE-IMPLICITS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 103 src/Raku/ast/signature.rakumod
        
        if nqp::getattr_i($SELF, RakuAST::Signature, '$!is-on-method') && !(nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant') || nqp::getattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash')) {
            my @param-asts := nqp::getattr($SELF, RakuAST::Signature, '$!parameters') // [];
            unless @param-asts && @param-asts[0].invocant {
                my $type;
                if nqp::getattr_i($SELF, RakuAST::Signature, '$!is-on-meta-method') {
                    $type := $SELF.get-implicit-lookups.AT-POS(0);
                }
                elsif nqp::getattr_i($SELF, RakuAST::Signature, '$!is-on-named-method') {
                    if nqp::isconcrete(nqp::getattr($SELF, RakuAST::Signature, '$!method-package')) {
                        my $Class := $SELF.get-implicit-lookups.AT-POS(1);
                        if nqp::getattr_i($SELF, RakuAST::Signature, '$!is-on-role-method') && $Class.is-resolved {
                            $type := RakuAST::Type::Simple.new(RakuAST::Name.from-identifier('$?CLASS'));
                            $type.set-resolution($Class.resolution);
                        } else {
                            my $package := nqp::getattr($SELF, RakuAST::Signature, '$!method-package').stubbed-meta-object;
                            my $package-name := $package.HOW.name($package);
                            $type := RakuAST::Type::Simple.new(RakuAST::Name.from-identifier($package-name));
                            $type.set-resolution(RakuAST::VarDeclaration::Implicit::Constant.new(
                                :name($package-name), :value($package), :scope<lexical>));
                        }
                    }
                }
                nqp::bindattr($SELF, RakuAST::Signature, '$!implicit-invocant',
                    RakuAST::Parameter.new(:invocant, :$type));
            }
            unless nqp::getattr_i($SELF, RakuAST::Signature, '$!is-on-meta-method') {
                my $slurpy-hash-seen := 0;
                for @param-asts {
                    if !($_.slurpy =:= RakuAST::Parameter::Slurpy) && $_.target && $_.target.sigil eq '%' {
                        $slurpy-hash-seen := 1;
                        last;
                    }
                }
                unless $slurpy-hash-seen {
                    nqp::bindattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash',
                        RakuAST::Parameter.new(
                            :slurpy(RakuAST::Parameter::Slurpy::Flattened.new),
                            :target(RakuAST::ParameterTarget::Var.new('%_'))
                        )
                    );
                }
            }
        }
        if nqp::getattr_i($SELF, RakuAST::Signature, '$!is-on-role-body') && !nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant') {
            my @param-asts := nqp::getattr($SELF, RakuAST::Signature, '$!parameters') // [];
            unless @param-asts && @param-asts[0].invocant {
                my $invocant := RakuAST::Parameter.new();
                $invocant.add-type-capture(
                    RakuAST::Type::Capture.new(RakuAST::Name.from-identifier('$?CLASS'))
                );
                $invocant.add-type-capture(
                    RakuAST::Type::Capture.new(RakuAST::Name.from-identifier('::?CLASS'))
                );
                nqp::bindattr($SELF, RakuAST::Signature, '$!implicit-invocant', $invocant);
            }
        }
    
    });
    add-method(RakuAST::Signature, 'PRODUCE-META-OBJECT', [RakuAST::Signature, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 162 src/Raku/ast/signature.rakumod
        
        # Produce meta-objects for each parameter.
        $SELF.IMPL-ENSURE-IMPLICITS();
        my @parameters;
        if nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant') {
            @parameters.push(nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant').meta-object);
        }
        if nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
            for nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
                @parameters.push($_.meta-object);
            }
        }
        if nqp::getattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash') {
            @parameters.push(nqp::getattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash').meta-object);
        }

        # Build signature object.
        my $signature := nqp::create(Signature);
        nqp::bindattr($signature, Signature, '@!params', @parameters);
        nqp::bindattr_i($signature, Signature, '$!arity', $SELF.arity);
        nqp::bindattr($signature, Signature, '$!count', $SELF.count);

        # Figure out and set return type.
        nqp::bindattr($signature, Signature, '$!returns', nqp::getattr($SELF, RakuAST::Signature, '$!returns')
            ?? $SELF.IMPL-RETURN-VALUE()
            !! nqp::null());

        $signature
    
    });
    add-method(RakuAST::Signature, 'IMPL-RETURN-VALUE', [RakuAST::Signature, '', 0, 0], anon sub IMPL-RETURN-VALUE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 192 src/Raku/ast/signature.rakumod
        
        if nqp::istype(nqp::getattr($SELF, RakuAST::Signature, '$!returns'), RakuAST::Type) {
            nqp::getattr($SELF, RakuAST::Signature, '$!returns').resolution.compile-time-value
        }
        elsif nqp::istype(nqp::getattr($SELF, RakuAST::Signature, '$!returns'), RakuAST::CompileTimeValue) {
            nqp::getattr($SELF, RakuAST::Signature, '$!returns').compile-time-value
        }
        else {
            nqp::die('--> return constraint must be a type or a constant value');
        }
    
    });
    add-method(RakuAST::Signature, 'IMPL-TO-QAST', [RakuAST::Signature, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 204 src/Raku/ast/signature.rakumod
        
        my $signature := $SELF.meta-object;
        $context.ensure-sc($signature);
        QAST::WVal.new(:value($signature))
    
    });
    add-method(RakuAST::Signature, 'IMPL-QAST-BINDINGS', [RakuAST::Signature, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '$needs-full-binder', 1, 1], anon sub IMPL-QAST-BINDINGS ($SELF_CONT, $context!, :$needs-full-binder?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $needs-full-binder := nqp::decont($needs-full-binder);
#line 210 src/Raku/ast/signature.rakumod
        
        $SELF.IMPL-ENSURE-IMPLICITS();
        my $bindings := QAST::Stmts.new();
        my $parameters := nqp::getattr($SELF, RakuAST::Signature, '$!parameters') // [];
        if $needs-full-binder {
            $bindings.push(QAST::Op.new(
                :op('if'),
                QAST::Op.new(
                    :op('dispatch'),
                    QAST::SVal.new( :value('boot-syscall') ),
                    QAST::SVal.new( :value('bind-will-resume-on-failure') )
                ),
                QAST::Op.new(
                    :op('assertparamcheck'),
                    QAST::Op.new( :op('p6trybindsig') )
                ),
                QAST::Op.new( :op('p6bindsig') )
            ));
        }
        else {
            if nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant') {
                $bindings.push(nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant').IMPL-TO-QAST($context));
            }
            for $parameters {
                $bindings.push($_.IMPL-TO-QAST($context));
            }
            if nqp::getattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash') {
                $bindings.push(nqp::getattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash').IMPL-TO-QAST($context));
            }
        }
        $bindings
    
    });
    add-method(RakuAST::Signature, 'set-default-type', [RakuAST::Signature, '', 0, 0, RakuAST::Type, '$type', 0, 0], anon sub set-default-type ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 243 src/Raku/ast/signature.rakumod
        
        if nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
            for nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
                $_.set-default-type($type);
            }
        }
    
    });
    add-method(RakuAST::Signature, 'arity', [RakuAST::Signature, '', 0, 0], anon sub arity ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 251 src/Raku/ast/signature.rakumod
        
        my int $arity := 0;
        $arity++ if nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant');
        if nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
            for nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
                last unless $_.is-positional && !$_.is-optional;
                $arity++;
            }
        }
        nqp::box_i($arity, Int)
    
    });
    add-method(RakuAST::Signature, 'count', [RakuAST::Signature, '', 0, 0], anon sub count ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 263 src/Raku/ast/signature.rakumod
        
        my int $count := 0;
        $count++ if nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant');
        if nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
            for nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
                if $_.is-positional {
                    $count++;
                }
                elsif !($_.slurpy =:= RakuAST::Parameter::Slurpy)
                         && $_.target.sigil ne '%' {
                    return nqp::box_n(nqp::inf, Num);
                }
            }
        }
        nqp::box_i($count, Int)
    
    });
    add-method(RakuAST::Signature, 'visit-children', [RakuAST::Signature, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 280 src/Raku/ast/signature.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant')) if nqp::getattr($SELF, RakuAST::Signature, '$!implicit-invocant');
        if nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
            for nqp::getattr($SELF, RakuAST::Signature, '$!parameters') {
                $visitor($_);
            }
        }
        $visitor(nqp::getattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash')) if nqp::getattr($SELF, RakuAST::Signature, '$!implicit-slurpy-hash');
        $visitor(nqp::getattr($SELF, RakuAST::Signature, '$!returns')) if nqp::getattr($SELF, RakuAST::Signature, '$!returns');
    
    });
    add-method(RakuAST::Signature, 'IMPL-SIGNATURE-PARAMS', [RakuAST::Signature, '', 0, 0, Mu, '$var', 0, 0], anon sub IMPL-SIGNATURE-PARAMS ($SELF_CONT, $var!) {
        my $SELF := nqp::decont($SELF_CONT);
        $var := nqp::decont($var);
#line 292 src/Raku/ast/signature.rakumod
        
        unless nqp::getattr($SELF, RakuAST::Signature, '$!ins_params') {
            nqp::bindattr($SELF, RakuAST::Signature, '$!ins_params', QAST::Node.unique('__lowered_parameters_'));
            $var.push(
                QAST::Op.new(
                    :op('bind'),
                    QAST::Var.new(:name(nqp::getattr($SELF, RakuAST::Signature, '$!ins_params')), :scope('local'), :decl('var')),
                    QAST::Op.new( # Get @!params on the signature
                        :op('getattr'),
                        QAST::Op.new( # Get signature object
                            :op('getattr'),
                            QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) ),
                            QAST::WVal.new(:value(Code)),
                            QAST::SVal.new(:value('$!signature'))
                        ),
                        QAST::WVal.new(:value(Signature)),
                        QAST::SVal.new(:value('@!params'))
                    )
                )
            );
        }
        QAST::Var.new(:name(nqp::getattr($SELF, RakuAST::Signature, '$!ins_params')), :scope('local'))
    
    });
#line 10 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Signature, 'returns', [], anon sub returns ($self) { nqp::getattr(nqp::decont($self), RakuAST::Signature, '$!returns') });
#line 17 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Signature, 'implicit-invocant', [], anon sub implicit-invocant ($self) { nqp::getattr(nqp::decont($self), RakuAST::Signature, '$!implicit-invocant') });
    compose(RakuAST::Signature);
    parent(RakuAST::FakeSignature, RakuAST::Meta);
    parent(RakuAST::FakeSignature, RakuAST::Term);
    parent(RakuAST::FakeSignature, RakuAST::LexicalScope);
    add-attribute(RakuAST::FakeSignature, RakuAST::Signature, '$!signature');
    add-method(RakuAST::FakeSignature, 'new', [RakuAST::FakeSignature, '', 0, 0, Any, '$signature', 0, 0], anon sub new ($SELF_CONT, $signature!) {
        my $SELF := nqp::decont($SELF_CONT);
        $signature := nqp::decont($signature);
#line 324 src/Raku/ast/signature.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::FakeSignature, '$!signature', $signature);
        $obj
    
    });
    add-method(RakuAST::FakeSignature, 'PRODUCE-META-OBJECT', [RakuAST::FakeSignature, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 330 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::FakeSignature, '$!signature').meta-object
    
    });
    add-method(RakuAST::FakeSignature, 'IMPL-TO-QAST', [RakuAST::FakeSignature, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 334 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::FakeSignature, '$!signature').IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::FakeSignature, 'visit-children', [RakuAST::FakeSignature, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 338 src/Raku/ast/signature.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::FakeSignature, '$!signature'))
    
    });
#line 322 src/Raku/ast/signature.rakumod
    add-method(RakuAST::FakeSignature, 'signature', [], anon sub signature ($self) { nqp::getattr(nqp::decont($self), RakuAST::FakeSignature, '$!signature') });
    compose(RakuAST::FakeSignature);
    parent(RakuAST::Parameter, RakuAST::Meta);
    parent(RakuAST::Parameter, RakuAST::Attaching);
    parent(RakuAST::Parameter, RakuAST::ImplicitLookups);
    parent(RakuAST::Parameter, RakuAST::TraitTarget);
    parent(RakuAST::Parameter, RakuAST::BeginTime);
    parent(RakuAST::Parameter, RakuAST::CheckTime);
    parent(RakuAST::Parameter, RakuAST::Doc::DeclaratorTarget);
    add-attribute(RakuAST::Parameter, RakuAST::Type, '$!type');
    add-attribute(RakuAST::Parameter, RakuAST::ParameterTarget, '$!target');
    add-attribute(RakuAST::Parameter, Mu, '$!names');
    add-attribute(RakuAST::Parameter, Bool, '$!invocant');
    add-attribute(RakuAST::Parameter, Bool, '$!optional');
    add-attribute(RakuAST::Parameter, RakuAST::Parameter::Slurpy, '$!slurpy');
    add-attribute(RakuAST::Parameter, RakuAST::Expression, '$!default');
    add-attribute(RakuAST::Parameter, RakuAST::Expression, '$!where');
    add-attribute(RakuAST::Parameter, RakuAST::Node, '$!owner');
    add-attribute(RakuAST::Parameter, RakuAST::Package, '$!package');
    add-attribute(RakuAST::Parameter, RakuAST::Signature, '$!sub-signature');
    add-attribute(RakuAST::Parameter, List, '$!type-captures');
    add-attribute(RakuAST::Parameter, Mu, '$!value');
    add-method(RakuAST::Parameter, 'new', [RakuAST::Parameter, '', 0, 0, RakuAST::Type, '$type', 1, 1, RakuAST::ParameterTarget, '$target', 1, 1, List, '$names', 1, 1, Bool, '$invocant', 1, 1, Bool, '$optional', 1, 1, RakuAST::Parameter::Slurpy, '$slurpy', 1, 1, List, '$traits', 1, 1, RakuAST::Expression, '$default', 1, 1, RakuAST::Expression, '$where', 1, 1, RakuAST::Signature, '$sub-signature', 1, 1, List, '$type-captures', 1, 1, Mu, '$value', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$type?, :$target?, :$names?, :$invocant?, :$optional?, :$slurpy?, :$traits?, :$default?, :$where?, :$sub-signature?, :$type-captures?, :$value?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
        $target := nqp::decont($target);
        $names := nqp::decont($names);
        $invocant := nqp::decont($invocant);
        $optional := nqp::decont($optional);
        $slurpy := nqp::decont($slurpy);
        $traits := nqp::decont($traits);
        $default := nqp::decont($default);
        $where := nqp::decont($where);
        $sub-signature := nqp::decont($sub-signature);
        $type-captures := nqp::decont($type-captures);
        $value := nqp::decont($value);
        $WHY := nqp::decont($WHY);
#line 382 src/Raku/ast/signature.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Parameter, '$!type',
          $type // RakuAST::Type);
        $target.set-type($type)
          if $target && nqp::can($target, 'set-type') && $type;
        nqp::bindattr($obj, RakuAST::Parameter, '$!target',
          $target // RakuAST::ParameterTarget);
        nqp::bindattr($obj, RakuAST::Parameter, '$!names',
          $SELF.IMPL-NAMES($names));
        nqp::bindattr($obj, RakuAST::Parameter, '$!invocant',
          $invocant ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Parameter, '$!optional',
          nqp::defined($optional)
            ?? ($optional ?? (Bool.WHO)<True> !! (Bool.WHO)<False>)
            !! Bool);
        nqp::bindattr($obj, RakuAST::Parameter, '$!slurpy',
          nqp::istype($slurpy, RakuAST::Parameter::Slurpy)
            ?? $slurpy
            !! RakuAST::Parameter::Slurpy);
        $obj.set-traits($traits);
        nqp::bindattr($obj, RakuAST::Parameter, '$!default',
          $default // RakuAST::Expression);
        nqp::bindattr($obj, RakuAST::Parameter, '$!where',
          $where // RakuAST::Expression);
        nqp::bindattr($obj, RakuAST::Parameter, '$!sub-signature',
          $sub-signature // RakuAST::Signature);
        nqp::bindattr($obj, RakuAST::Parameter, '$!type-captures',
          nqp::defined($type-captures)
            ?? $SELF.IMPL-TYPE-CAPTURES($type-captures)
            !! []);
        nqp::bindattr($obj, RakuAST::Parameter, '$!value', $value)
          if nqp::defined($value);
        $obj.set-WHY($WHY);
        $obj
    
    });
    add-method(RakuAST::Parameter, 'set-type', [RakuAST::Parameter, '', 0, 0, RakuAST::Type, '$type', 0, 0], anon sub set-type ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 419 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!type', $type);
        nqp::getattr($SELF, RakuAST::Parameter, '$!target').set-type($type) if nqp::getattr($SELF, RakuAST::Parameter, '$!target') && nqp::can(nqp::getattr($SELF, RakuAST::Parameter, '$!target'), 'set-type');
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-default-type', [RakuAST::Parameter, '', 0, 0, RakuAST::Type, '$type', 0, 0], anon sub set-default-type ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 425 src/Raku/ast/signature.rakumod
        
        my str $sigil := nqp::getattr($SELF, RakuAST::Parameter, '$!target').sigil;
        unless $sigil eq '@' || $sigil eq '%' || $sigil eq '&' {
            nqp::bindattr($SELF, RakuAST::Parameter, '$!type', $type)
                unless nqp::getattr($SELF, RakuAST::Parameter, '$!type');
        }
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-invocant', [RakuAST::Parameter, '', 0, 0, Bool, '$invocant', 0, 0], anon sub set-invocant ($SELF_CONT, $invocant!) {
        my $SELF := nqp::decont($SELF_CONT);
        $invocant := nqp::decont($invocant);
#line 434 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!invocant', $invocant ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-optional', [RakuAST::Parameter, '', 0, 0], anon sub set-optional ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 439 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!optional', (Bool.WHO)<True>);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-required', [RakuAST::Parameter, '', 0, 0], anon sub set-required ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 444 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!optional', (Bool.WHO)<False>);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'clear-optionality', [RakuAST::Parameter, '', 0, 0], anon sub clear-optionality ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 449 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!optional', Bool);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-slurpy', [RakuAST::Parameter, '', 0, 0, RakuAST::Parameter::Slurpy, '$slurpy', 0, 0], anon sub set-slurpy ($SELF_CONT, $slurpy!) {
        my $SELF := nqp::decont($SELF_CONT);
        $slurpy := nqp::decont($slurpy);
#line 454 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!slurpy', $slurpy);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-names', [RakuAST::Parameter, '', 0, 0, List, '$names', 0, 0], anon sub set-names ($SELF_CONT, $names!) {
        my $SELF := nqp::decont($SELF_CONT);
        $names := nqp::decont($names);
#line 459 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!names', $SELF.IMPL-NAMES($names));
        Nil
    
    });
    add-method(RakuAST::Parameter, 'add-name', [RakuAST::Parameter, '', 0, 0, Str, '$name', 0, 0], anon sub add-name ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 464 src/Raku/ast/signature.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Parameter, '$!names'), $name);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'names', [RakuAST::Parameter, '', 0, 0], anon sub names ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 469 src/Raku/ast/signature.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Parameter, '$!names'))
    
    });
    add-method(RakuAST::Parameter, 'set-default', [RakuAST::Parameter, '', 0, 0, RakuAST::Expression, '$default', 0, 0], anon sub set-default ($SELF_CONT, $default!) {
        my $SELF := nqp::decont($SELF_CONT);
        $default := nqp::decont($default);
#line 473 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!default', $default);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-where', [RakuAST::Parameter, '', 0, 0, RakuAST::Expression, '$where', 0, 0], anon sub set-where ($SELF_CONT, $where!) {
        my $SELF := nqp::decont($SELF_CONT);
        $where := nqp::decont($where);
#line 478 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!where', $where);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-value', [RakuAST::Parameter, '', 0, 0, Mu, '$value', 0, 0], anon sub set-value ($SELF_CONT, $value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $value := nqp::decont($value);
#line 483 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!value', $value);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-sub-signature', [RakuAST::Parameter, '', 0, 0, RakuAST::Expression, '$sub-signature', 0, 0], anon sub set-sub-signature ($SELF_CONT, $sub-signature!) {
        my $SELF := nqp::decont($SELF_CONT);
        $sub-signature := nqp::decont($sub-signature);
#line 488 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!sub-signature', $sub-signature);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'set-type-captures', [RakuAST::Parameter, '', 0, 0, List, '$type-captures', 0, 0], anon sub set-type-captures ($SELF_CONT, $type-captures!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type-captures := nqp::decont($type-captures);
#line 493 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!type-captures',
            $SELF.IMPL-TYPE-CAPTURES($type-captures));
    
    });
    add-method(RakuAST::Parameter, 'add-type-capture', [RakuAST::Parameter, '', 0, 0, RakuAST::Type::Capture, '$type-capture', 0, 0], anon sub add-type-capture ($SELF_CONT, $type-capture!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type-capture := nqp::decont($type-capture);
#line 498 src/Raku/ast/signature.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Parameter, '$!type-captures'), $type-capture);
        Nil
    
    });
    add-method(RakuAST::Parameter, 'type-captures', [RakuAST::Parameter, '', 0, 0], anon sub type-captures ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 503 src/Raku/ast/signature.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Parameter, '$!type-captures'))
    
    });
    add-method(RakuAST::Parameter, 'is-positional', [RakuAST::Parameter, '', 0, 0], anon sub is-positional ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 508 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::Parameter, '$!names') || !(nqp::getattr($SELF, RakuAST::Parameter, '$!slurpy') =:= RakuAST::Parameter::Slurpy) ?? (Bool.WHO)<False> !! (Bool.WHO)<True>
    
    });
    add-method(RakuAST::Parameter, 'is-declared-optional', [RakuAST::Parameter, '', 0, 0], anon sub is-declared-optional ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 513 src/Raku/ast/signature.rakumod
        
        nqp::eqaddr(nqp::getattr($SELF, RakuAST::Parameter, '$!optional'), (Bool.WHO)<True>)
    
    });
    add-method(RakuAST::Parameter, 'is-declared-required', [RakuAST::Parameter, '', 0, 0], anon sub is-declared-required ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 518 src/Raku/ast/signature.rakumod
        
        nqp::eqaddr(nqp::getattr($SELF, RakuAST::Parameter, '$!optional'), (Bool.WHO)<False>)
    
    });
    add-method(RakuAST::Parameter, 'is-optional', [RakuAST::Parameter, '', 0, 0], anon sub is-optional ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 525 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::Parameter, '$!optional') // (nqp::getattr($SELF, RakuAST::Parameter, '$!default') || nqp::getattr($SELF, RakuAST::Parameter, '$!names') ?? (Bool.WHO)<True> !! (Bool.WHO)<False>)
    
    });
    add-method(RakuAST::Parameter, 'IMPL-NAMES', [RakuAST::Parameter, '', 0, 0, Mu, '$names', 0, 0], anon sub IMPL-NAMES ($SELF_CONT, $names!) {
        my $SELF := nqp::decont($SELF_CONT);
        $names := nqp::decont($names);
#line 529 src/Raku/ast/signature.rakumod
        
        my @names;
        if $names {
            for $SELF.IMPL-UNWRAP-LIST($names) {
                if nqp::isstr($_) || nqp::istype($_, Str) {
                    @names.push($_);
                }
                else {
                    nqp::die('Parameter names list must be a list of Str');
                }
            }
        }
        @names
    
    });
    add-method(RakuAST::Parameter, 'IMPL-TYPE-CAPTURES', [RakuAST::Parameter, '', 0, 0, Mu, '$type-captures', 0, 0], anon sub IMPL-TYPE-CAPTURES ($SELF_CONT, $type-captures!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type-captures := nqp::decont($type-captures);
#line 544 src/Raku/ast/signature.rakumod
        
        my @type-captures;
        if $type-captures {
            for $SELF.IMPL-UNWRAP-LIST($type-captures) {
                if nqp::istype($_, RakuAST::Type::Capture) {
                    @type-captures.push($_);
                }
                else {
                    nqp::die('Parameter type-captures list must be a list of RakuAST::Type::Captures');
                }
            }
        }
        @type-captures
    
    });
    add-method(RakuAST::Parameter, 'attach', [RakuAST::Parameter, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 559 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::Parameter, '$!owner',
            $resolver.find-attach-target('block'));
        nqp::bindattr($SELF, RakuAST::Parameter, '$!package',
            $resolver.find-attach-target('package'));
    
    });
    add-method(RakuAST::Parameter, 'visit-children', [RakuAST::Parameter, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 566 src/Raku/ast/signature.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Parameter, '$!type'))          if nqp::getattr($SELF, RakuAST::Parameter, '$!type');
        $visitor(nqp::getattr($SELF, RakuAST::Parameter, '$!target'))        if nqp::getattr($SELF, RakuAST::Parameter, '$!target');
        $visitor(nqp::getattr($SELF, RakuAST::Parameter, '$!default'))       if nqp::getattr($SELF, RakuAST::Parameter, '$!default');
        $visitor(nqp::getattr($SELF, RakuAST::Parameter, '$!where'))         if nqp::getattr($SELF, RakuAST::Parameter, '$!where');
        $visitor(nqp::getattr($SELF, RakuAST::Parameter, '$!sub-signature')) if nqp::getattr($SELF, RakuAST::Parameter, '$!sub-signature');
        $visitor($SELF.WHY)        if $SELF.WHY;
    
    });
    add-method(RakuAST::Parameter, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Parameter, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 575 src/Raku/ast/signature.rakumod
        
        my @lookups;
        my str $sigil := nqp::getattr($SELF, RakuAST::Parameter, '$!target').sigil;
        my str $sigil-type;
        if $sigil eq '@' { nqp::push(@lookups, 'Positional'); nqp::push(@lookups, 'PositionalBindFailover') }
        elsif $sigil eq '%' { nqp::push(@lookups, 'Associative') }
        elsif $sigil eq '&' { nqp::push(@lookups, 'Callable') }

        my @types;
        for @lookups {
            nqp::push(@types, RakuAST::Type::Setting.new(RakuAST::Name.from-identifier($_)));
        }
        $SELF.IMPL-WRAP-LIST(@types)
    
    });
    add-method(RakuAST::Parameter, 'PRODUCE-META-OBJECT', [RakuAST::Parameter, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 590 src/Raku/ast/signature.rakumod
        
        my $parameter := nqp::create(Parameter);
        if nqp::getattr($SELF, RakuAST::Parameter, '$!target') {
            nqp::bindattr_s($parameter, Parameter, '$!variable_name',
                nqp::getattr($SELF, RakuAST::Parameter, '$!target').introspection-name);
        }
        if nqp::getattr($SELF, RakuAST::Parameter, '$!names') {
            my $names-str-list := nqp::list_s();
            for nqp::getattr($SELF, RakuAST::Parameter, '$!names') {
                nqp::push_s($names-str-list, $_);
            }
            nqp::bindattr($parameter, Parameter, '@!named_names', $names-str-list);
        }
        nqp::bindattr_i($parameter, Parameter, '$!flags', $SELF.IMPL-FLAGS);
        my $type := $SELF.IMPL-NOMINAL-TYPE();
        nqp::bindattr($parameter, Parameter, '$!type', $type);
        if nqp::getattr($SELF, RakuAST::Parameter, '$!target') {
            my $name := nqp::getattr($SELF, RakuAST::Parameter, '$!target').introspection-name;
            my constant SIG_ELEM_IS_RW   := 256;
            my constant SIG_ELEM_IS_COPY := 512;
            for $SELF.IMPL-UNWRAP-LIST($SELF.traits) {
                if nqp::istype($_, RakuAST::Trait::Is) && ($_.name.canonicalize eq 'copy' || $_.name.canonicalize eq 'rw') {
                    my $cd := ContainerDescriptor.new(:of($type), :$name, :default($type), :dynamic(0));
                    nqp::bindattr($parameter, Parameter, '$!container_descriptor', $cd);
                    last;
                }
            }
        }
        my @post_constraints;
        if nqp::getattr($SELF, RakuAST::Parameter, '$!where') {
            nqp::push(@post_constraints, nqp::getattr($SELF, RakuAST::Parameter, '$!where').IMPL-CURRIED || nqp::getattr($SELF, RakuAST::Parameter, '$!where').meta-object);
        }
        if nqp::defined(nqp::getattr($SELF, RakuAST::Parameter, '$!value')) {
            nqp::push(@post_constraints, nqp::getattr($SELF, RakuAST::Parameter, '$!value'));
        }
        if nqp::defined(nqp::getattr($SELF, RakuAST::Parameter, '$!type')) && nqp::getattr($SELF, RakuAST::Parameter, '$!type').meta-object.HOW.archetypes.nominalizable {
            nqp::push(@post_constraints, nqp::getattr($SELF, RakuAST::Parameter, '$!type').meta-object);
        }
        if nqp::elems(@post_constraints) {
            nqp::bindattr($parameter, Parameter, '@!post_constraints', @post_constraints);
        }
        if nqp::getattr($SELF, RakuAST::Parameter, '$!sub-signature') {
            nqp::bindattr($parameter, Parameter, '$!sub_signature', nqp::getattr($SELF, RakuAST::Parameter, '$!sub-signature').meta-object);
        }
        if nqp::getattr($SELF, RakuAST::Parameter, '$!type-captures') {
            my @type-captures := nqp::list_s;
            for nqp::getattr($SELF, RakuAST::Parameter, '$!type-captures') {
                nqp::push_s(@type-captures, $_.lexical-name);
            }
            nqp::bindattr($parameter, Parameter, '@!type_captures', @type-captures);
        }
        # TODO further setup
        $parameter
    
    });
    add-method(RakuAST::Parameter, 'IMPL-FLAGS', [RakuAST::Parameter, '', 0, 0], anon sub IMPL-FLAGS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 645 src/Raku/ast/signature.rakumod
        
        my constant SIG_ELEM_INVOCANT            := 64;
        my constant SIG_ELEM_MULTI_INVOCANT      := 128;
        my constant SIG_ELEM_IS_RAW              := 1024;
        my constant SIG_ELEM_IS_OPTIONAL         := 2048;
        my constant SIG_ELEM_ARRAY_SIGIL         := 4096;
        my constant SIG_ELEM_HASH_SIGIL          := 8192;
        my constant SIG_ELEM_UNDEFINED_ONLY      := 65536;
        my constant SIG_ELEM_DEFINED_ONLY        := 131072;
        my constant SIG_ELEM_TYPE_GENERIC        := 524288;
        my constant SIG_ELEM_NATIVE_INT_VALUE    := 2097152;
        my constant SIG_ELEM_NATIVE_UINT_VALUE   := 134217728;
        my constant SIG_ELEM_NATIVE_NUM_VALUE    := 4194304;
        my constant SIG_ELEM_NATIVE_STR_VALUE    := 8388608;
        my constant SIG_ELEM_CODE_SIGIL          := 33554432;
        my constant SIG_ELEM_IS_COERCIVE         := 67108864;

        my $sigil := nqp::getattr($SELF, RakuAST::Parameter, '$!target').sigil;
        my int $flags;
        $flags := $flags +| SIG_ELEM_INVOCANT if nqp::getattr($SELF, RakuAST::Parameter, '$!invocant');
        $flags := $flags +| SIG_ELEM_MULTI_INVOCANT;
        $flags := $flags +| SIG_ELEM_IS_OPTIONAL if $SELF.is-optional;
        if $sigil eq '@' {
            $flags := $flags +| SIG_ELEM_ARRAY_SIGIL;
        }
        elsif $sigil eq '%' {
            $flags := $flags +| SIG_ELEM_HASH_SIGIL;
        }
        elsif $sigil eq '&' {
            $flags := $flags +| SIG_ELEM_CODE_SIGIL;
        }
        if nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!target'), RakuAST::ParameterTarget::Term) {
            $flags := $flags +| SIG_ELEM_IS_RAW;
        }
        if nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!type'), RakuAST::Type::Definedness) {
            $flags := $flags +| (nqp::getattr($SELF, RakuAST::Parameter, '$!type').definite ?? SIG_ELEM_DEFINED_ONLY !! SIG_ELEM_UNDEFINED_ONLY);
        }
        if nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!type'), RakuAST::Type::Coercion) {
            $flags := $flags +| SIG_ELEM_IS_COERCIVE;
        }
        if nqp::getattr($SELF, RakuAST::Parameter, '$!type') {
            my $meta-object := nqp::getattr($SELF, RakuAST::Parameter, '$!type').meta-object;
            if $meta-object.HOW.archetypes.generic {
                $flags := $flags +| SIG_ELEM_TYPE_GENERIC;
            }
            my $primspec := nqp::objprimspec(nqp::getattr($SELF, RakuAST::Parameter, '$!type').meta-object);
            if $primspec == 1 {
                $flags := $flags +| SIG_ELEM_NATIVE_INT_VALUE;
            }
            elsif $primspec == 2 {
                $flags := $flags +| SIG_ELEM_NATIVE_NUM_VALUE;
            }
            elsif $primspec == 3 {
                $flags := $flags +| SIG_ELEM_NATIVE_STR_VALUE;
            }
            elsif $primspec == 10 {
                $flags := $flags +| SIG_ELEM_NATIVE_UINT_VALUE;
            }
        }
        $flags := $flags +| nqp::getattr($SELF, RakuAST::Parameter, '$!slurpy').IMPL-FLAGS($sigil);
        $flags
    
    });
    add-method(RakuAST::Parameter, 'IMPL-NOMINAL-TYPE', [RakuAST::Parameter, '', 0, 0], anon sub IMPL-NOMINAL-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 708 src/Raku/ast/signature.rakumod
        
        my str $sigil := nqp::getattr($SELF, RakuAST::Parameter, '$!target').sigil;
        if $sigil eq '@' || $sigil eq '%' || $sigil eq '&' {
            my $sigil-type :=
              $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
            nqp::getattr($SELF, RakuAST::Parameter, '$!type')
                ?? $sigil-type.HOW.parameterize($sigil-type,
                        nqp::getattr($SELF, RakuAST::Parameter, '$!type').resolution.compile-time-value)
                !! $sigil-type
        }
        else {
            if nqp::getattr($SELF, RakuAST::Parameter, '$!type') {
                my $type       := nqp::getattr($SELF, RakuAST::Parameter, '$!type').meta-object;
                my $archetypes := $type.HOW.archetypes;
                $archetypes.nominal
                  || $archetypes.coercive
                  || $archetypes.generic
                  ?? $type
                  !! $archetypes.nominalizable
                    ?? $type.HOW.nominalize($type)
                    !! $type
            }
            else {
                Mu
            }
        }
    
    });
    add-method(RakuAST::Parameter, 'PERFORM-BEGIN', [RakuAST::Parameter, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 736 src/Raku/ast/signature.rakumod
        
        $SELF.apply-traits($resolver, $context, $SELF);

        if nqp::getattr($SELF, RakuAST::Parameter, '$!where') && (! nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!where'), RakuAST::Code) || nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!where'), RakuAST::RegexThunk)) && !nqp::getattr($SELF, RakuAST::Parameter, '$!where').IMPL-CURRIED {
            my $block := RakuAST::Block.new(
                body => RakuAST::Blockoid.new(
                    RakuAST::StatementList.new(
                        RakuAST::Statement::Expression.new(
                            expression => RakuAST::ApplyPostfix.new(
                                operand => RakuAST::ApplyPostfix.new(
                                    operand => nqp::getattr($SELF, RakuAST::Parameter, '$!where'),
                                    postfix => RakuAST::Call::Method.new(
                                        name => RakuAST::Name.from-identifier('ACCEPTS'),
                                        args => RakuAST::ArgList.new(
                                            RakuAST::Var::Lexical.new('$_'),
                                        ),
                                    ),
                                ),
                                postfix => RakuAST::Call::Method.new(
                                    name => RakuAST::Name.from-identifier('Bool'),
                                ),
                            ),
                        ),
                    ),
                ),
            );
            $block.IMPL-CHECK($resolver, $context, (Bool.WHO)<False>);
            nqp::bindattr($SELF, RakuAST::Parameter, '$!where', $block);
        }
    
    });
    add-method(RakuAST::Parameter, 'PERFORM-CHECK', [RakuAST::Parameter, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 767 src/Raku/ast/signature.rakumod
        
        if nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!owner'), RakuAST::Routine) {
            my $name := nqp::getattr($SELF, RakuAST::Parameter, '$!owner').name;
            if $name && $name.is-identifier && $name.canonicalize eq 'MAIN' {
                for $SELF.IMPL-UNWRAP-LIST($SELF.traits) {
                    if nqp::istype($_, RakuAST::Trait::Is) && $_.name.canonicalize eq 'copy' {
                        $SELF.add-worry:
                          $resolver.build-exception: 'X::AdHoc',
                            payload => "'is rw' on parameters of 'sub MAIN' usually cannot be satisfied.\nDid you mean 'is copy'?";
                        last;
                    }
                }
            }
        }

        if nqp::getattr($SELF, RakuAST::Parameter, '$!default') {
            # Ensure this is something that a default can go on.
            if nqp::isconcrete(nqp::getattr($SELF, RakuAST::Parameter, '$!slurpy')) {
                $SELF.add-sorry:
                  $resolver.build-exception: 'X::Parameter::Default',
                    how => 'slurpy', parameter => nqp::getattr($SELF, RakuAST::Parameter, '$!target').name;
            }
            if $SELF.is-declared-required {
                $SELF.add-sorry:
                  $resolver.build-exception: 'X::Parameter::Default',
                    how => 'required', parameter => nqp::getattr($SELF, RakuAST::Parameter, '$!target').name;
            }

            # If it doesn't have a compile-time value, we'll need to thunk it.
            unless nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!default'), RakuAST::CompileTimeValue) {
                nqp::getattr($SELF, RakuAST::Parameter, '$!default').wrap-with-thunk(RakuAST::ParameterDefaultThunk.new($SELF));
                nqp::getattr($SELF, RakuAST::Parameter, '$!default').visit-thunks(-> $thunk { $thunk.ensure-begin-performed($resolver, $context) });
            }
        }

        if nqp::getattr($SELF, RakuAST::Parameter, '$!sub-signature') {
            nqp::getattr($SELF, RakuAST::Parameter, '$!owner').set-custom-args;
        }

        my $param-obj := $SELF.meta-object;
        my $param-type := nqp::getattr($param-obj, Parameter, '$!type');
        my $ptype-archetypes := $param-type.HOW.archetypes($param-type);
        my int $is-generic  := $ptype-archetypes.generic;
        my int $is-coercive := $ptype-archetypes.coercive;
        my int $was-slurpy := !(nqp::getattr($SELF, RakuAST::Parameter, '$!slurpy') =:= RakuAST::Parameter::Slurpy);

        if $is-generic && $is-coercive && !$was-slurpy && !($param-type =:= Mu) && !$SELF.invocant {
            nqp::getattr($SELF, RakuAST::Parameter, '$!owner').set-custom-args;
        }
    
    });
    add-method(RakuAST::Parameter, 'IMPL-TO-QAST', [RakuAST::Parameter, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 818 src/Raku/ast/signature.rakumod
        
        nqp::die('shouldnt get here') if nqp::getattr($SELF, RakuAST::Parameter, '$!sub-signature');
        # Flag constants we need to pay attention to.
        my constant SIG_ELEM_IS_RW               := 256;
        my constant SIG_ELEM_IS_COPY             := 512;
        my constant SIG_ELEM_IS_RAW              := 1024;
        my constant SIG_ELEM_IS_COERCIVE         := 67108864;
        my @iscont-ops := ['iscont', 'iscont_i', 'iscont_n', 'iscont_s', 'iscont_i', 'iscont_i', 'iscont_i', 'iscont_u', 'iscont_u', 'iscont_u', 'iscont_u'];

        # Get the parameter meta-object, since traits can change some things.
        my $param-obj := $SELF.meta-object;
        my int $flags := nqp::getattr_i($param-obj, Parameter, '$!flags');
        my int $is-rw := $flags +& SIG_ELEM_IS_RW;

        my $param-type := nqp::getattr($param-obj, Parameter, '$!type');
        my $ptype-archetypes := $param-type.HOW.archetypes($param-type);
        my int $is-generic  := $ptype-archetypes.generic;
        my int $is-coercive := $ptype-archetypes.coercive;
        my $nominal-type := !$is-generic && $ptype-archetypes.nominalizable
                            ?? $param-type.HOW.nominalize($param-type)
                            !! $param-type;
        my int $spec  := nqp::objprimspec($nominal-type);

        # Take the parameter into a temporary local.
        my $name := QAST::Node.unique("__lowered_param");
        my $param-qast := QAST::Var.new( :decl('param'), :scope('local'), :$name );
        my $temp-qast-var := QAST::Var.new( :name($name), :scope('local') );

        # Deal with nameds and slurpies.
        my int $was-slurpy;
        my @prepend;
        if nqp::getattr($SELF, RakuAST::Parameter, '$!names') {
            $param-qast.named(nqp::elems(nqp::getattr($SELF, RakuAST::Parameter, '$!names')) == 1 ?? nqp::getattr($SELF, RakuAST::Parameter, '$!names')[0] !! nqp::getattr($SELF, RakuAST::Parameter, '$!names'));
        }
        elsif !(nqp::getattr($SELF, RakuAST::Parameter, '$!slurpy') =:= RakuAST::Parameter::Slurpy) {
            nqp::getattr($SELF, RakuAST::Parameter, '$!slurpy').IMPL-TRANSFORM-PARAM-QAST($context, $param-qast, $temp-qast-var,
                nqp::getattr($SELF, RakuAST::Parameter, '$!target').sigil, @prepend);
            $was-slurpy := 1;
        }

        # HLLize before type checking unless it was a slurpy (in which
        # case we know full well what we produced) or it's a native type
        if !$was-slurpy && ($is-generic || !$spec) {
            $param-qast.push(QAST::Op.new(
                :op('bind'),
                $temp-qast-var,
                QAST::Op.new( :op('hllize'), $temp-qast-var )
            ));
        }

        # We may need to decontainerize it; produce that lazily if so.
        my $decont-qast-var := $was-slurpy ?? $temp-qast-var !! Nil;
        my $get-decont-var := -> {
            unless $decont-qast-var {
                my str $name := QAST::Node.unique("__decont_param");
                $param-qast.push(QAST::Op.new(
                    :op('bind'),
                    QAST::Var.new( :$name, :scope('local'), :decl('var') ),
                    QAST::Op.new( :op('decont'), $temp-qast-var )
                ));
                $decont-qast-var := QAST::Var.new( :$name, :scope('local') );
            }
            $decont-qast-var
        }

        # Add type checks.
        if !$is-generic && $spec {
            if $is-rw {
                $param-qast.push(QAST::ParamTypeCheck.new(QAST::Op.new(
                    :op(@iscont-ops[$spec]),
                    $temp-qast-var
                )));
            }
            else {
                $context.ensure-sc($param-type);
                $param-qast.returns($param-type);
            }
        }
        elsif !$was-slurpy {
            # Type-check, unless it's Mu, in which case skip it.
            if $is-generic && !$is-coercive {
                my $genericname := $param-type.HOW.name(nqp::getattr($SELF, RakuAST::Parameter, '$!package').stubbed-meta-object);
                $param-qast.push(QAST::ParamTypeCheck.new(QAST::Op.new(
                    :op('istype_nd'),
                    $get-decont-var(),
                    QAST::Var.new( :name($genericname), :scope<typevar> )
                )));
            }
            elsif !($param-type =:= Mu) {
                if !$ptype-archetypes.generic {
                    if nqp::getattr($SELF, RakuAST::Parameter, '$!target').sigil eq '@' {
                        my $PositionalBindFailover := $SELF.get-implicit-lookups.AT-POS(1).resolution.compile-time-value;
                        $param-qast.push(QAST::Op.new(
                            :op('if'),
                            QAST::Op.new(
                                :op('istype_nd'),
                                $get-decont-var(),
                                QAST::WVal.new( :value($PositionalBindFailover) )
                            ),
                            QAST::Op.new(
                                :op('bind'),
                                $get-decont-var(),
                                QAST::Op.new(
                                    :op('decont'),
                                    QAST::Op.new(
                                        :op('bind'),
                                        $temp-qast-var,
                                        QAST::Op.new(
                                            :op('callmethod'), :name('cache'),
                                            $get-decont-var()
                                        ))))));
                    }

                    # Try to be smarter with coercions. We don't have to do full typecheck on them, which results in
                    # additional call to a HOW method. Instead it's ok to check if value matches target or
                    # constraint types.
                    if $is-coercive && nqp::can($param-type.HOW, 'target_type') {
                        my $constraint-type := $param-type.HOW.constraint_type($param-type);
                        $context.ensure-sc($constraint-type);
                        $param-qast.push(QAST::ParamTypeCheck.new(QAST::Op.new(
                                :op('unless'),
                                QAST::Op.new(
                                    :op('istype_nd'),
                                    $get-decont-var(),
                                    QAST::WVal.new( :value($param-type.HOW.target_type($param-type) ))),
                                QAST::Op.new(
                                    :op('istype_nd'),
                                    $get-decont-var(),
                                    QAST::WVal.new( :value($constraint-type))))));
                    }
                    else {
                        $context.ensure-sc($param-type);
                        $param-qast.push(QAST::ParamTypeCheck.new(QAST::Op.new(
                            :op('istype_nd'),
                            $get-decont-var(),
                            QAST::WVal.new( :value($param-type) )
                        )));
                    }
                }
            }
            if nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!type').IMPL-TARGET-TYPE, RakuAST::Type::Definedness) {
                if nqp::getattr($SELF, RakuAST::Parameter, '$!type').IMPL-TARGET-TYPE.definite {
                    $param-qast.push(QAST::ParamTypeCheck.new(QAST::Op.new(
                        :op('isconcrete_nd'),
                        $get-decont-var()
                    )));
                }
                else {
                    $param-qast.push(QAST::ParamTypeCheck.new(QAST::Op.new(
                        :op('not_i'),
                        QAST::Op.new(
                            :op('isconcrete_nd'),
                            $get-decont-var()
                        ))));
                }
            }
            # If marked `is rw`, do rw check.
            if $is-rw {
                $param-qast.push(QAST::ParamTypeCheck.new(QAST::Op.new(
                    :op('isrwcont'),
                    $temp-qast-var,
                )));
            }
        }

        my $inst-param;
        # Make sure we have (possibly instantiated) parameter object ready when we need it
        if $is-generic || nqp::getattr($SELF, RakuAST::Parameter, '$!sub-signature') {
            my $inst-param-name := QAST::Node.unique('__lowered_param_obj_');
            my $i := 0; #FIXME TODO XXX Need a way to know which parameter this is in the signature!
            $param-qast.push( # Fetch instantiated Parameter object
                QAST::Op.new(
                    :op('bind'),
                    QAST::Var.new( :name($inst-param-name), :scope('local'), :decl('var') ),
                    QAST::Op.new(
                        :op('atpos'),
                        nqp::getattr($SELF, RakuAST::Parameter, '$!owner').signature.IMPL-SIGNATURE-PARAMS($param-qast),
                        QAST::IVal.new(:value($i)))));
            $inst-param := QAST::Var.new(:name($inst-param-name), :scope<local>);
        }

        # Handle coercion.
        # For a generic we can't know beforehand if it's going to be a coercive or any other nominalizable. Thus
        # we have to fetch the instantiated parameter object and do run-time processing.
        if $is-generic {
            # For a generic-typed parameter get its instantiated clone and see if its type is a coercion.
            $get-decont-var := -> { NQPMu }
            my $low-param-type := QAST::Node.unique('__lowered_param_type');
            $param-qast.push( # Get actual parameter type
                            QAST::Op.new(
                                :op('bind'),
                                QAST::Var.new(:name($low-param-type), :scope('local'), :decl('var')),
                                QAST::Op.new(
                                    :op('getattr'),
                                    $inst-param,
                                    QAST::WVal.new(:value(Parameter)),
                                    QAST::SVal.new(:value('$!type')))));
            $param-qast.push(
                QAST::Op.new(
                    :op('if'),
                    QAST::Op.new(
                        :op('istype'),
                        $temp-qast-var,
                        QAST::Var.new(:name($low-param-type), :scope('local'))
                    ),
                    QAST::Op.new(
                        :op('if'),
                        QAST::Op.new(
                            :op('bitand_i'),
                            QAST::Op.new(
                                :op('getattr'),
                                $inst-param,
                                QAST::WVal.new(:value(Parameter)),
                                QAST::SVal.new(:value('$!flags'))
                            ),
                            QAST::IVal.new(:value(SIG_ELEM_IS_COERCIVE))
                        ),
                        QAST::Op.new(
                            :op('bind'),
                            $temp-qast-var,
                            QAST::Op.new(
                                :op<dispatch>,
                                QAST::SVal.new(:value<raku-coercion>),
                                QAST::Var.new(:name($low-param-type), :scope<local>),
                                $temp-qast-var)))));
        }
        elsif $is-coercive {
            $get-decont-var := -> { NQPMu }
            my $coercion-type := $param-type.HOW.wrappee($param-type, :coercion);
            my $target-type := $coercion-type.HOW.target_type($coercion-type);
            $context.ensure-sc($param-type);
            $context.ensure-sc($target-type);
            $param-qast.push(
                QAST::Op.new(
                    :op('unless'),
                    QAST::Op.new(
                        :op('istype'),
                        $temp-qast-var,
                        QAST::WVal.new( :value($target-type) )
                    ),
                    QAST::Op.new(
                        :op('bind'),
                        $temp-qast-var,
                        QAST::Op.new(
                            :op<dispatch>,
                            QAST::SVal.new(:value<raku-coercion>),
                            QAST::WVal.new(:value($param-type)),
                            $temp-qast-var))));
        }

        # If it's optional, do any default handling.
        if $SELF.is-optional {
            if nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!default'), RakuAST::CompileTimeValue) {
                # Literal default value, so just insert it.
                $param-qast.default(nqp::getattr($SELF, RakuAST::Parameter, '$!default').IMPL-TO-QAST($context));
            }
            elsif nqp::getattr($SELF, RakuAST::Parameter, '$!default') {
                # Default has been thunked, so call the produced thunk.
                $param-qast.default(QAST::Op.new(
                    :op('call'),
                    nqp::getattr($SELF, RakuAST::Parameter, '$!default').IMPL-TO-QAST($context)
                ));
            }
            else {
                my $sigil := nqp::getattr($SELF, RakuAST::Parameter, '$!target').sigil;
                if (my $is-array := $sigil eq '@') || $sigil eq '%' {
                    my $role := $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
                    my $base-type := $is-array ?? Array !! Hash;
                    my $value := nqp::istype($nominal-type, $role) && nqp::can($nominal-type.HOW, 'role_arguments')
                        ?? $base-type.HOW.parameterize($base-type, |$nominal-type.HOW.role_arguments($nominal-type))
                        !! $base-type;
                    $context.ensure-sc($value);
                    $param-qast.default(
                        QAST::Op.new(
                            :op<create>,
                            QAST::WVal.new(value => $value)
                        )
                    );
                }
                else {
                    if $spec == 1 {
                        $param-qast.default(QAST::IVal.new( :value(0) ));
                    }
                    elsif $spec == 2 {
                        $param-qast.default(QAST::NVal.new( :value(0.0) ));
                    }
                    elsif $spec == 3 {
                        $param-qast.default(QAST::SVal.new( :value('') ));
                    }
                    elsif $spec == 10 {
                        $param-qast.default(QAST::IVal.new( :value(0) ));
                    }
                    else {
                        $param-qast.default(QAST::WVal.new( :value($nominal-type) ));
                    }
                }
            }
        }

        if nqp::defined(nqp::getattr($SELF, RakuAST::Parameter, '$!value')) {
            my $value := nqp::getattr($SELF, RakuAST::Parameter, '$!value');
            my $wval  := QAST::WVal.new: :value($value);
            $context.ensure-sc($value);
            my $type := nqp::getattr($SELF, RakuAST::Parameter, '$!type').name.canonicalize;
            $param-qast.push: QAST::ParamTypeCheck.new:
                $type eq 'Int'
                    ?? QAST::Op.new(:op<if>,
                        QAST::Op.new(:op<isconcrete>, $temp-qast-var),
                        QAST::Op.new(:op<iseq_I>, $wval,
                          QAST::Op.new: :op<decont>, $temp-qast-var))
                    !! $type eq 'Num'
                      ?? QAST::Op.new(:op<if>,
                          QAST::Op.new(:op<isconcrete>, $temp-qast-var),
                          QAST::Op.new(:op<unless>,
                            QAST::Op.new(:op<iseq_n>, $wval, $temp-qast-var), # equal
                            QAST::Op.new(:op<if>, # or both are NaNs
                              QAST::Op.new(:op<isne_n>, $wval, $wval),
                              QAST::Op.new(:op<isne_n>, $temp-qast-var, $temp-qast-var))))
                      !! QAST::Op.new(:op<if>,
                          QAST::Op.new(:op<isconcrete>, $temp-qast-var),
                          QAST::Op.new(:op<iseq_s>, $wval, $temp-qast-var));
        }

        $context.ensure-sc(nqp::getattr($param-obj, Parameter, '$!container_descriptor'));

        # Bind parameter into its target.
        if $SELF.invocant {
            $param-qast.push(QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name('self'), :scope('lexical') ),
                $get-decont-var() // QAST::Op.new(
                        :op('decont'),
                        $temp-qast-var,
                    )));
        }
        if nqp::isconcrete(nqp::getattr($SELF, RakuAST::Parameter, '$!target')) {
            if $flags +& (SIG_ELEM_IS_RW +| SIG_ELEM_IS_RAW) {
                # Don't do any decontainerization (rw or raw).
                $param-qast.push(nqp::getattr($SELF, RakuAST::Parameter, '$!target').IMPL-BIND-QAST($context, $temp-qast-var));
            }
            else {
                my $value := $get-decont-var() // $temp-qast-var;

                if $flags +& SIG_ELEM_IS_COPY {
                    my $sigil := nqp::getattr($SELF, RakuAST::Parameter, '$!target').sigil;
                    if (my $is-array := $sigil eq '@') || $sigil eq '%' {
                        my $copy-var := $name ~ '_copy';
                        $param-qast.push(
                            QAST::Op.new( :op<bind>,
                                QAST::Var.new( :name($copy-var), :scope<local>, :decl<var> ),
                                QAST::Op.new( :op<create>,
                                    QAST::WVal.new( :value($is-array ?? Array !! Hash) )
                                )
                            )
                        );
                        $param-qast.push(
                            QAST::Op.new( :op<callmethod>, :name<STORE>,
                                QAST::Var.new( :name($copy-var), :scope<local> ),
                                $value
                            )
                        );
                        $value := QAST::Var.new( :name($copy-var), :scope<local> );
                    }
                    else {
                        my $container_descriptor := $param-obj.container_descriptor;
                        if $container_descriptor {
                            $value := QAST::Op.new(
                                :op<p6scalarwithvalue>,
                                QAST::WVal.new(:value($container_descriptor)),
                                $value
                            );
                        }
                        else {
                            $value := QAST::Op.new(
                                :op('p6bindattrinvres'),
                                QAST::Op.new(
                                    :op('create'),
                                    QAST::WVal.new( :value(Scalar) )
                                ),
                                QAST::WVal.new( :value(Scalar) ),
                                QAST::SVal.new( :value('$!value') ),
                                $value
                            );
                        }
                    }
                }

                # Give the decontainerized thing.
                $param-qast.push(nqp::getattr($SELF, RakuAST::Parameter, '$!target').IMPL-BIND-QAST($context, $value));
            }
        }
        for nqp::getattr($SELF, RakuAST::Parameter, '$!type-captures') {
            $param-qast.push($_.IMPL-BIND-QAST($context, $temp-qast-var));
        }

        if nqp::getattr($SELF, RakuAST::Parameter, '$!where') {
            $param-qast.push(
                QAST::ParamTypeCheck.new(
                    QAST::Op.new(
                        :op('call'),
                        nqp::getattr($SELF, RakuAST::Parameter, '$!where').IMPL-TO-QAST($context),
                        $temp-qast-var
                    )
                )
            );
        }

        # Take care of checking against provided subset types and other nominalizable types.
        # TODO: Investigate breakage -- No such method 'ACCEPTS' for invocant of type '::?CLASS:D'
        #        if nqp::defined($!type) && $!type.meta-object.HOW.archetypes.nominalizable {
        if nqp::defined(nqp::getattr($SELF, RakuAST::Parameter, '$!type')) && nqp::istype(nqp::getattr($SELF, RakuAST::Parameter, '$!type').meta-object.HOW, Perl6::Metamodel::SubsetHOW) {
            my $type-object := nqp::getattr($SELF, RakuAST::Parameter, '$!type').meta-object;
            $context.ensure-sc($type-object);
            $param-qast.push(
                QAST::ParamTypeCheck.new(
                    QAST::Op.new(
                        :op('callmethod'), :name('ACCEPTS'),
                        QAST::WVal.new( :value($type-object) ),
                        $temp-qast-var
                    )
                )
            );
        }

        @prepend ?? QAST::Stmts.new( |@prepend, $param-qast ) !! $param-qast
    
    });
#line 362 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'where', [], anon sub where ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!where') });
#line 367 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!value') });
#line 355 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'type', [], anon sub type ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!type') });
#line 356 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'target', [], anon sub target ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!target') });
#line 365 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'sub-signature', [], anon sub sub-signature ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!sub-signature') });
#line 360 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'slurpy', [], anon sub slurpy ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!slurpy') });
#line 359 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'optional', [], anon sub optional ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!optional') });
#line 358 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'invocant', [], anon sub invocant ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!invocant') });
#line 361 src/Raku/ast/signature.rakumod
    add-method(RakuAST::Parameter, 'default', [], anon sub default ($self) { nqp::getattr(nqp::decont($self), RakuAST::Parameter, '$!default') });
    compose(RakuAST::Parameter);
    parent(RakuAST::ParameterTarget, RakuAST::Node);
    add-method(RakuAST::ParameterTarget, 'sigil', [RakuAST::ParameterTarget, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1253 src/Raku/ast/signature.rakumod
         '' 
    });
    add-method(RakuAST::ParameterTarget, 'name', [RakuAST::ParameterTarget, '', 0, 0], anon sub name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1254 src/Raku/ast/signature.rakumod
         '' 
    });
    compose(RakuAST::ParameterTarget);
    parent(RakuAST::ParameterTarget::Var, RakuAST::ParameterTarget);
    parent(RakuAST::ParameterTarget::Var, RakuAST::TraitTarget);
    parent(RakuAST::ParameterTarget::Var, RakuAST::Meta);
    parent(RakuAST::ParameterTarget::Var, RakuAST::ContainerCreator);
    parent(RakuAST::ParameterTarget::Var, RakuAST::BeginTime);
    parent(RakuAST::ParameterTarget::Var, RakuAST::CheckTime);
    parent(RakuAST::ParameterTarget::Var, RakuAST::Attaching);
    add-attribute(RakuAST::ParameterTarget::Var, str, '$!name');
    add-attribute(RakuAST::ParameterTarget::Var, RakuAST::Type, '$!type');
    add-attribute(RakuAST::ParameterTarget::Var, Mu, '$!of');
    add-attribute(RakuAST::ParameterTarget::Var, RakuAST::Package, '$!attribute-package');
    add-attribute(RakuAST::ParameterTarget::Var, RakuAST::VarDeclaration::Simple, '$!declaration');
    add-attribute(RakuAST::ParameterTarget::Var, str, '$!scope');
    add-method(RakuAST::ParameterTarget::Var, 'new', [RakuAST::ParameterTarget::Var, '', 0, 0, str, '$name', 0, 0, Bool, '$forced-dynamic', 1, 1], anon sub new ($SELF_CONT, $name!, :$forced-dynamic?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $forced-dynamic := nqp::decont($forced-dynamic);
#line 1274 src/Raku/ast/signature.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::ParameterTarget::Var, '$!name', $name);
        nqp::bindattr($obj, RakuAST::ParameterTarget::Var, '$!type', Mu);
        nqp::bindattr($obj, RakuAST::ParameterTarget::Var, '$!of', Mu);
        nqp::bindattr($obj, RakuAST::ContainerCreator, '$!forced-dynamic',
          $forced-dynamic ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        my $sigil := $obj.sigil;
        my $twigil := $obj.twigil;
        nqp::bindattr(
            $obj,
            RakuAST::ParameterTarget::Var,
            '$!declaration',
            RakuAST::VarDeclaration::Simple.new(
                :scope($obj.scope),
                :desigilname(RakuAST::Name.from-identifier($obj.desigilname)),
                :$sigil,
                :$twigil,
                :type(Mu),
                :$forced-dynamic,
            )
        );
        $obj
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'lexical-name', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1299 src/Raku/ast/signature.rakumod
        
        nqp::getattr_s($SELF, RakuAST::ParameterTarget::Var, '$!name')
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'introspection-name', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub introspection-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1303 src/Raku/ast/signature.rakumod
        
        nqp::getattr_s($SELF, RakuAST::ParameterTarget::Var, '$!name')
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'scope', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1307 src/Raku/ast/signature.rakumod
        
        nqp::getattr_s($SELF, RakuAST::ParameterTarget::Var, '$!scope') // $SELF.default-scope
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'replace-scope', [RakuAST::ParameterTarget::Var, '', 0, 0, Any, '$scope', 0, 0], anon sub replace-scope ($SELF_CONT, $scope!) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
#line 1311 src/Raku/ast/signature.rakumod
        
        nqp::bindattr_s($SELF, RakuAST::ParameterTarget::Var, '$!scope', $scope);
        if nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration') {
            nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration').replace-scope($scope);
        }
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'generate-lookup', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1319 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration').generate-lookup
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'sigil', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub sigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1323 src/Raku/ast/signature.rakumod
        
        nqp::substr(nqp::getattr_s($SELF, RakuAST::ParameterTarget::Var, '$!name'), 0, 1)
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'twigil', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub twigil ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1327 src/Raku/ast/signature.rakumod
        
        if nqp::chars(nqp::getattr_s($SELF, RakuAST::ParameterTarget::Var, '$!name')) > 2 {
            my str $twigil := nqp::substr(nqp::getattr_s($SELF, RakuAST::ParameterTarget::Var, '$!name'), 1, 1);
            nqp::index('.!^:*?=~', $twigil) >= 0 ?? $twigil !! ''
        }
        else {
            ''
        }
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'desigilname', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub desigilname ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1337 src/Raku/ast/signature.rakumod
        
        nqp::substr(nqp::getattr_s($SELF, RakuAST::ParameterTarget::Var, '$!name'), $SELF.twigil ?? 2 !! 1)
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'can-be-bound-to', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub can-be-bound-to ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1341 src/Raku/ast/signature.rakumod
        
        (Bool.WHO)<True> #TODO only when parameter is copy
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'set-type', [RakuAST::ParameterTarget::Var, '', 0, 0, RakuAST::Type, '$type', 0, 0], anon sub set-type ($SELF_CONT, $type!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
#line 1345 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::ParameterTarget::Var, '$!type', $type);
        nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration').set-type($type) if nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration');
        Nil
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'set-name', [RakuAST::ParameterTarget::Var, '', 0, 0, str, '$name', 0, 0], anon sub set-name ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 1351 src/Raku/ast/signature.rakumod
        
        nqp::bindattr_s($SELF, RakuAST::ParameterTarget::Var, '$!name', $name);
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'set-container-type', [RakuAST::ParameterTarget::Var, '', 0, 0, Mu, '$type', 0, 0, Mu, '$of', 0, 0], anon sub set-container-type ($SELF_CONT, $type!, $of!) {
        my $SELF := nqp::decont($SELF_CONT);
        $type := nqp::decont($type);
        $of := nqp::decont($of);
#line 1355 src/Raku/ast/signature.rakumod
        
        nqp::bindattr($SELF, RakuAST::ParameterTarget::Var, '$!type', $type);
        nqp::bindattr($SELF, RakuAST::ParameterTarget::Var, '$!of', $of);
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'attach', [RakuAST::ParameterTarget::Var, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub attach ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 1360 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration').attach($resolver);
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'PRODUCE-META-OBJECT', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1364 src/Raku/ast/signature.rakumod
        
        nqp::bindattr(
            $SELF,
            RakuAST::ParameterTarget::Var,
            '$!of',
            nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!type').resolution.compile-time-value
        ) if nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!type') && nqp::eqaddr(nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!of'), Mu);

        nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration').meta-object
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'IMPL-QAST-DECL', [RakuAST::ParameterTarget::Var, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1375 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration').IMPL-QAST-DECL($context)
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'IMPL-BIND-QAST', [RakuAST::ParameterTarget::Var, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 1379 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration').IMPL-BIND-QAST($context, $source-qast)
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'IMPL-LOOKUP-QAST', [RakuAST::ParameterTarget::Var, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1383 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration').IMPL-LOOKUP-QAST($context)
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'PERFORM-BEGIN', [RakuAST::ParameterTarget::Var, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1387 src/Raku/ast/signature.rakumod
        
        my $var := nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration');
        for $SELF.IMPL-UNWRAP-LIST($SELF.traits) {
            $var.add-trait($_);
        }
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'PERFORM-CHECK', [RakuAST::ParameterTarget::Var, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1397 src/Raku/ast/signature.rakumod
        
        # Check for illegal post declaration is actually performed by RakuAST::Scope
        # Need PERFORM-CHECK because we're a RakuAST::CheckTime and we need to be
        # that to carry the sorry generated by the check.
    
    });
    add-method(RakuAST::ParameterTarget::Var, 'default-scope', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1403 src/Raku/ast/signature.rakumod
         'my' 
    });
    add-method(RakuAST::ParameterTarget::Var, 'allowed-scopes', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1405 src/Raku/ast/signature.rakumod
         $SELF.IMPL-WRAP-LIST(['my', 'our', 'has', 'HAS']) 
    });
    add-method(RakuAST::ParameterTarget::Var, 'is-begin-performed-before-children', [RakuAST::ParameterTarget::Var, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1407 src/Raku/ast/signature.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::ParameterTarget::Var, 'visit-children', [RakuAST::ParameterTarget::Var, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1409 src/Raku/ast/signature.rakumod
        
        # We don't want to visit the declaration if it is a topic variable,
        # as that will result in multiple declarations because blocks already
        # automatically declare a `$_`. And if the signature is not on a block
        # it will still find a lexical `$_` somewhere in scope.
        $visitor(nqp::getattr($SELF, RakuAST::ParameterTarget::Var, '$!declaration')) unless nqp::getattr_s($SELF, RakuAST::ParameterTarget::Var, '$!name') eq '$_';
    
    });
#line 1268 src/Raku/ast/signature.rakumod
    add-method(RakuAST::ParameterTarget::Var, 'type', [], anon sub type ($self) { nqp::getattr(nqp::decont($self), RakuAST::ParameterTarget::Var, '$!type') });
#line 1267 src/Raku/ast/signature.rakumod
    add-method(RakuAST::ParameterTarget::Var, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::ParameterTarget::Var, '$!name') });
    compose(RakuAST::ParameterTarget::Var);
    parent(RakuAST::ParameterTarget::Term, RakuAST::ParameterTarget);
    parent(RakuAST::ParameterTarget::Term, RakuAST::Declaration);
    add-attribute(RakuAST::ParameterTarget::Term, RakuAST::Name, '$!name');
    add-method(RakuAST::ParameterTarget::Term, 'new', [RakuAST::ParameterTarget::Term, '', 0, 0, RakuAST::Name, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 1425 src/Raku/ast/signature.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ParameterTarget::Term, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::ParameterTarget::Term, 'lexical-name', [RakuAST::ParameterTarget::Term, '', 0, 0], anon sub lexical-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1431 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::ParameterTarget::Term, '$!name').canonicalize
    
    });
    add-method(RakuAST::ParameterTarget::Term, 'introspection-name', [RakuAST::ParameterTarget::Term, '', 0, 0], anon sub introspection-name ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1435 src/Raku/ast/signature.rakumod
        
        nqp::getattr($SELF, RakuAST::ParameterTarget::Term, '$!name').canonicalize
    
    });
    add-method(RakuAST::ParameterTarget::Term, 'generate-lookup', [RakuAST::ParameterTarget::Term, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1440 src/Raku/ast/signature.rakumod
        
        my $lookup := RakuAST::Term::Name.new(nqp::getattr($SELF, RakuAST::ParameterTarget::Term, '$!name'));
        $lookup.set-resolution($SELF);
        $lookup
    
    });
    add-method(RakuAST::ParameterTarget::Term, 'IMPL-QAST-DECL', [RakuAST::ParameterTarget::Term, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1446 src/Raku/ast/signature.rakumod
        
        QAST::Var.new( :decl('var'), :scope('lexical'), :name(nqp::getattr($SELF, RakuAST::ParameterTarget::Term, '$!name').canonicalize) )
    
    });
    add-method(RakuAST::ParameterTarget::Term, 'IMPL-BIND-QAST', [RakuAST::ParameterTarget::Term, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$source-qast', 0, 0], anon sub IMPL-BIND-QAST ($SELF_CONT, $context!, $source-qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $source-qast := nqp::decont($source-qast);
#line 1450 src/Raku/ast/signature.rakumod
        
        QAST::Op.new(
            :op('bind'),
            QAST::Var.new( :scope('lexical'), :name(nqp::getattr($SELF, RakuAST::ParameterTarget::Term, '$!name').canonicalize) ),
            $source-qast
        )
    
    });
    add-method(RakuAST::ParameterTarget::Term, 'IMPL-LOOKUP-QAST', [RakuAST::ParameterTarget::Term, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-LOOKUP-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1458 src/Raku/ast/signature.rakumod
        
        my str $scope := 'lexical';
        QAST::Var.new( :name(nqp::getattr($SELF, RakuAST::ParameterTarget::Term, '$!name').canonicalize), :$scope )
    
    });
    add-method(RakuAST::ParameterTarget::Term, 'default-scope', [RakuAST::ParameterTarget::Term, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1463 src/Raku/ast/signature.rakumod
         'my' 
    });
    add-method(RakuAST::ParameterTarget::Term, 'allowed-scopes', [RakuAST::ParameterTarget::Term, '', 0, 0], anon sub allowed-scopes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1465 src/Raku/ast/signature.rakumod
         $SELF.IMPL-WRAP-LIST(['my']) 
    });
    add-method(RakuAST::ParameterTarget::Term, 'visit-children', [RakuAST::ParameterTarget::Term, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1467 src/Raku/ast/signature.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::ParameterTarget::Term, '$!name'));
    
    });
#line 1423 src/Raku/ast/signature.rakumod
    add-method(RakuAST::ParameterTarget::Term, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::ParameterTarget::Term, '$!name') });
    compose(RakuAST::ParameterTarget::Term);
    parent(RakuAST::ParameterTarget::Whatever, RakuAST::ParameterTarget::Term);
    add-method(RakuAST::ParameterTarget::Whatever, 'new', [RakuAST::ParameterTarget::Whatever, '', 0, 0, str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 1477 src/Raku/ast/signature.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ParameterTarget::Term, '$!name',
            RakuAST::Name.from-identifier($name // QAST::Node.unique('$whatevercode_arg')));
        $obj
    
    });
    add-method(RakuAST::ParameterTarget::Whatever, 'generate-lookup', [RakuAST::ParameterTarget::Whatever, '', 0, 0], anon sub generate-lookup ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1485 src/Raku/ast/signature.rakumod
        
        my $name := nqp::getattr($SELF, RakuAST::ParameterTarget::Term, '$!name');
        my $lookup := RakuAST::WhateverCode::Argument.new($name);
        $lookup.set-resolution($SELF);
        $lookup
    
    });
    compose(RakuAST::ParameterTarget::Whatever);
    parent(RakuAST::Parameter::Slurpy, Any);
    add-method(RakuAST::Parameter::Slurpy, 'new', [RakuAST::Parameter::Slurpy, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1502 src/Raku/ast/signature.rakumod
         $SELF 
    });
    add-method(RakuAST::Parameter::Slurpy, 'IMPL-FLAGS', [RakuAST::Parameter::Slurpy, '', 0, 0, str, '$sigil', 0, 0], anon sub IMPL-FLAGS ($SELF_CONT, $sigil!) {
        my $SELF := nqp::decont($SELF_CONT);
        $sigil := nqp::decont($sigil);
#line 1504 src/Raku/ast/signature.rakumod
        
        # Not slurpy, so no flags
        0
    
    });
    add-method(RakuAST::Parameter::Slurpy, 'IMPL-TRANSFORM-PARAM-QAST', [RakuAST::Parameter::Slurpy, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$param-qast', 0, 0, Mu, '$temp-qast', 0, 0, str, '$sigil', 0, 0, Any, '@prepend', 0, 0], anon sub IMPL-TRANSFORM-PARAM-QAST ($SELF_CONT, $context!, $param-qast!, $temp-qast!, $sigil!, @prepend!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $param-qast := nqp::decont($param-qast);
        $temp-qast := nqp::decont($temp-qast);
        $sigil := nqp::decont($sigil);
        @prepend := nqp::decont(@prepend);
#line 1510 src/Raku/ast/signature.rakumod
        
        # Not slurply, so nothing to do
        $param-qast
    
    });
    add-method(RakuAST::Parameter::Slurpy, 'IMPL-QAST-LISTY-SLURP', [RakuAST::Parameter::Slurpy, '', 0, 0, Mu, '$param-qast', 0, 0, Mu, '$temp-qast', 0, 0, List, '$type', 0, 0, str, '$method', 0, 0], anon sub IMPL-QAST-LISTY-SLURP ($SELF_CONT, $param-qast!, $temp-qast!, $type!, $method!) {
        my $SELF := nqp::decont($SELF_CONT);
        $param-qast := nqp::decont($param-qast);
        $temp-qast := nqp::decont($temp-qast);
        $type := nqp::decont($type);
        $method := nqp::decont($method);
#line 1515 src/Raku/ast/signature.rakumod
        
        $param-qast.slurpy(1);
        $param-qast.push(QAST::Op.new(
            :op('bind'),
            $temp-qast,
            QAST::Op.new(
                :op('callmethod'), :name($method),
                QAST::WVal.new( :value($type) ),
                $temp-qast
            )
        ));
    
    });
    compose(RakuAST::Parameter::Slurpy);
    parent(RakuAST::Parameter::Slurpy::Flattened, RakuAST::Parameter::Slurpy);
    add-method(RakuAST::Parameter::Slurpy::Flattened, 'IMPL-FLAGS', [RakuAST::Parameter::Slurpy::Flattened, '', 0, 0, str, '$sigil', 0, 0], anon sub IMPL-FLAGS ($SELF_CONT, $sigil!) {
        my $SELF := nqp::decont($SELF_CONT);
        $sigil := nqp::decont($sigil);
#line 1533 src/Raku/ast/signature.rakumod
        
        my constant SIG_ELEM_SLURPY_POS   := 8;
        my constant SIG_ELEM_SLURPY_NAMED := 16;
        $sigil eq '@' ?? SIG_ELEM_SLURPY_POS !!
        $sigil eq '%' ?? SIG_ELEM_SLURPY_NAMED !!
                         0
    
    });
    add-method(RakuAST::Parameter::Slurpy::Flattened, 'IMPL-TRANSFORM-PARAM-QAST', [RakuAST::Parameter::Slurpy::Flattened, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$param-qast', 0, 0, Mu, '$temp-qast', 0, 0, str, '$sigil', 0, 0, Any, '@prepend', 0, 0], anon sub IMPL-TRANSFORM-PARAM-QAST ($SELF_CONT, $context!, $param-qast!, $temp-qast!, $sigil!, @prepend!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $param-qast := nqp::decont($param-qast);
        $temp-qast := nqp::decont($temp-qast);
        $sigil := nqp::decont($sigil);
        @prepend := nqp::decont(@prepend);
#line 1542 src/Raku/ast/signature.rakumod
        
        if $sigil eq '@' {
            $SELF.IMPL-QAST-LISTY-SLURP($param-qast, $temp-qast, Array, 'from-slurpy-flat');
        }
        elsif $sigil eq '%' {
            $param-qast.slurpy(1);
            $param-qast.named(1);
            $param-qast.push(QAST::Op.new(
                :op('bind'),
                $temp-qast,
                QAST::Op.new(
                    :op('p6bindattrinvres'),
                    QAST::Op.new(
                        :op('create'),
                        QAST::WVal.new( :value(Hash) )
                    ),
                    QAST::WVal.new( :value(Map) ),
                    QAST::SVal.new( :value('$!storage') ),
                    $temp-qast
                )
            ));
        }
        else {
            nqp::die("Parameter * quantifier not applicable to sigil '$sigil'");
        }
    
    });
    compose(RakuAST::Parameter::Slurpy::Flattened);
    parent(RakuAST::Parameter::Slurpy::Unflattened, RakuAST::Parameter::Slurpy);
    add-method(RakuAST::Parameter::Slurpy::Unflattened, 'IMPL-FLAGS', [RakuAST::Parameter::Slurpy::Unflattened, '', 0, 0, str, '$sigil', 0, 0], anon sub IMPL-FLAGS ($SELF_CONT, $sigil!) {
        my $SELF := nqp::decont($SELF_CONT);
        $sigil := nqp::decont($sigil);
#line 1574 src/Raku/ast/signature.rakumod
        
        my constant SIG_ELEM_SLURPY_LOL := 32;
        $sigil eq '@' ?? SIG_ELEM_SLURPY_LOL !! 0
    
    });
    add-method(RakuAST::Parameter::Slurpy::Unflattened, 'IMPL-TRANSFORM-PARAM-QAST', [RakuAST::Parameter::Slurpy::Unflattened, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$param-qast', 0, 0, Mu, '$temp-qast', 0, 0, str, '$sigil', 0, 0, Any, '@prepend', 0, 0], anon sub IMPL-TRANSFORM-PARAM-QAST ($SELF_CONT, $context!, $param-qast!, $temp-qast!, $sigil!, @prepend!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $param-qast := nqp::decont($param-qast);
        $temp-qast := nqp::decont($temp-qast);
        $sigil := nqp::decont($sigil);
        @prepend := nqp::decont(@prepend);
#line 1580 src/Raku/ast/signature.rakumod
        
        if $sigil eq '@' {
            $SELF.IMPL-QAST-LISTY-SLURP($param-qast, $temp-qast, Array, 'from-slurpy');
        }
        else {
            nqp::die("Parameter ** quantifier not applicable to sigil '$sigil'");
        }
    
    });
    compose(RakuAST::Parameter::Slurpy::Unflattened);
    parent(RakuAST::Parameter::Slurpy::SingleArgument, RakuAST::Parameter::Slurpy);
    add-method(RakuAST::Parameter::Slurpy::SingleArgument, 'IMPL-FLAGS', [RakuAST::Parameter::Slurpy::SingleArgument, '', 0, 0, str, '$sigil', 0, 0], anon sub IMPL-FLAGS ($SELF_CONT, $sigil!) {
        my $SELF := nqp::decont($SELF_CONT);
        $sigil := nqp::decont($sigil);
#line 1594 src/Raku/ast/signature.rakumod
        
        my constant SIG_ELEM_SLURPY_ONEARG := 16777216;
        $sigil eq '@' || $sigil eq '' ?? SIG_ELEM_SLURPY_ONEARG !! 0
    
    });
    add-method(RakuAST::Parameter::Slurpy::SingleArgument, 'IMPL-TRANSFORM-PARAM-QAST', [RakuAST::Parameter::Slurpy::SingleArgument, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$param-qast', 0, 0, Mu, '$temp-qast', 0, 0, str, '$sigil', 0, 0, Any, '@prepend', 0, 0], anon sub IMPL-TRANSFORM-PARAM-QAST ($SELF_CONT, $context!, $param-qast!, $temp-qast!, $sigil!, @prepend!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $param-qast := nqp::decont($param-qast);
        $temp-qast := nqp::decont($temp-qast);
        $sigil := nqp::decont($sigil);
        @prepend := nqp::decont(@prepend);
#line 1600 src/Raku/ast/signature.rakumod
        
        if $sigil eq '@' || $sigil eq '' {
            $SELF.IMPL-QAST-LISTY-SLURP($param-qast, $temp-qast, Array, 'from-slurpy-onearg');
        }
        else {
            nqp::die("Parameter + quantifier not applicable to sigil '$sigil'");
        }
    
    });
    compose(RakuAST::Parameter::Slurpy::SingleArgument);
    parent(RakuAST::Parameter::Slurpy::Capture, RakuAST::Parameter::Slurpy);
    add-method(RakuAST::Parameter::Slurpy::Capture, 'IMPL-FLAGS', [RakuAST::Parameter::Slurpy::Capture, '', 0, 0, str, '$sigil', 0, 0], anon sub IMPL-FLAGS ($SELF_CONT, $sigil!) {
        my $SELF := nqp::decont($SELF_CONT);
        $sigil := nqp::decont($sigil);
#line 1614 src/Raku/ast/signature.rakumod
        
        my constant SIG_ELEM_IS_CAPTURE := 32768;
        SIG_ELEM_IS_CAPTURE
    
    });
    add-method(RakuAST::Parameter::Slurpy::Capture, 'IMPL-TRANSFORM-PARAM-QAST', [RakuAST::Parameter::Slurpy::Capture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$param-qast', 0, 0, Mu, '$temp-qast', 0, 0, str, '$sigil', 0, 0, Any, '@prepend', 0, 0], anon sub IMPL-TRANSFORM-PARAM-QAST ($SELF_CONT, $context!, $param-qast!, $temp-qast!, $sigil!, @prepend!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $param-qast := nqp::decont($param-qast);
        $temp-qast := nqp::decont($temp-qast);
        $sigil := nqp::decont($sigil);
        @prepend := nqp::decont(@prepend);
#line 1620 src/Raku/ast/signature.rakumod
        
        # Sneak in a slurpy hash parameter too.
        $param-qast.slurpy(1);
        my $hash-param-name := $temp-qast.name ~ '_hash';
        @prepend.push(QAST::Var.new(
            :name($hash-param-name), :scope('local'), :decl('param'),
            :slurpy(1), :named(1)
        ));

        # Build a capture object.
        my $capture-wval := QAST::WVal.new( :value(Capture) );
        $param-qast.push(QAST::Op.new(
            :op('bind'),
            $temp-qast,
            QAST::Op.new(
                :op('p6bindattrinvres'),
                QAST::Op.new(
                    :op('p6bindattrinvres'),
                    QAST::Op.new( :op('create'), $capture-wval ),
                    $capture-wval,
                    QAST::SVal.new( :value('@!list') ),
                    $temp-qast
                ),
                $capture-wval,
                QAST::SVal.new( :value('%!hash') ),
                QAST::Var.new( :name($hash-param-name), :scope('local') )
            )));
    
    });
    compose(RakuAST::Parameter::Slurpy::Capture);
    parent(RakuAST::ParameterDefaultThunk, RakuAST::ExpressionThunk);
    add-attribute(RakuAST::ParameterDefaultThunk, RakuAST::Parameter, '$!parameter');
    add-method(RakuAST::ParameterDefaultThunk, 'new', [RakuAST::ParameterDefaultThunk, '', 0, 0, RakuAST::Parameter, '$parameter', 0, 0], anon sub new ($SELF_CONT, $parameter!) {
        my $SELF := nqp::decont($SELF_CONT);
        $parameter := nqp::decont($parameter);
#line 1656 src/Raku/ast/signature.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::ParameterDefaultThunk, '$!parameter', $parameter);
        $obj
    
    });
    add-method(RakuAST::ParameterDefaultThunk, 'thunk-kind', [RakuAST::ParameterDefaultThunk, '', 0, 0], anon sub thunk-kind ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1662 src/Raku/ast/signature.rakumod
        
        'Parameter default'
    
    });
    add-method(RakuAST::ParameterDefaultThunk, 'thunk-details', [RakuAST::ParameterDefaultThunk, '', 0, 0], anon sub thunk-details ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1666 src/Raku/ast/signature.rakumod
        
        ''
    
    });
    add-method(RakuAST::ParameterDefaultThunk, 'IMPL-THUNK-META-OBJECT-PRODUCED', [RakuAST::ParameterDefaultThunk, '', 0, 0, Mu, '$code', 0, 0], anon sub IMPL-THUNK-META-OBJECT-PRODUCED ($SELF_CONT, $code!) {
        my $SELF := nqp::decont($SELF_CONT);
        $code := nqp::decont($code);
#line 1670 src/Raku/ast/signature.rakumod
        
        nqp::bindattr(nqp::getattr($SELF, RakuAST::ParameterDefaultThunk, '$!parameter').meta-object, Parameter, '$!default_value', $code);
    
    });
    compose(RakuAST::ParameterDefaultThunk);
    parent(RakuAST::Package, RakuAST::PackageInstaller);
    parent(RakuAST::Package, RakuAST::StubbyMeta);
    parent(RakuAST::Package, RakuAST::Term);
    parent(RakuAST::Package, RakuAST::IMPL::ImmediateBlockUser);
    parent(RakuAST::Package, RakuAST::Declaration);
    parent(RakuAST::Package, RakuAST::AttachTarget);
    parent(RakuAST::Package, RakuAST::BeginTime);
    parent(RakuAST::Package, RakuAST::TraitTarget);
    parent(RakuAST::Package, RakuAST::ImplicitBlockSemanticsProvider);
    parent(RakuAST::Package, RakuAST::LexicalScope);
    parent(RakuAST::Package, RakuAST::Lookup);
    parent(RakuAST::Package, RakuAST::Doc::DeclaratorTarget);
    add-attribute(RakuAST::Package, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Package, RakuAST::Code, '$!body');
    add-attribute(RakuAST::Package, Mu, '$!attribute-type');
    add-attribute(RakuAST::Package, Mu, '$!how');
    add-attribute(RakuAST::Package, Str, '$!repr');
    add-attribute(RakuAST::Package, Bool, '$!augmented');
    add-attribute(RakuAST::Package, Mu, '$!role-group');
    add-attribute(RakuAST::Package, Mu, '$!block-semantics-applied');
    add-attribute(RakuAST::Package, Bool, '$!is-stub');
    add-attribute(RakuAST::Package, Mu, '$!attached-methods');
    add-attribute(RakuAST::Package, Mu, '$!attached-attributes');
    add-attribute(RakuAST::Package, Mu, '$!attached-attribute-usages');
    add-method(RakuAST::Package, 'new', [RakuAST::Package, '', 0, 0, str, '$scope', 1, 1, RakuAST::Name, '$name', 1, 1, RakuAST::Signature, '$parameterization', 1, 1, List, '$traits', 1, 1, RakuAST::Code, '$body', 1, 1, Mu, '$attribute-type', 1, 1, Mu, '$how', 1, 1, Str, '$repr', 1, 1, Bool, '$augmented', 1, 1, RakuAST::Doc::Declarator, '$WHY', 1, 1], anon sub new ($SELF_CONT, :$scope?, :$name?, :$parameterization?, :$traits?, :$body?, :$attribute-type?, :$how?, :$repr?, :$augmented?, :$WHY?) {
        my $SELF := nqp::decont($SELF_CONT);
        $scope := nqp::decont($scope);
        $name := nqp::decont($name);
        $parameterization := nqp::decont($parameterization);
        $traits := nqp::decont($traits);
        $body := nqp::decont($body);
        $attribute-type := nqp::decont($attribute-type);
        $how := nqp::decont($how);
        $repr := nqp::decont($repr);
        $augmented := nqp::decont($augmented);
        $WHY := nqp::decont($WHY);
#line 47 src/Raku/ast/package.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Declaration, '$!scope', $scope);
        nqp::bindattr($obj, RakuAST::Package, '$!name', $name // RakuAST::Name);
        nqp::bindattr($obj, RakuAST::Package, '$!attribute-type',
          nqp::eqaddr($attribute-type, NQPMu) ?? Attribute !! $attribute-type);
        nqp::bindattr($obj, RakuAST::Package, '$!how',
          nqp::eqaddr($how,NQPMu) ?? $obj.default-how !! $how);
        nqp::bindattr($obj, RakuAST::Package, '$!repr', $repr // Str);
        nqp::bindattr($obj, RakuAST::Package, '$!augmented',$augmented // (Bool.WHO)<False>);

        $obj.set-traits($traits) if $traits;
        $obj.replace-body($body, $parameterization);
        $obj.set-WHY($WHY);

        # Set up internal defaults
        nqp::bindattr($obj, RakuAST::Package, '$!attached-methods', []);
        nqp::bindattr($obj, RakuAST::Package, '$!attached-attributes', []);
        nqp::bindattr($obj, RakuAST::Package, '$!attached-attribute-usages',[]);
        nqp::bindattr($obj, RakuAST::Package, '$!role-group', Mu);
        nqp::bindattr($obj, RakuAST::Package, '$!is-stub', (Bool.WHO)<False>);

        $obj
    
    });
    add-method(RakuAST::Package, 'declarator', [RakuAST::Package, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 73 src/Raku/ast/package.rakumod
         "package"             
    });
    add-method(RakuAST::Package, 'dba', [RakuAST::Package, '', 0, 0], anon sub dba ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 74 src/Raku/ast/package.rakumod
         "package"             
    });
    add-method(RakuAST::Package, 'default-how', [RakuAST::Package, '', 0, 0], anon sub default-how ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 75 src/Raku/ast/package.rakumod
         Metamodel::PackageHOW 
    });
    add-method(RakuAST::Package, 'default-scope', [RakuAST::Package, '', 0, 0], anon sub default-scope ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 77 src/Raku/ast/package.rakumod
         'our' 
    });
    add-method(RakuAST::Package, 'can-have-methods', [RakuAST::Package, '', 0, 0], anon sub can-have-methods ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 78 src/Raku/ast/package.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Package, 'can-have-attributes', [RakuAST::Package, '', 0, 0], anon sub can-have-attributes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 79 src/Raku/ast/package.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Package, 'IMPL-CAN-INTERPRET', [RakuAST::Package, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 80 src/Raku/ast/package.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Package, 'parameterization', [RakuAST::Package, '', 0, 0], anon sub parameterization ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 82 src/Raku/ast/package.rakumod
         Mu 
    });
    add-method(RakuAST::Package, 'is-simple-lexical-declaration', [RakuAST::Package, '', 0, 0], anon sub is-simple-lexical-declaration ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 87 src/Raku/ast/package.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Package, 'is-begin-performed-before-children', [RakuAST::Package, '', 0, 0], anon sub is-begin-performed-before-children ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 90 src/Raku/ast/package.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Package, 'replace-body', [RakuAST::Package, '', 0, 0, RakuAST::Code, '$body', 0, 0, RakuAST::Signature, '$signature', 0, 0], anon sub replace-body ($SELF_CONT, $body!, $signature!) {
        my $SELF := nqp::decont($SELF_CONT);
        $body := nqp::decont($body);
        $signature := nqp::decont($signature);
#line 93 src/Raku/ast/package.rakumod
        
        nqp::bindattr($SELF, RakuAST::Package, '$!body',
          $body // RakuAST::Block.new);
        Nil
    
    });
    add-method(RakuAST::Package, 'set-repr', [RakuAST::Package, '', 0, 0, Str, '$repr', 0, 0], anon sub set-repr ($SELF_CONT, $repr!) {
        my $SELF := nqp::decont($SELF_CONT);
        $repr := nqp::decont($repr);
#line 99 src/Raku/ast/package.rakumod
        
        nqp::bindattr($SELF, RakuAST::Package, '$!repr', $repr);
    
    });
    add-method(RakuAST::Package, 'set-is-stub', [RakuAST::Package, '', 0, 0, Bool, '$is-stub', 0, 0], anon sub set-is-stub ($SELF_CONT, $is-stub!) {
        my $SELF := nqp::decont($SELF_CONT);
        $is-stub := nqp::decont($is-stub);
#line 103 src/Raku/ast/package.rakumod
        
        nqp::bindattr($SELF, RakuAST::Package, '$!is-stub', $is-stub ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
    
    });
    add-method(RakuAST::Package, 'resolve-with', [RakuAST::Package, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub resolve-with ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 107 src/Raku/ast/package.rakumod
        
        if nqp::getattr($SELF, RakuAST::Package, '$!augmented') {
            my $resolved := $resolver.resolve-name($SELF.name);
            if $resolved {
                $SELF.set-resolution($resolved);
            }
        }
        elsif nqp::getattr($SELF, RakuAST::Package, '$!name') {
            my $resolved := $resolver.resolve-name-constant(nqp::getattr($SELF, RakuAST::Package, '$!name'));
            if $resolved {
                my $meta := $resolved.compile-time-value;
                my $how  := $meta.HOW;
                if $how.HOW.name($how) ne 'Perl6::Metamodel::PackageHOW'
                  && nqp::can($how, 'is_composed')
                  && !$how.is_composed($meta) {
                    $SELF.set-resolution($resolved);
                }
            }
        }
        Nil
    
    });
    add-method(RakuAST::Package, 'attach-target-names', [RakuAST::Package, '', 0, 0], anon sub attach-target-names ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 129 src/Raku/ast/package.rakumod
         $SELF.IMPL-WRAP-LIST(['package', 'also']) 
    });
    add-method(RakuAST::Package, 'clear-attachments', [RakuAST::Package, '', 0, 0], anon sub clear-attachments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 131 src/Raku/ast/package.rakumod
        
        # Attributes and methods only attach once as a BEGIN effect, thus we
        # don't have to deal with duplicates on them.
        Nil
    
    });
    add-method(RakuAST::Package, 'ATTACH-METHOD', [RakuAST::Package, '', 0, 0, RakuAST::Method, '$method', 0, 0], anon sub ATTACH-METHOD ($SELF_CONT, $method!) {
        my $SELF := nqp::decont($SELF_CONT);
        $method := nqp::decont($method);
#line 137 src/Raku/ast/package.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Package, '$!attached-methods'), $method);
        Nil
    
    });
    add-method(RakuAST::Package, 'ATTACH-ATTRIBUTE', [RakuAST::Package, '', 0, 0, RakuAST::VarDeclaration::Simple, '$attribute', 0, 0], anon sub ATTACH-ATTRIBUTE ($SELF_CONT, $attribute!) {
        my $SELF := nqp::decont($SELF_CONT);
        $attribute := nqp::decont($attribute);
#line 143 src/Raku/ast/package.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Package, '$!attached-attributes'), $attribute);
        Nil
    
    });
    add-method(RakuAST::Package, 'ATTACH-ATTRIBUTE-USAGE', [RakuAST::Package, '', 0, 0, RakuAST::Var::Attribute, '$attribute', 0, 0], anon sub ATTACH-ATTRIBUTE-USAGE ($SELF_CONT, $attribute!) {
        my $SELF := nqp::decont($SELF_CONT);
        $attribute := nqp::decont($attribute);
#line 148 src/Raku/ast/package.rakumod
        
        nqp::push(nqp::getattr($SELF, RakuAST::Package, '$!attached-attribute-usages'), $attribute);
        Nil
    
    });
    add-method(RakuAST::Package, 'IMPL-GENERATE-LEXICAL-DECLARATION', [RakuAST::Package, '', 0, 0, RakuAST::Name, '$name', 0, 0, Mu, '$type-object', 0, 0], anon sub IMPL-GENERATE-LEXICAL-DECLARATION ($SELF_CONT, $name!, $type-object!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $type-object := nqp::decont($type-object);
#line 153 src/Raku/ast/package.rakumod
        
        RakuAST::Declaration::LexicalPackage.new:
            :lexical-name($name),
            :compile-time-value($type-object),
            :package($SELF);
    
    });
    add-method(RakuAST::Package, 'PERFORM-BEGIN', [RakuAST::Package, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-BEGIN ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 163 src/Raku/ast/package.rakumod
        
        # Note that this early return is actually not effective as the
        # begin handler will already be run when the parser enters the
        # package and we only know that it's a stub when we are done
        # parsing the body.
        return Nil if nqp::getattr($SELF, RakuAST::Package, '$!is-stub');

        # Install the symbol.
        my str $scope := $SELF.scope;
        $scope := 'our' if $scope eq 'unit';
        my $name := nqp::getattr($SELF, RakuAST::Package, '$!name');
        if $name && !$name.is-empty {
            my $type-object := $SELF.stubbed-meta-object;
            my $current     := $resolver.current-package;
            my $full-name   := nqp::eqaddr($current,$resolver.get-global)
              ?? $name
              !! $name.qualified-with(
                   RakuAST::Name.from-identifier-parts(
                     |nqp::split('::', $current.HOW.name($current))
                    )
                 );
            $type-object.HOW.set_name(
                $type-object,
                $full-name.canonicalize(:colonpairs(0))
            ) if !nqp::eqaddr($current, $resolver.get-global);

            # Update the Stash's name, too.
            nqp::bindattr_s($type-object.WHO, Stash, '$!longname',
              $type-object.HOW.name($type-object));

            $SELF.install-in-scope(
              $resolver, $scope, $name, $full-name, $type-object
            );
        }

        # TODO split off the above into a pre-begin handler, so the enter-scope
        # and declarations can go back into RakuAST::Actions
        if nqp::istype($resolver, RakuAST::Resolver::Compile) {
            $resolver.enter-scope($SELF);
            $SELF.declare-lexicals($resolver);
        }

        # Apply any traits
        $SELF.apply-traits($resolver, $context, $SELF);
    
    });
    add-method(RakuAST::Package, 'install-in-scope', [RakuAST::Package, '', 0, 0, Any, '$resolver', 0, 0, Any, '$scope', 0, 0, Any, '$name', 0, 0, Any, '$full-name', 0, 0, Any, '$type-object', 0, 0], anon sub install-in-scope ($SELF_CONT, $resolver!, $scope!, $name!, $full-name!, $type-object!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $scope := nqp::decont($scope);
        $name := nqp::decont($name);
        $full-name := nqp::decont($full-name);
        $type-object := nqp::decont($type-object);
#line 210 src/Raku/ast/package.rakumod
        
        $SELF.IMPL-INSTALL-PACKAGE(
          $resolver, $scope, $name, $type-object, $resolver.current-package
        ) if $scope eq 'my' || $scope eq 'our';
    
    });
    add-method(RakuAST::Package, 'declare-lexicals', [RakuAST::Package, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub declare-lexicals ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 217 src/Raku/ast/package.rakumod
        
        $SELF.meta-object-as-lexicals($resolver, 'CLASS')
          unless $SELF.declarator eq 'package';
    
    });
    add-method(RakuAST::Package, 'meta-object-as-lexicals', [RakuAST::Package, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, str, '$root', 0, 0], anon sub meta-object-as-lexicals ($SELF_CONT, $resolver!, $root!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $root := nqp::decont($root);
#line 223 src/Raku/ast/package.rakumod
        
        for '$?', '::?' {
            $resolver.declare-lexical($SELF.implicit-constant($_ ~ $root));
        }
    
    });
    add-method(RakuAST::Package, 'meta-object-as-body-lexicals', [RakuAST::Package, '', 0, 0, str, '$root', 0, 0], anon sub meta-object-as-body-lexicals ($SELF_CONT, $root!) {
        my $SELF := nqp::decont($SELF_CONT);
        $root := nqp::decont($root);
#line 230 src/Raku/ast/package.rakumod
        
        my $body := $SELF.body;
        for '$?', '::?' {
            $body.add-generated-lexical-declaration(
              $SELF.implicit-constant($_ ~ $root)
            )
        }
    
    });
    add-method(RakuAST::Package, 'implicit-constant', [RakuAST::Package, '', 0, 0, str, '$name', 0, 0], anon sub implicit-constant ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 240 src/Raku/ast/package.rakumod
        
        RakuAST::VarDeclaration::Implicit::Constant.new(
          :$name, :value($SELF.stubbed-meta-object)
        )
    
    });
    add-method(RakuAST::Package, 'PRODUCE-STUBBED-META-OBJECT', [RakuAST::Package, '', 0, 0], anon sub PRODUCE-STUBBED-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 246 src/Raku/ast/package.rakumod
        
        if nqp::getattr($SELF, RakuAST::Package, '$!augmented') || $SELF.is-resolved {
            $SELF.resolution.compile-time-value;
        }
        else {
            # Create the type object and return it; this stubs the type.
            my %options;
            %options<name> := nqp::getattr($SELF, RakuAST::Package, '$!name').canonicalize if nqp::getattr($SELF, RakuAST::Package, '$!name');
            %options<repr> := nqp::getattr($SELF, RakuAST::Package, '$!repr') if nqp::getattr($SELF, RakuAST::Package, '$!repr');
            if nqp::getattr($SELF, RakuAST::Package, '$!name') {
                for nqp::getattr($SELF, RakuAST::Package, '$!name').colonpairs {
                    %options{$_.key} := $_.simple-compile-time-quote-value;
                }
            }
            nqp::getattr($SELF, RakuAST::Package, '$!how').new_type(|%options)
        }
    
    });
    add-method(RakuAST::Package, 'PRODUCE-META-OBJECT', [RakuAST::Package, '', 0, 0], anon sub PRODUCE-META-OBJECT ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 264 src/Raku/ast/package.rakumod
        
        # Obtain the stubbed meta-object, which is the type object.
        my $type := $SELF.stubbed-meta-object();
        my $how  := $type.HOW;

        # Add methods and attributes.
        for nqp::getattr($SELF, RakuAST::Package, '$!attached-methods') {
            my $name := $_.name.canonicalize;
            my $meta-object := $_.meta-object;
            if nqp::istype($_, RakuAST::Method) && $_.private {
                $how.add_private_method($type, $name, $meta-object);
            }
            elsif nqp::istype($_, RakuAST::Method) && $_.meta {
                $how.add_meta_method($type, $name, $meta-object);
            }
            elsif $_.multiness eq 'multi' {
                $how.add_multi_method($type, $name, $meta-object);
            }
            else {
                $how.add_method($type, $name, $meta-object);
            }
        }
        for nqp::getattr($SELF, RakuAST::Package, '$!attached-attributes') {
            # TODO: create method BUILDALL here
            $how.add_attribute($type, $_.meta-object);
        }

        if $SELF.declarator eq 'role' {
            $how.set_body_block($type, nqp::getattr($SELF, RakuAST::Package, '$!body').meta-object);

            # The role needs to be composed before we add the possibility
            # to the group
            $how.compose($type);

            my $group := nqp::getattr($SELF, RakuAST::Package, '$!role-group');
            $group.HOW.add_possibility($group, $type) unless $group =:= Mu;
        }
        else {
            # Compose the meta-object
            $how.compose($type);
        }
        # Return the meta-object
        $type
    
    });
    add-method(RakuAST::Package, 'apply-implicit-block-semantics', [RakuAST::Package, '', 0, 0], anon sub apply-implicit-block-semantics ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 309 src/Raku/ast/package.rakumod
        
        unless nqp::getattr($SELF, RakuAST::Package, '$!block-semantics-applied') {
            $SELF.meta-object-as-body-lexicals('PACKAGE');
            $SELF.additional-body-lexicals;

            nqp::bindattr($SELF,RakuAST::Package,'$!block-semantics-applied',1);
        }
    
    });
    add-method(RakuAST::Package, 'additional-body-lexicals', [RakuAST::Package, '', 0, 0], anon sub additional-body-lexicals ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 319 src/Raku/ast/package.rakumod
        
        $SELF.meta-object-as-body-lexicals('CLASS')
          unless $SELF.declarator eq 'package';
    
    });
    add-method(RakuAST::Package, 'IMPL-EXPR-QAST', [RakuAST::Package, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 324 src/Raku/ast/package.rakumod
        
        my $type-object := $SELF.meta-object;
        $context.ensure-sc($type-object);
        my $body := nqp::getattr($SELF, RakuAST::Package, '$!body').IMPL-QAST-BLOCK($context, :blocktype<immediate>);
        my $result := QAST::Stmts.new(
            $body,
            QAST::WVal.new( :value($type-object) )
        );
        $result
    
    });
    add-method(RakuAST::Package, 'IMPL-INTERPRET', [RakuAST::Package, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 335 src/Raku/ast/package.rakumod
        
        $SELF.compile-time-value
    
    });
    add-method(RakuAST::Package, 'IMPL-COMPOSE', [RakuAST::Package, '', 0, 0], anon sub IMPL-COMPOSE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 339 src/Raku/ast/package.rakumod
        
        $SELF.meta-object; # Ensure it's composed
    
    });
    add-method(RakuAST::Package, 'visit-children', [RakuAST::Package, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 343 src/Raku/ast/package.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Package, '$!name')) if nqp::getattr($SELF, RakuAST::Package, '$!name');
        $SELF.visit-traits($visitor);
        $visitor(nqp::getattr($SELF, RakuAST::Package, '$!body'));
        $visitor($SELF.WHY) if $SELF.WHY;
    
    });
    add-method(RakuAST::Package, 'needs-sink-call', [RakuAST::Package, '', 0, 0], anon sub needs-sink-call ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 350 src/Raku/ast/package.rakumod
         (Bool.WHO)<False> 
    });
#line 23 src/Raku/ast/package.rakumod
    add-method(RakuAST::Package, 'repr', [], anon sub repr ($self) { nqp::getattr(nqp::decont($self), RakuAST::Package, '$!repr') });
#line 19 src/Raku/ast/package.rakumod
    add-method(RakuAST::Package, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Package, '$!name') });
#line 28 src/Raku/ast/package.rakumod
    add-method(RakuAST::Package, 'is-stub', [], anon sub is-stub ($self) { nqp::getattr(nqp::decont($self), RakuAST::Package, '$!is-stub') });
#line 22 src/Raku/ast/package.rakumod
    add-method(RakuAST::Package, 'how', [], anon sub how ($self) { nqp::getattr(nqp::decont($self), RakuAST::Package, '$!how') });
#line 20 src/Raku/ast/package.rakumod
    add-method(RakuAST::Package, 'body', [], anon sub body ($self) { nqp::getattr(nqp::decont($self), RakuAST::Package, '$!body') });
#line 24 src/Raku/ast/package.rakumod
    add-method(RakuAST::Package, 'augmented', [], anon sub augmented ($self) { nqp::getattr(nqp::decont($self), RakuAST::Package, '$!augmented') });
#line 21 src/Raku/ast/package.rakumod
    add-method(RakuAST::Package, 'attribute-type', [], anon sub attribute-type ($self) { nqp::getattr(nqp::decont($self), RakuAST::Package, '$!attribute-type') });
    compose(RakuAST::Package);
    parent(RakuAST::Role, RakuAST::Package);
    add-method(RakuAST::Role, 'declarator', [RakuAST::Role, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 359 src/Raku/ast/package.rakumod
         "role"                       
    });
    add-method(RakuAST::Role, 'default-how', [RakuAST::Role, '', 0, 0], anon sub default-how ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 360 src/Raku/ast/package.rakumod
         Metamodel::ParametricRoleHOW 
    });
    add-method(RakuAST::Role, 'can-have-methods', [RakuAST::Role, '', 0, 0], anon sub can-have-methods ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 362 src/Raku/ast/package.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Role, 'can-have-attributes', [RakuAST::Role, '', 0, 0], anon sub can-have-attributes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 363 src/Raku/ast/package.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Role, 'replace-body', [RakuAST::Role, '', 0, 0, RakuAST::Code, '$body', 0, 0, RakuAST::Signature, '$signature', 0, 0], anon sub replace-body ($SELF_CONT, $body!, $signature!) {
        my $SELF := nqp::decont($SELF_CONT);
        $body := nqp::decont($body);
        $signature := nqp::decont($signature);
#line 365 src/Raku/ast/package.rakumod
        
        # The body of a role is internally a Sub that has the parameterization
        # of the role as the signature.  This allows a role to be selected
        # using ordinary dispatch semantics.  The statement list gets a return
        # value added, so that the role's meta-object and lexpad are returned.
        $signature := RakuAST::Signature.new unless $signature;
        $signature.set-is-on-role-body(1);

        $body := RakuAST::Block.new unless $body;
        $body := $body.body;
        $body.statement-list.add-statement(
          RakuAST::Statement::Expression.new(
            expression => RakuAST::Nqp.new('list',
              RakuAST::Declaration::ResolvedConstant.new(
                compile-time-value => $SELF.stubbed-meta-object
              ),
              RakuAST::Nqp.new('curlexpad')
            )
          )
        );
        $body := RakuAST::Sub.new(:name($SELF.name), :$signature, :$body);

        nqp::bindattr($SELF, RakuAST::Package, '$!body', $body);
        Nil
    
    });
    add-method(RakuAST::Role, 'parameterization', [RakuAST::Role, '', 0, 0], anon sub parameterization ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 391 src/Raku/ast/package.rakumod
         $SELF.body.signature 
    });
    add-method(RakuAST::Role, 'declare-lexicals', [RakuAST::Role, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub declare-lexicals ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 393 src/Raku/ast/package.rakumod
        
        $SELF.meta-object-as-lexicals($resolver, 'ROLE');

        for '$?CLASS', '::?CLASS' {
            $resolver.declare-lexical(
              RakuAST::Type::Capture.new(RakuAST::Name.from-identifier($_))
            );
        }
    
    });
    add-method(RakuAST::Role, 'install-in-scope', [RakuAST::Role, '', 0, 0, Any, '$resolver', 0, 0, Any, '$scope', 0, 0, Any, '$name', 0, 0, Any, '$full-name', 0, 0, Any, '$type-object', 0, 0], anon sub install-in-scope ($SELF_CONT, $resolver!, $scope!, $name!, $full-name!, $type-object!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $scope := nqp::decont($scope);
        $name := nqp::decont($name);
        $full-name := nqp::decont($full-name);
        $type-object := nqp::decont($type-object);
#line 403 src/Raku/ast/package.rakumod
        
        # Find an appropriate existing role group
        my $group-name := $full-name.canonicalize(:colonpairs(0));
        my $group      := $resolver.resolve-lexical-constant($group-name);
        if $group {
            $group := $group.compile-time-value;
        }

        # No existing one found - create a role group
        else {
            $group := Perl6::Metamodel::ParametricRoleGroupHOW.new_type(
              :name($group-name), :repr($SELF.repr)
            );
            my $outer := $resolver.find-attach-target('block')
              // $resolver.find-attach-target('compunit');
            $outer.add-generated-lexical-declaration(
              RakuAST::VarDeclaration::Implicit::Constant.new(
                :name($name.canonicalize(:colonpairs(0))),
                :value($group)
              )
            );

            $SELF.IMPL-INSTALL-PACKAGE(
              $resolver, $scope, $name, $group, $resolver.current-package,
              :no-lexical
            ) if $scope eq 'our';
        }
        # Add ourselves to the role group
        $type-object.HOW.set_group($type-object, $group);
        nqp::bindattr($SELF, RakuAST::Package, '$!role-group', $group);
    
    });
    add-method(RakuAST::Role, 'additional-body-lexicals', [RakuAST::Role, '', 0, 0], anon sub additional-body-lexicals ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 435 src/Raku/ast/package.rakumod
        
        $SELF.meta-object-as-body-lexicals('ROLE');
    
    });
    compose(RakuAST::Role);
    parent(RakuAST::Class, RakuAST::Package);
    add-method(RakuAST::Class, 'declarator', [RakuAST::Class, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 446 src/Raku/ast/package.rakumod
         "class"             
    });
    add-method(RakuAST::Class, 'default-how', [RakuAST::Class, '', 0, 0], anon sub default-how ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 447 src/Raku/ast/package.rakumod
         Metamodel::ClassHOW 
    });
    add-method(RakuAST::Class, 'can-have-methods', [RakuAST::Class, '', 0, 0], anon sub can-have-methods ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 449 src/Raku/ast/package.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Class, 'can-have-attributes', [RakuAST::Class, '', 0, 0], anon sub can-have-attributes ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 450 src/Raku/ast/package.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Class, 'IMPL-COMPOSE', [RakuAST::Class, '', 0, 0], anon sub IMPL-COMPOSE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 452 src/Raku/ast/package.rakumod
        
        # create BUILDALL method if there's something to create,
        # otherwise put in a generic fallback BUILDALL that doesn't
        # do anything
        $SELF.meta-object; # Ensure it's composed
    
    });
    compose(RakuAST::Class);
    parent(RakuAST::Grammar, RakuAST::Class);
    add-method(RakuAST::Grammar, 'declarator', [RakuAST::Grammar, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 466 src/Raku/ast/package.rakumod
         "grammar"             
    });
    add-method(RakuAST::Grammar, 'default-how', [RakuAST::Grammar, '', 0, 0], anon sub default-how ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 467 src/Raku/ast/package.rakumod
         Metamodel::GrammarHOW 
    });
    add-method(RakuAST::Grammar, 'IMPL-COMPOSE', [RakuAST::Grammar, '', 0, 0], anon sub IMPL-COMPOSE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 469 src/Raku/ast/package.rakumod
        
        $SELF.meta-object; # Ensure it's composed
    
    });
    compose(RakuAST::Grammar);
    parent(RakuAST::Module, RakuAST::Package);
    add-method(RakuAST::Module, 'declarator', [RakuAST::Module, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 480 src/Raku/ast/package.rakumod
         "module"           
    });
    add-method(RakuAST::Module, 'default-how', [RakuAST::Module, '', 0, 0], anon sub default-how ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 481 src/Raku/ast/package.rakumod
         Metamodel::KnowHOW 
    });
    add-method(RakuAST::Module, 'declare-lexicals', [RakuAST::Module, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0], anon sub declare-lexicals ($SELF_CONT, $resolver!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
#line 483 src/Raku/ast/package.rakumod
        
        $SELF.meta-object-as-lexicals($resolver, 'MODULE');
    
    });
    add-method(RakuAST::Module, 'additional-body-lexicals', [RakuAST::Module, '', 0, 0], anon sub additional-body-lexicals ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 487 src/Raku/ast/package.rakumod
        
        $SELF.meta-object-as-body-lexicals('MODULE');
    
    });
    compose(RakuAST::Module);
    parent(RakuAST::Knowhow, RakuAST::Package);
    add-method(RakuAST::Knowhow, 'declarator', [RakuAST::Knowhow, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 498 src/Raku/ast/package.rakumod
         "knowhow"          
    });
    add-method(RakuAST::Knowhow, 'default-how', [RakuAST::Knowhow, '', 0, 0], anon sub default-how ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 499 src/Raku/ast/package.rakumod
         Metamodel::KnowHOW 
    });
    compose(RakuAST::Knowhow);
    parent(RakuAST::Native, RakuAST::Package);
    add-method(RakuAST::Native, 'declarator', [RakuAST::Native, '', 0, 0], anon sub declarator ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 508 src/Raku/ast/package.rakumod
         "native"             
    });
    add-method(RakuAST::Native, 'default-how', [RakuAST::Native, '', 0, 0], anon sub default-how ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 509 src/Raku/ast/package.rakumod
         Metamodel::NativeHOW 
    });
    compose(RakuAST::Native);
    parent(RakuAST::Literal, RakuAST::Term);
    parent(RakuAST::Literal, RakuAST::CompileTimeValue);
    add-attribute(RakuAST::Literal, Str, '$!typename');
    add-attribute(RakuAST::Literal, Mu, '$!value');
    add-method(RakuAST::Literal, 'new', [RakuAST::Literal, '', 0, 0, Mu, '$value', 0, 0], anon sub new ($SELF_CONT, $value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $value := nqp::decont($value);
#line 9 src/Raku/ast/literals.rakumod
        
        nqp::die("Please use RakuAST::Literal.from-value()")
          if nqp::eqaddr($SELF,RakuAST::Literal);

        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Literal, '$!value',    $value);
        nqp::bindattr($obj, RakuAST::Literal, '$!typename', nqp::null);
        $obj
    
    });
    add-method(RakuAST::Literal, 'from-value', [RakuAST::Literal, '', 0, 0, Mu, '$value', 0, 0], anon sub from-value ($SELF_CONT, $value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $value := nqp::decont($value);
#line 19 src/Raku/ast/literals.rakumod
        
        my $typename := $value.HOW.name($value);
        my $obj := nqp::create(RakuAST.WHO{$typename ~ 'Literal'});
        nqp::bindattr($obj, RakuAST::Literal, '$!value',    $value);
        nqp::bindattr($obj, RakuAST::Literal, '$!typename', $typename);
        $obj
    
    });
    add-method(RakuAST::Literal, 'set-value', [RakuAST::Literal, '', 0, 0, Mu, '$value', 0, 0], anon sub set-value ($SELF_CONT, $value!) {
        my $SELF := nqp::decont($SELF_CONT);
        $value := nqp::decont($value);
#line 27 src/Raku/ast/literals.rakumod
        
        nqp::bindattr($SELF, RakuAST::Literal, '$!value', $value);
    
    });
    add-method(RakuAST::Literal, 'expression', [RakuAST::Literal, '', 0, 0], anon sub expression ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 31 src/Raku/ast/literals.rakumod
         $SELF 
    });
    add-method(RakuAST::Literal, 'type', [RakuAST::Literal, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 32 src/Raku/ast/literals.rakumod
         nqp::getattr($SELF, RakuAST::Literal, '$!value').WHAT 
    });
    add-method(RakuAST::Literal, 'compile-time-value', [RakuAST::Literal, '', 0, 0], anon sub compile-time-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 33 src/Raku/ast/literals.rakumod
         nqp::getattr($SELF, RakuAST::Literal, '$!value') 
    });
    add-method(RakuAST::Literal, 'IMPL-CAN-INTERPRET', [RakuAST::Literal, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 34 src/Raku/ast/literals.rakumod
         (Bool.WHO)<True> 
    });
    add-method(RakuAST::Literal, 'IMPL-INTERPRET', [RakuAST::Literal, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 35 src/Raku/ast/literals.rakumod
         nqp::getattr($SELF, RakuAST::Literal, '$!value') 
    });
    add-method(RakuAST::Literal, 'ast-type', [RakuAST::Literal, '', 0, 0], anon sub ast-type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 37 src/Raku/ast/literals.rakumod
        
        RakuAST::Type::Simple.new(
          RakuAST::Name.from-identifier(
            nqp::ifnull(
              nqp::getattr($SELF, RakuAST::Literal, '$!typename'),
              nqp::bindattr($SELF,RakuAST::Literal,'$!typename',
                nqp::getattr($SELF, RakuAST::Literal, '$!value').HOW.name(nqp::getattr($SELF, RakuAST::Literal, '$!value')))
            )
          )
        )
    
    });
    add-method(RakuAST::Literal, 'IMPL-EXPR-QAST', [RakuAST::Literal, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 50 src/Raku/ast/literals.rakumod
        
        my $value := nqp::getattr($SELF, RakuAST::Literal, '$!value');
        $context.ensure-sc($value);
        QAST::WVal.new( :$value )
    
    });
#line 7 src/Raku/ast/literals.rakumod
    add-method(RakuAST::Literal, 'value', [], anon sub value ($self) { nqp::getattr(nqp::decont($self), RakuAST::Literal, '$!value') });
    compose(RakuAST::Literal);
    parent(RakuAST::Constant, RakuAST::Literal);
    add-method(RakuAST::Constant, 'deparse', [RakuAST::Constant, '', 0, 0], anon sub deparse ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 61 src/Raku/ast/literals.rakumod
         $SELF.value.raku 
    });
    compose(RakuAST::Constant);
    parent(RakuAST::IntLiteral, RakuAST::Literal);
    add-method(RakuAST::IntLiteral, 'IMPL-EXPR-QAST', [RakuAST::IntLiteral, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 67 src/Raku/ast/literals.rakumod
        
        my $value := $SELF.value;
        $context.ensure-sc($value);
        my $wval := QAST::WVal.new( :$value );
        nqp::isbig_I($value)
          ?? $wval
          !! QAST::Want.new(
               $wval,
               'Ii',
               QAST::IVal.new(:value(nqp::unbox_i($value)))
             )
    
    });
    compose(RakuAST::IntLiteral);
    parent(RakuAST::NumLiteral, RakuAST::Literal);
    add-method(RakuAST::NumLiteral, 'IMPL-EXPR-QAST', [RakuAST::NumLiteral, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 84 src/Raku/ast/literals.rakumod
        
        my $value := $SELF.value;
        $context.ensure-sc($value);
        my $wval := QAST::WVal.new( :$value );
        QAST::Want.new($wval,'Nn', QAST::NVal.new(:value(nqp::unbox_n($value))))
    
    });
    compose(RakuAST::NumLiteral);
    parent(RakuAST::RatLiteral, RakuAST::Literal);
    compose(RakuAST::RatLiteral);
    parent(RakuAST::ComplexLiteral, RakuAST::Literal);
    compose(RakuAST::ComplexLiteral);
    parent(RakuAST::VersionLiteral, RakuAST::Literal);
    compose(RakuAST::VersionLiteral);
    parent(RakuAST::ListLiteral, RakuAST::Literal);
    compose(RakuAST::ListLiteral);
    parent(RakuAST::MapLiteral, RakuAST::Literal);
    compose(RakuAST::MapLiteral);
    parent(RakuAST::StrLiteral, RakuAST::Literal);
    add-method(RakuAST::StrLiteral, 'IMPL-EXPR-QAST', [RakuAST::StrLiteral, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 118 src/Raku/ast/literals.rakumod
        
        my $value := $SELF.value;
        $context.ensure-sc($value);
        my $wval := QAST::WVal.new( :$value );
        QAST::Want.new($wval,'Ss', QAST::SVal.new(:value(nqp::unbox_s($value))))
    
    });
    compose(RakuAST::StrLiteral);
    parent(RakuAST::QuotedString, RakuAST::ColonPairish);
    parent(RakuAST::QuotedString, RakuAST::Term);
    parent(RakuAST::QuotedString, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::QuotedString, Mu, '$!segments');
    add-attribute(RakuAST::QuotedString, Mu, '$!processors');
    add-method(RakuAST::QuotedString, 'new', [RakuAST::QuotedString, '', 0, 0, List, '$segments', 1, 0, List, '$processors', 1, 1], anon sub new ($SELF_CONT, :$segments!, :$processors?) {
        my $SELF := nqp::decont($SELF_CONT);
        $segments := nqp::decont($segments);
        $processors := nqp::decont($processors);
#line 138 src/Raku/ast/literals.rakumod
        
        nqp::create($SELF).SET-SELF($segments, $processors)
    
    });
    add-method(RakuAST::QuotedString, 'SET-SELF', [RakuAST::QuotedString, '', 0, 0, List, '$segments', 0, 0, List, '$processors', 0, 0], anon sub SET-SELF ($SELF_CONT, $segments!, $processors!) {
        my $SELF := nqp::decont($SELF_CONT);
        $segments := nqp::decont($segments);
        $processors := nqp::decont($processors);
#line 143 src/Raku/ast/literals.rakumod
        
        nqp::bindattr($SELF, RakuAST::QuotedString, '$!segments',
            $SELF.IMPL-UNWRAP-LIST($segments));
        nqp::bindattr($SELF, RakuAST::QuotedString, '$!processors',
            $SELF.IMPL-CHECK-PROCESSORS($processors));
        $SELF
    
    });
    add-method(RakuAST::QuotedString, 'IMPL-CHECK-PROCESSORS', [RakuAST::QuotedString, '', 0, 0, Mu, '$processors', 0, 0], anon sub IMPL-CHECK-PROCESSORS ($SELF_CONT, $processors!) {
        my $SELF := nqp::decont($SELF_CONT);
        $processors := nqp::decont($processors);
#line 151 src/Raku/ast/literals.rakumod
        
        my constant VALID := nqp::hash('words', Mu, 'quotewords', Mu, 'val', Mu, 'exec', Mu, 'heredoc', Mu, 'format', Mu);
        my @result;
        for $SELF.IMPL-UNWRAP-LIST($processors // []) {
            if nqp::existskey(VALID, $_) {
                nqp::push(@result, nqp::box_s($_, Str));
            }
            else {
                nqp::die("Unsupported quoted string processor '$_'");
            }
        }
        @result
    
    });
    add-method(RakuAST::QuotedString, 'segments', [RakuAST::QuotedString, '', 0, 0], anon sub segments ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 165 src/Raku/ast/literals.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::QuotedString, '$!segments'))
    
    });
    add-method(RakuAST::QuotedString, 'processors', [RakuAST::QuotedString, '', 0, 0], anon sub processors ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 169 src/Raku/ast/literals.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::QuotedString, '$!processors'))
    
    });
    add-method(RakuAST::QuotedString, 'canonicalize', [RakuAST::QuotedString, '', 0, 0], anon sub canonicalize ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 173 src/Raku/ast/literals.rakumod
        
        $SELF.IMPL-QUOTE-VALUE($SELF.literal-value // '')
    
    });
    add-method(RakuAST::QuotedString, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::QuotedString, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 177 src/Raku/ast/literals.rakumod
        
        my @needed;
        if nqp::elems(nqp::getattr($SELF, RakuAST::QuotedString, '$!processors')) {
            for nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') {
                if $_ eq 'val' {
                    nqp::push(@needed, RakuAST::Var::Lexical::Setting.new(
                        :sigil<&>,
                        :desigilname(RakuAST::Name.from-identifier('val'))));
                    last;
                }
                elsif $_ eq 'format' {
                    nqp::push(@needed, RakuAST::Var::Lexical::Setting.new(
                        :desigilname(RakuAST::Name.from-identifier('Format'))));
                    last;
                }
            }
        }
        $SELF.IMPL-WRAP-LIST(@needed)
    
    });
    add-method(RakuAST::QuotedString, 'has-variables', [RakuAST::QuotedString, '', 0, 0], anon sub has-variables ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 197 src/Raku/ast/literals.rakumod
        
        for nqp::getattr($SELF, RakuAST::QuotedString, '$!segments') {
            return (Bool.WHO)<True> if nqp::istype($_,RakuAST::Var);
        }
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::QuotedString, 'type', [RakuAST::QuotedString, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 204 src/Raku/ast/literals.rakumod
        
        if nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') {
            # Can probably figure some of these out.
            Mu
        }
        else {
            # Always a string if no processors.
            Str
        }
    
    });
    add-method(RakuAST::QuotedString, 'ast-type', [RakuAST::QuotedString, '', 0, 0], anon sub ast-type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 215 src/Raku/ast/literals.rakumod
        
        if nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') {
            # Can probably figure some of these out.
            nqp::die('NYI ast-type of non-trivial quoted strings');
        }
        else {
            # Always a string if no processors.
            RakuAST::Type::Simple.new(RakuAST::Name.from-identifier('Str'))
        }
    
    });
    add-method(RakuAST::QuotedString, 'IMPL-PROCESS-PART', [RakuAST::QuotedString, '', 0, 0, Any, '$result', 0, 0, Any, '$part', 0, 0], anon sub IMPL-PROCESS-PART ($SELF_CONT, $result!, $part!) {
        my $SELF := nqp::decont($SELF_CONT);
        $result := nqp::decont($result);
        $part := nqp::decont($part);
#line 226 src/Raku/ast/literals.rakumod
        
        return Nil if $part =:= Nil;
        for nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') {
            if $_ eq 'words' {
                return Nil unless nqp::istype($part, Str);
                my @parts;
                for $part.WORDS_AUTODEREF.FLATTENABLE_LIST {
                    nqp::push(@parts, $_);
                }
                $part := @parts;
            }
            elsif $_ eq 'quotewords' {
                return Nil unless nqp::istype($part, Str);
                #TODO actually implement special handling of « »
                my @parts;
                for $part.WORDS_AUTODEREF.FLATTENABLE_LIST {
                    nqp::push(@parts, $_);
                }
                $part := @parts;
            }
            elsif $_ eq 'val' {
                my $val := $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
                $part := $val(nqp::hllizefor($part, 'Raku'));
            }
            elsif $_ eq 'heredoc' {
            }
            elsif $_ eq 'format' {
            }
            else {
                return Nil;
            }
        }
        if nqp::islist($part) {
            for $part {
                nqp::push($result, $_);
            }
        }
        elsif nqp::istype($part, List) {
            for $part.FLATTENABLE_LIST {
                nqp::push($result, $_);
            }
        }
        else {
            nqp::push($result, $part);
        }
        (Bool.WHO)<True>
    
    });
    add-method(RakuAST::QuotedString, 'literal-value', [RakuAST::QuotedString, '', 0, 0], anon sub literal-value ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 276 src/Raku/ast/literals.rakumod
        
        my @parts;
        for nqp::getattr($SELF, RakuAST::QuotedString, '$!segments') {
            if nqp::istype($_, RakuAST::StrLiteral) {
                $SELF.IMPL-PROCESS-PART(@parts, $_.value) || return Nil;
            }
            elsif nqp::istype($_, RakuAST::QuoteWordsAtom)
                && nqp::istype($_.atom, RakuAST::QuotedString)
                && my $nested-str := $_.atom.literal-value
            {
                return Nil if $nested-str =:= Nil;

                if nqp::istype($nested-str, Str) {
                    nqp::push(@parts, $nested-str);
                }
                elsif nqp::istype($nested-str, List) {
                    for $nested-str.FLATTENABLE_LIST {
                        nqp::push(@parts, $_);
                    }
                }
            }
            elsif nqp::istype($_, RakuAST::Var::Lexical)
                && $_.is-resolved
                && nqp::istype($_.resolution, RakuAST::VarDeclaration::Constant)
            {
                $SELF.IMPL-PROCESS-PART(@parts, $_.resolution.compile-time-value.Str) || return Nil;
            }
            else {
                return Nil;
            }
        }

        my int $return-list := 0;
        for nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') {
            if $_ eq 'words' {
                $return-list := 1;
            }
            elsif $_ eq 'quotewords' {
                $return-list := 1;
            }
            elsif $_ eq 'val' && nqp::elems(@parts) == 1 {
                $return-list := 0;
            }
        }
        return $return-list
            ?? nqp::hllizefor(@parts, 'Raku')
            !! nqp::elems(@parts) == 1
                ?? @parts[0] # need to preserve val() result
                !! nqp::box_s(nqp::join('', @parts), Str);
    
    });
    add-method(RakuAST::QuotedString, 'is-empty-words', [RakuAST::QuotedString, '', 0, 0], anon sub is-empty-words ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 328 src/Raku/ast/literals.rakumod
        
        # Is it empty?
        return (Bool.WHO)<False> if nqp::elems(nqp::getattr($SELF, RakuAST::QuotedString, '$!segments')) >= 2;
        if nqp::elems(nqp::getattr($SELF, RakuAST::QuotedString, '$!segments')) == 1 {
            my $seg := nqp::getattr($SELF, RakuAST::QuotedString, '$!segments')[0];
            return (Bool.WHO)<False> unless nqp::istype($seg, RakuAST::StrLiteral) && $seg.value eq '';
        }

        # Yes, but is it quote words?
        for nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') {
            if $_ eq 'words' {
                return (Bool.WHO)<True>;
            }
        }
        (Bool.WHO)<False>
    
    });
    add-method(RakuAST::QuotedString, 'dump-extras', [RakuAST::QuotedString, '', 0, 0, int, '$indent', 0, 0], anon sub dump-extras ($SELF_CONT, $indent!) {
        my $SELF := nqp::decont($SELF_CONT);
        $indent := nqp::decont($indent);
#line 345 src/Raku/ast/literals.rakumod
        
        nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') && nqp::elems(nqp::getattr($SELF, RakuAST::QuotedString, '$!processors'))
            ?? nqp::x(' ', $indent) ~ 'postprocessors: ' ~ nqp::join(', ', nqp::getattr($SELF, RakuAST::QuotedString, '$!processors')) ~ "\n"
            !! ''
    
    });
    add-method(RakuAST::QuotedString, 'IMPL-EXPR-QAST', [RakuAST::QuotedString, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-EXPR-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 351 src/Raku/ast/literals.rakumod
        
        # If we can constant fold it, just produce the constant.
        my $literal-value := $SELF.literal-value;
        if nqp::isconcrete($literal-value) {

            # format string
            if nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') && nqp::getattr($SELF, RakuAST::QuotedString, '$!processors')[0] eq 'format' {
                my $Format := $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;

# The below code "should" work, but doesn't because references to internal
# subs (such as "str-right-justified") appear to be QASTed correctly, but
# when executed, do *not* call the unit in question, but simply return the
# arguments that were given.  Not sure what is going on here.  For now,
# create the format at run-time: it will still get cached, but *will* incur
# a performance penalty at runtime, which is too bad because the whole idea
# of a quote string format, was to create all of this at compile time.
#
#                my $format := $Format.new($literal-value);
#                $context.ensure-sc($format);
#                return QAST::WVal.new(:value($format));

                # for now, until above fixed
                $context.ensure-sc($literal-value);
                return QAST::Op.new(
                  :op('callmethod'), :name('new'),
                  QAST::WVal.new( :value($Format) ),
                  QAST::WVal.new( :value($literal-value) )
                );
            }

            $context.ensure-sc($literal-value);
            my $wval := QAST::WVal.new( :value($literal-value) );
            return nqp::istype($literal-value, Str)
                ?? QAST::Want.new(
                     $wval,
                     'Ss',
                     QAST::SVal.new( :value(nqp::unbox_s($literal-value)) )
                   )
                !! $wval;
        }

        # Otherwise, needs compilation.
        my @segment-asts;
        for nqp::getattr($SELF, RakuAST::QuotedString, '$!segments') {
            if $_.type =:= Str || nqp::istype($_, RakuAST::QuoteWordsAtom) {
                @segment-asts.push($_.IMPL-TO-QAST($context));
            }
            else {
                my $inter-qast := $_.IMPL-TO-QAST($context);
                if nqp::istype($_, RakuAST::Block) {
                    $inter-qast := QAST::Op.new( :op('call'), $inter-qast );
                }
                @segment-asts.push(QAST::Op.new(
                    :op('callmethod'), :name('Str'),
                    $inter-qast
                ));
            }
        }
        my int $seg-count := nqp::elems(@segment-asts);
        my $qast;
        if $seg-count == 1 {
            $qast := @segment-asts[0];
        }
        elsif $seg-count == 2 {
            $qast := QAST::Op.new( :op('concat'), @segment-asts[0], @segment-asts[1] )
        }
        else {
            $qast := QAST::Op.new(
                :op('join'),
                QAST::SVal.new( :value('') ),
                QAST::Op.new( :op('list_s'), |@segment-asts )
            )
        }
        $SELF.IMPL-QAST-PROCESSORS($context, $qast)
    
    });
    add-method(RakuAST::QuotedString, 'IMPL-WALK', [RakuAST::QuotedString, '', 0, 0, Any, '$context', 0, 0, Any, '$node', 0, 0, Any, '$result', 0, 0], anon sub IMPL-WALK ($SELF_CONT, $context!, $node!, $result!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $node := nqp::decont($node);
        $result := nqp::decont($result);
#line 427 src/Raku/ast/literals.rakumod
        
        if $node.ann('ww_atom') {
            $result.push($node);
        }
        elsif nqp::istype($node, QAST::Op) && $node.name eq '&infix:<~>' {
            $SELF.IMPL-WALK($context, $node[0], $result);
            $SELF.IMPL-WALK($context, $node[1], $result);
        }
        elsif nqp::istype($node, QAST::Op) && $node.op eq 'concat' {
            $SELF.IMPL-WALK($context, $node[0], $result);
            $SELF.IMPL-WALK($context, $node[1], $result);
        }
        elsif nqp::istype($node, QAST::Op) && $node.op eq 'join' {
            for $node[1].list {
                $SELF.IMPL-WALK($context, $_, $result);
            }
        }
        # (can't just use postprocess_words here because it introduces spurious comma operations)
        elsif $node.has_compile_time_value {
            my @words := HLL::Grammar.split_words(nqp::unbox_s($node.compile_time_value));
            for @words {
                $result.push(RakuAST::StrLiteral.new($_).IMPL-EXPR-QAST($context));
            }
        }
        else {
            $result.push(
                QAST::Op.new(
                    :op('callmethod'),
                    :name('Slip'),
                    QAST::Op.new(
                        :op('callmethod'),
                        :name('WORDS_AUTODEREF'),
                        QAST::Op.new(
                            :op('callmethod'),
                            :name('Stringy'),
                            $node
                        )
                    )
                )
            );
        }
    
    });
    add-method(RakuAST::QuotedString, 'IMPL-QAST-PROCESSORS', [RakuAST::QuotedString, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$qast', 0, 0], anon sub IMPL-QAST-PROCESSORS ($SELF_CONT, $context!, $qast!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $qast := nqp::decont($qast);
#line 470 src/Raku/ast/literals.rakumod
        
        # Non-optimized handling of processors.
        for nqp::getattr($SELF, RakuAST::QuotedString, '$!processors') {
            if $_ eq 'words' {
                $qast := QAST::Op.new(
                    :op('callmethod'), :name('WORDS_AUTODEREF'), $qast
                );
            }
            elsif $_ eq 'quotewords' {
                my $result := QAST::Op.new( :op('call'), :name('&infix:<,>') );
                $SELF.IMPL-WALK($context, $qast, $result);

                # Strip out list op and possible Slip if only one resulting word
                $qast := nqp::elems($result) == 1
                    ?? nqp::istype($result[0], QAST::Op) && $result[0].name eq 'Slip'
                        ?? $result[0][0]
                        !! $result[0]
                    !! QAST::Stmts.new( $result );
            }
            elsif $_ eq 'val' {
                my $name :=
                  $SELF.get-implicit-lookups.AT-POS(0).resolution.lexical-name;
                $qast := QAST::Op.new(:op('call'), :$name, $qast);
            }
            elsif $_ eq 'exec' {
                $qast := QAST::Op.new(
                    :op('call'), :name('&QX'), $qast
                );
            }
            elsif $_ eq 'heredoc' {
                $qast := QAST::Op.new(
                    :op('die_s'), QAST::SVal.new( :value("Premature heredoc consumption") )
                );
            }
            elsif $_ eq 'format' {
                my $Format := $SELF.get-implicit-lookups.AT-POS(0).resolution.compile-time-value;
                $qast := QAST::Op.new(
                  :op('callmethod'), :name('new'),
                  QAST::WVal.new( :value($Format)),
                  $qast
                );
            }
            else {
                nqp::die("Compiling processor '$_' is not implemented");
            }
        }
        $qast
    
    });
    add-method(RakuAST::QuotedString, 'visit-children', [RakuAST::QuotedString, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 519 src/Raku/ast/literals.rakumod
        
        my @segments := nqp::getattr($SELF, RakuAST::QuotedString, '$!segments');
        for @segments {
            $visitor($_);
        }
    
    });
    add-method(RakuAST::QuotedString, 'IMPL-CAN-INTERPRET', [RakuAST::QuotedString, '', 0, 0], anon sub IMPL-CAN-INTERPRET ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 526 src/Raku/ast/literals.rakumod
        
        nqp::isconcrete($SELF.literal-value) ?? (Bool.WHO)<True> !! (Bool.WHO)<False>
    
    });
    add-method(RakuAST::QuotedString, 'IMPL-INTERPRET', [RakuAST::QuotedString, '', 0, 0, RakuAST::IMPL::InterpContext, '$ctx', 0, 0], anon sub IMPL-INTERPRET ($SELF_CONT, $ctx!) {
        my $SELF := nqp::decont($SELF_CONT);
        $ctx := nqp::decont($ctx);
#line 530 src/Raku/ast/literals.rakumod
        
        $SELF.literal-value
    
    });
    compose(RakuAST::QuotedString);
    parent(RakuAST::Heredoc, RakuAST::QuotedString);
    add-attribute(RakuAST::Heredoc, Str, '$!stop');
    add-attribute(RakuAST::Heredoc, int, '$!indent');
    add-method(RakuAST::Heredoc, 'new', [RakuAST::Heredoc, '', 0, 0, List, '$segments', 1, 0, List, '$processors', 1, 1, Str, '$stop', 1, 1], anon sub new ($SELF_CONT, :$segments!, :$processors?, :$stop?) {
        my $SELF := nqp::decont($SELF_CONT);
        $segments := nqp::decont($segments);
        $processors := nqp::decont($processors);
        $stop := nqp::decont($stop);
#line 541 src/Raku/ast/literals.rakumod
        
        my $obj := nqp::create($SELF).SET-SELF($segments, $processors);
        nqp::bindattr($obj, RakuAST::Heredoc, '$!stop', $stop // '');
        $obj
    
    });
    add-method(RakuAST::Heredoc, 'replace-segments-from', [RakuAST::Heredoc, '', 0, 0, RakuAST::QuotedString, '$source', 0, 0], anon sub replace-segments-from ($SELF_CONT, $source!) {
        my $SELF := nqp::decont($SELF_CONT);
        $source := nqp::decont($source);
#line 547 src/Raku/ast/literals.rakumod
        
        nqp::bindattr(
            $SELF,
            RakuAST::QuotedString,
            '$!segments',
            nqp::getattr($source, RakuAST::QuotedString, '$!segments')
        );
        Nil
    
    });
    add-method(RakuAST::Heredoc, 'steal-processors-from', [RakuAST::Heredoc, '', 0, 0, RakuAST::QuotedString, '$source', 0, 0], anon sub steal-processors-from ($SELF_CONT, $source!) {
        my $SELF := nqp::decont($SELF_CONT);
        $source := nqp::decont($source);
#line 557 src/Raku/ast/literals.rakumod
        
        my $processors := nqp::getattr($SELF, RakuAST::QuotedString, '$!processors');
        for $SELF.IMPL-UNWRAP-LIST($source.processors) {
            nqp::push($processors, $_);
        }
        # Also steal the implicit lookups as any processor related lookups will
        # have been done before we got to stealing those processors.
        nqp::bindattr(
            $SELF,
            RakuAST::ImplicitLookups,
            '$!implicit-lookups-cache',
            nqp::getattr($source, RakuAST::ImplicitLookups, '$!implicit-lookups-cache')
        );
    
    });
    add-method(RakuAST::Heredoc, 'set-stop', [RakuAST::Heredoc, '', 0, 0, Str, '$stop', 0, 0], anon sub set-stop ($SELF_CONT, $stop!) {
        my $SELF := nqp::decont($SELF_CONT);
        $stop := nqp::decont($stop);
#line 572 src/Raku/ast/literals.rakumod
        
        nqp::bindattr($SELF, RakuAST::Heredoc, '$!stop', $stop);
    
    });
    add-method(RakuAST::Heredoc, 'stop', [RakuAST::Heredoc, '', 0, 0], anon sub stop ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 575 src/Raku/ast/literals.rakumod
         nqp::getattr($SELF, RakuAST::Heredoc, '$!stop') 
    });
    add-method(RakuAST::Heredoc, 'set-indent', [RakuAST::Heredoc, '', 0, 0, int, '$indent', 0, 0], anon sub set-indent ($SELF_CONT, $indent!) {
        my $SELF := nqp::decont($SELF_CONT);
        $indent := nqp::decont($indent);
#line 577 src/Raku/ast/literals.rakumod
        
        nqp::bindattr_i($SELF, RakuAST::Heredoc, '$!indent', $indent);
    
    });
    add-method(RakuAST::Heredoc, 'trim', [RakuAST::Heredoc, '', 0, 0], anon sub trim ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 581 src/Raku/ast/literals.rakumod
        
        # Remove heredoc postprocessor to defuse the "Premature heredoc consumption" error
        my $processors := nqp::getattr($SELF, RakuAST::QuotedString, '$!processors');
        my $new_processors := [];
        nqp::bindattr($SELF, RakuAST::QuotedString, '$!processors', $new_processors);
        for $processors {
            nqp::push($new_processors, $_) if $_ ne 'heredoc';
        }

        if (nqp::getattr_i($SELF, RakuAST::Heredoc, '$!indent')) {
            my int $indent := -nqp::getattr_i($SELF, RakuAST::Heredoc, '$!indent');

            my $in-fresh-line := 1;
            for $SELF.IMPL-UNWRAP-LIST($SELF.segments) {
                if nqp::istype($_, RakuAST::StrLiteral) && !nqp::istype($_, RakuAST::Heredoc::InterpolatedWhiteSpace) {
                    if $in-fresh-line {
                        $_.set-value($_.value.indent($indent));
                    }
                    else {
                        my $strval := $_.value;
                        if $strval ~~ /\n/ { # we have more lines
                            # add temporary indentation to the front, so every line will be indented
                            my $strbox := nqp::box_s(nqp::x(" ", -$indent) ~ nqp::unbox_s($strval), Str);
                            $in-fresh-line := 1;
                            $_.set-value($strbox.indent($indent));
                        }
                    }
                }
                else {
                    $in-fresh-line := 0;
                }
            }
        }
    
    });
    compose(RakuAST::Heredoc);
    parent(RakuAST::Heredoc::InterpolatedWhiteSpace, RakuAST::StrLiteral);
    compose(RakuAST::Heredoc::InterpolatedWhiteSpace);
    parent(RakuAST::QuoteWordsAtom, RakuAST::Node);
    add-attribute(RakuAST::QuoteWordsAtom, RakuAST::Node, '$!atom');
    add-method(RakuAST::QuoteWordsAtom, 'new', [RakuAST::QuoteWordsAtom, '', 0, 0, RakuAST::Node, '$atom', 0, 0], anon sub new ($SELF_CONT, $atom!) {
        my $SELF := nqp::decont($SELF_CONT);
        $atom := nqp::decont($atom);
#line 627 src/Raku/ast/literals.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::QuoteWordsAtom, '$!atom', $atom);
        $obj
    
    });
    add-method(RakuAST::QuoteWordsAtom, 'type', [RakuAST::QuoteWordsAtom, '', 0, 0], anon sub type ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 633 src/Raku/ast/literals.rakumod
        
        nqp::getattr($SELF, RakuAST::QuoteWordsAtom, '$!atom').type
    
    });
    add-method(RakuAST::QuoteWordsAtom, 'IMPL-TO-QAST', [RakuAST::QuoteWordsAtom, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-TO-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 637 src/Raku/ast/literals.rakumod
        
        my $qast := nqp::getattr($SELF, RakuAST::QuoteWordsAtom, '$!atom').IMPL-TO-QAST($context);
        $qast.annotate('ww_atom', 1);
        $qast
    
    });
    add-method(RakuAST::QuoteWordsAtom, 'visit-children', [RakuAST::QuoteWordsAtom, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 643 src/Raku/ast/literals.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::QuoteWordsAtom, '$!atom'))
    
    });
#line 625 src/Raku/ast/literals.rakumod
    add-method(RakuAST::QuoteWordsAtom, 'atom', [], anon sub atom ($self) { nqp::getattr(nqp::decont($self), RakuAST::QuoteWordsAtom, '$!atom') });
    compose(RakuAST::QuoteWordsAtom);
    parent(RakuAST::Regex, RakuAST::Node);
    add-method(RakuAST::Regex, 'IMPL-REGEX-TOP-LEVEL-QAST', [RakuAST::Regex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$code-object', 0, 0, Any, '%mods', 0, 0, int, '$no-scan', 1, 1, Mu, '$body-qast', 1, 1, str, '$name', 1, 1], anon sub IMPL-REGEX-TOP-LEVEL-QAST ($SELF_CONT, $context!, $code-object!, %mods!, :$no-scan?, :$body-qast?, :$name?) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $code-object := nqp::decont($code-object);
        %mods := nqp::decont(%mods);
        $no-scan := nqp::decont($no-scan);
        $body-qast := nqp::decont($body-qast);
        $name := nqp::decont($name);
#line 12 src/Raku/ast/regex.rakumod
        
        # Compile the regex.
        my $regex-qast := $body-qast // $SELF.IMPL-REGEX-QAST($context, %mods);

        # Store its captures and NFA.
        $code-object.SET_CAPS(QRegex::P6Regex::Actions.capnames($regex-qast, 0));
        # TODO top-level NFA if applicable (e.g. if named rule)
        QRegex::P6Regex::Actions.alt_nfas($code-object, $regex-qast, $context.sc-handle);

        # Wrap in scan/pass as appropriate.
        my $wrap-qast := QAST::Regex.new(
            :rxtype('concat'),
            $regex-qast,
            ($name
              ?? QAST::Regex.new(:rxtype('pass'), :$name)
              !! QAST::Regex.new(:rxtype('pass'))
            )
        );
        unless $no-scan {
            $wrap-qast.unshift(QAST::Regex.new( :rxtype('scan') ));
        }
        $wrap-qast
    
    });
    add-method(RakuAST::Regex, 'IMPL-REGEX-BLOCK-CALL', [RakuAST::Regex, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, RakuAST::Block, '$block', 0, 0], anon sub IMPL-REGEX-BLOCK-CALL ($SELF_CONT, $context!, $block!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $block := nqp::decont($block);
#line 36 src/Raku/ast/regex.rakumod
        
        QAST::Stmts.new(
            QAST::Op.new(
                :op('p6store'),
                QAST::Var.new( :name('$/'), :scope<lexical> ),
                QAST::Op.new(
                    QAST::Var.new( :name('$¢'), :scope<lexical> ),
                    :name('MATCH'),
                    :op('callmethod')
                )
            ),
            $block.IMPL-TO-QAST($context, :immediate)
        )
    
    });
    add-method(RakuAST::Regex, 'IMPL-APPLY-LITERAL-MODS', [RakuAST::Regex, '', 0, 0, Mu, '$qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-APPLY-LITERAL-MODS ($SELF_CONT, $qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $qast := nqp::decont($qast);
        %mods := nqp::decont(%mods);
#line 51 src/Raku/ast/regex.rakumod
        
        if %mods<i> && %mods<m> {
            $qast.subtype('ignorecase+ignoremark')
        }
        elsif %mods<i> {
            $qast.subtype('ignorecase')
        }
        elsif %mods<m> {
            $qast.subtype('ignoremark')
        }
        $qast
    
    });
    add-method(RakuAST::Regex, 'IMPL-SUBRULE-ALIAS', [RakuAST::Regex, '', 0, 0, Mu, '$qast', 0, 0, str, '$name', 0, 0], anon sub IMPL-SUBRULE-ALIAS ($SELF_CONT, $qast!, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $qast := nqp::decont($qast);
        $name := nqp::decont($name);
#line 64 src/Raku/ast/regex.rakumod
        
        if $qast.name gt '' {
            $qast.name($name ~ '=' ~ $qast.name);
        }
        else {
            $qast.name($name);
        }
        $qast.subtype('capture');
        $qast
    
    });
    compose(RakuAST::Regex);
    parent(RakuAST::Regex::Branching, RakuAST::Regex);
    add-attribute(RakuAST::Regex::Branching, Mu, '$!branches');
    add-method(RakuAST::Regex::Branching, 'new', [RakuAST::Regex::Branching, '', 0, 0, Any, '@branches', 0, 0], anon sub new ($SELF_CONT, *@branches) {
        my $SELF := nqp::decont($SELF_CONT);
        @branches := nqp::decont(@branches);
#line 82 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Branching, '$!branches',
            @branches);
        $obj
    
    });
    add-method(RakuAST::Regex::Branching, 'branches', [RakuAST::Regex::Branching, '', 0, 0], anon sub branches ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 89 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Regex::Branching, '$!branches'))
    
    });
    add-method(RakuAST::Regex::Branching, 'IMPL-REGEX-QAST', [RakuAST::Regex::Branching, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 93 src/Raku/ast/regex.rakumod
        
        my $qast := QAST::Regex.new(:rxtype($SELF.IMPL-QAST-REGEX-TYPE));
        for nqp::getattr($SELF, RakuAST::Regex::Branching, '$!branches') {
            my $branch-qast := $_.IMPL-REGEX-QAST($context, %mods);
            $branch-qast.backtrack('r') if %mods<r> && !$branch-qast.backtrack;
            $qast.push($branch-qast);
        }
        $qast
    
    });
    add-method(RakuAST::Regex::Branching, 'visit-children', [RakuAST::Regex::Branching, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 103 src/Raku/ast/regex.rakumod
        
        for nqp::getattr($SELF, RakuAST::Regex::Branching, '$!branches') {
            $visitor($_);
        }
    
    });
    compose(RakuAST::Regex::Branching);
    parent(RakuAST::Regex::SequentialAlternation, RakuAST::Regex::Branching);
    add-method(RakuAST::Regex::SequentialAlternation, 'IMPL-QAST-REGEX-TYPE', [RakuAST::Regex::SequentialAlternation, '', 0, 0], anon sub IMPL-QAST-REGEX-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 114 src/Raku/ast/regex.rakumod
         'altseq' 
    });
    compose(RakuAST::Regex::SequentialAlternation);
    parent(RakuAST::Regex::SequentialConjunction, RakuAST::Regex::Branching);
    add-method(RakuAST::Regex::SequentialConjunction, 'IMPL-QAST-REGEX-TYPE', [RakuAST::Regex::SequentialConjunction, '', 0, 0], anon sub IMPL-QAST-REGEX-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 121 src/Raku/ast/regex.rakumod
         'conjseq' 
    });
    compose(RakuAST::Regex::SequentialConjunction);
    parent(RakuAST::Regex::Alternation, RakuAST::Regex::Branching);
    add-method(RakuAST::Regex::Alternation, 'IMPL-QAST-REGEX-TYPE', [RakuAST::Regex::Alternation, '', 0, 0], anon sub IMPL-QAST-REGEX-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 128 src/Raku/ast/regex.rakumod
         'alt' 
    });
    compose(RakuAST::Regex::Alternation);
    parent(RakuAST::Regex::Conjunction, RakuAST::Regex::Branching);
    add-method(RakuAST::Regex::Conjunction, 'IMPL-QAST-REGEX-TYPE', [RakuAST::Regex::Conjunction, '', 0, 0], anon sub IMPL-QAST-REGEX-TYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 135 src/Raku/ast/regex.rakumod
         'conj' 
    });
    compose(RakuAST::Regex::Conjunction);
    parent(RakuAST::Regex::Sequence, RakuAST::Regex);
    add-attribute(RakuAST::Regex::Sequence, Mu, '$!terms');
    add-method(RakuAST::Regex::Sequence, 'new', [RakuAST::Regex::Sequence, '', 0, 0, Any, '@atoms', 0, 0], anon sub new ($SELF_CONT, *@atoms) {
        my $SELF := nqp::decont($SELF_CONT);
        @atoms := nqp::decont(@atoms);
#line 144 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);

        my @terms;
        my @literals;

        my sub handle-literals($with-whitespace) {
            my $literal := RakuAST::Regex::Literal.new(nqp::join('',@literals));
            @terms.push($with-whitespace
              ?? RakuAST::Regex::WithWhitespace.new($literal)
              !! $literal
            );
            nqp::setelems(@literals, 0);
        }

        for @atoms {
            if nqp::istype($_, RakuAST::Regex::Literal) {
                @literals.push($_.text);
            }
            elsif nqp::istype($_, RakuAST::Regex::WithWhitespace) {
                my $regex := $_.regex;
                if nqp::istype($regex, RakuAST::Regex::Literal) && @literals {
                    @literals.push($regex.text);
                    handle-literals((Bool.WHO)<True>);
                }
                else {
                    handle-literals((Bool.WHO)<False>) if @literals;
                    @terms.push($_);
                }
            }
            else {
                handle-literals((Bool.WHO)<False>) if @literals;
                @terms.push($_);
            }
        }
        handle-literals((Bool.WHO)<False>) if @literals;

        nqp::bindattr($obj, RakuAST::Regex::Sequence, '$!terms', @terms);
        $obj
    
    });
    add-method(RakuAST::Regex::Sequence, 'terms', [RakuAST::Regex::Sequence, '', 0, 0], anon sub terms ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 185 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Regex::Sequence, '$!terms'))
    
    });
    add-method(RakuAST::Regex::Sequence, 'IMPL-REGEX-QAST', [RakuAST::Regex::Sequence, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 189 src/Raku/ast/regex.rakumod
        
        my $concat := QAST::Regex.new(:rxtype<concat>);
        my str $collect-literals := '';
        for nqp::getattr($SELF, RakuAST::Regex::Sequence, '$!terms') {
            if nqp::istype($_, RakuAST::Regex::Literal) {
                $collect-literals := $collect-literals ~ $_.text;
            }
            else {
                if $collect-literals ne '' {
                    $concat.push($SELF.IMPL-LIT($collect-literals, %mods));
                    $collect-literals := '';
                }
                my $qast := $_.IMPL-REGEX-QAST($context, %mods);
                if $qast {
                    $qast.backtrack('r') if %mods<r> && !$qast.backtrack;
                    $concat.push($qast);
                }
            }
        }
        if $collect-literals ne '' {
            $concat.push($SELF.IMPL-LIT($collect-literals, %mods));
        }
        $concat
    
    });
    add-method(RakuAST::Regex::Sequence, 'IMPL-LIT', [RakuAST::Regex::Sequence, '', 0, 0, str, '$text', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-LIT ($SELF_CONT, $text!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $text := nqp::decont($text);
        %mods := nqp::decont(%mods);
#line 214 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-APPLY-LITERAL-MODS:
            QAST::Regex.new( :rxtype<literal>, $text ),
            %mods
    
    });
    add-method(RakuAST::Regex::Sequence, 'visit-children', [RakuAST::Regex::Sequence, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 220 src/Raku/ast/regex.rakumod
        
        for nqp::getattr($SELF, RakuAST::Regex::Sequence, '$!terms') {
            $visitor($_);
        }
    
    });
    compose(RakuAST::Regex::Sequence);
    parent(RakuAST::Regex::Term, RakuAST::Regex);
    add-method(RakuAST::Regex::Term, 'whitespace-wrappable', [RakuAST::Regex::Term, '', 0, 0], anon sub whitespace-wrappable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 231 src/Raku/ast/regex.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::Regex::Term);
    parent(RakuAST::Regex::Atom, RakuAST::Regex::Term);
    add-method(RakuAST::Regex::Atom, 'quantifiable', [RakuAST::Regex::Atom, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 238 src/Raku/ast/regex.rakumod
         (Bool.WHO)<True> 
    });
    compose(RakuAST::Regex::Atom);
    parent(RakuAST::Regex::Literal, RakuAST::Regex::Atom);
    add-attribute(RakuAST::Regex::Literal, str, '$!text');
    add-method(RakuAST::Regex::Literal, 'new', [RakuAST::Regex::Literal, '', 0, 0, str, '$text', 0, 0], anon sub new ($SELF_CONT, $text!) {
        my $SELF := nqp::decont($SELF_CONT);
        $text := nqp::decont($text);
#line 247 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Regex::Literal, '$!text', $text);
        $obj
    
    });
    add-method(RakuAST::Regex::Literal, 'IMPL-REGEX-QAST', [RakuAST::Regex::Literal, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 253 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-APPLY-LITERAL-MODS:
            QAST::Regex.new( :rxtype<literal>, nqp::getattr_s($SELF, RakuAST::Regex::Literal, '$!text') ),
            %mods
    
    });
#line 245 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Literal, 'text', [], anon sub text ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::Literal, '$!text') });
    compose(RakuAST::Regex::Literal);
    parent(RakuAST::Regex::Quote, RakuAST::Regex::Atom);
    add-attribute(RakuAST::Regex::Quote, RakuAST::QuotedString, '$!quoted');
    add-method(RakuAST::Regex::Quote, 'new', [RakuAST::Regex::Quote, '', 0, 0, RakuAST::QuotedString, '$quoted', 0, 0], anon sub new ($SELF_CONT, $quoted!) {
        my $SELF := nqp::decont($SELF_CONT);
        $quoted := nqp::decont($quoted);
#line 268 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Quote, '$!quoted', $quoted);
        $obj
    
    });
    add-method(RakuAST::Regex::Quote, 'IMPL-REGEX-QAST', [RakuAST::Regex::Quote, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 274 src/Raku/ast/regex.rakumod
        
        my $literal-value := nqp::getattr($SELF, RakuAST::Regex::Quote, '$!quoted').literal-value;
        if nqp::isconcrete($literal-value) {
            if nqp::istype($literal-value, Str) {
                # Really simple string; just match it.
                $SELF.IMPL-APPLY-LITERAL-MODS:
                    QAST::Regex.new( :rxtype<literal>, $literal-value ),
                    %mods
            }
            elsif nqp::istype($literal-value, List) {
                # Quote words alternation.
                my $alt := QAST::Regex.new( :rxtype<alt> );
                for $SELF.IMPL-UNWRAP-LIST($literal-value) {
                    $alt.push: $SELF.IMPL-APPLY-LITERAL-MODS:
                        QAST::Regex.new( :rxtype<literal>, $_ ),
                        %mods
                }
                $alt
            }
            else {
                nqp::die('Unexpected quoted string literal value type in regex quote; got ' ~
                    $literal-value.HOW.name($literal-value));
            }
        }
        else {
            if $SELF.IMPL-UNWRAP-LIST(nqp::getattr($SELF, RakuAST::Regex::Quote, '$!quoted').processors) {
                # Somehow, overly complex quote words construct. Weird.
                nqp::die('Unsupported quoted string literal in regex quote');
            }
            else {
                # Complex string that needs interpolation.
                QAST::Regex.new(
                    :rxtype<subrule>, :subtype<method>,
                    QAST::NodeList.new(
                        QAST::SVal.new( :value('!LITERAL') ),
                        nqp::getattr($SELF, RakuAST::Regex::Quote, '$!quoted').IMPL-TO-QAST($context),
                        QAST::IVal.new( :value(%mods<i> ?? 1 !! 0) )
                    )
                )
            }
        }
    
    });
    add-method(RakuAST::Regex::Quote, 'visit-children', [RakuAST::Regex::Quote, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 317 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Quote, '$!quoted'));
    
    });
#line 266 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Quote, 'quoted', [], anon sub quoted ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Quote, '$!quoted') });
    compose(RakuAST::Regex::Quote);
    parent(RakuAST::Regex::Group, RakuAST::Regex::Atom);
    add-attribute(RakuAST::Regex::Group, RakuAST::Regex, '$!regex');
    add-method(RakuAST::Regex::Group, 'new', [RakuAST::Regex::Group, '', 0, 0, RakuAST::Regex, '$regex', 0, 0], anon sub new ($SELF_CONT, $regex!) {
        my $SELF := nqp::decont($SELF_CONT);
        $regex := nqp::decont($regex);
#line 328 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Group, '$!regex', $regex);
        $obj
    
    });
    add-method(RakuAST::Regex::Group, 'IMPL-REGEX-QAST', [RakuAST::Regex::Group, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 334 src/Raku/ast/regex.rakumod
        
        nqp::getattr($SELF, RakuAST::Regex::Group, '$!regex').IMPL-REGEX-QAST($context, nqp::clone(%mods))
    
    });
    add-method(RakuAST::Regex::Group, 'visit-children', [RakuAST::Regex::Group, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 338 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Group, '$!regex'));
    
    });
#line 326 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Group, 'regex', [], anon sub regex ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Group, '$!regex') });
    compose(RakuAST::Regex::Group);
    parent(RakuAST::Regex::CapturingGroup, RakuAST::Regex::Atom);
    parent(RakuAST::Regex::CapturingGroup, RakuAST::RegexThunk);
    add-attribute(RakuAST::Regex::CapturingGroup, RakuAST::Regex, '$!regex');
    add-attribute(RakuAST::Regex::CapturingGroup, str, '$!unique-name');
    add-attribute(RakuAST::Regex::CapturingGroup, Mu, '$!body-qast');
    add-method(RakuAST::Regex::CapturingGroup, 'new', [RakuAST::Regex::CapturingGroup, '', 0, 0, RakuAST::Regex, '$regex', 0, 0], anon sub new ($SELF_CONT, $regex!) {
        my $SELF := nqp::decont($SELF_CONT);
        $regex := nqp::decont($regex);
#line 354 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::CapturingGroup, '$!regex', $regex);
        $obj
    
    });
    add-method(RakuAST::Regex::CapturingGroup, 'IMPL-UNIQUE-NAME', [RakuAST::Regex::CapturingGroup, '', 0, 0], anon sub IMPL-UNIQUE-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 360 src/Raku/ast/regex.rakumod
        
        my str $unique-name := nqp::getattr_s($SELF, RakuAST::Regex::CapturingGroup, '$!unique-name');
        unless $unique-name {
            nqp::bindattr_s($SELF, RakuAST::Regex::CapturingGroup, '$!unique-name',
                ($unique-name := QAST::Node.unique('!__REGEX_CAPTURE_')));
        }
        $unique-name
    
    });
    add-method(RakuAST::Regex::CapturingGroup, 'IMPL-THUNKED-REGEX-QAST', [RakuAST::Regex::CapturingGroup, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-THUNKED-REGEX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 369 src/Raku/ast/regex.rakumod
        
        nqp::getattr($SELF, RakuAST::Regex::CapturingGroup, '$!regex').IMPL-REGEX-TOP-LEVEL-QAST($context, $SELF.meta-object, nqp::hash(),
            :body-qast(nqp::getattr($SELF, RakuAST::Regex::CapturingGroup, '$!body-qast') // nqp::die('Misordered regex compilation')),
            :no-scan);
    
    });
    add-method(RakuAST::Regex::CapturingGroup, 'IMPL-QAST-DECL-CODE', [RakuAST::Regex::CapturingGroup, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL-CODE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 375 src/Raku/ast/regex.rakumod
        
        # Form the block itself and link it with the meta-object. Install it
        # in the lexpad; we'll look it up when we need it. This means we can
        # avoid closure-cloning it per time we enter it, for example if it is
        # quantified.
        my str $name := $SELF.IMPL-UNIQUE-NAME;
        my $block := $SELF.IMPL-QAST-FORM-BLOCK($context, :blocktype('declaration_static'));
        $SELF.IMPL-LINK-META-OBJECT($context, $block);
        QAST::Stmts.new(
            $block,
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :decl<var>, :scope<lexical>, :$name ),
                $SELF.IMPL-CLOSURE-QAST($context)
            )
        )
    
    });
    add-method(RakuAST::Regex::CapturingGroup, 'IMPL-REGEX-QAST', [RakuAST::Regex::CapturingGroup, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 393 src/Raku/ast/regex.rakumod
        
        my str $name := $SELF.IMPL-UNIQUE-NAME;
        my $body-qast := nqp::getattr($SELF, RakuAST::Regex::CapturingGroup, '$!regex').IMPL-REGEX-QAST($context, nqp::clone(%mods));
        nqp::bindattr($SELF, RakuAST::Regex::CapturingGroup, '$!body-qast', $body-qast);
        QAST::Regex.new(
            :rxtype('subrule'), :subtype('capture'),
            QAST::NodeList.new(QAST::Var.new( :$name, :scope('lexical') )),
            $body-qast
        )
    
    });
    add-method(RakuAST::Regex::CapturingGroup, 'visit-children', [RakuAST::Regex::CapturingGroup, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 404 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::CapturingGroup, '$!regex'));
    
    });
#line 348 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CapturingGroup, 'regex', [], anon sub regex ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::CapturingGroup, '$!regex') });
    compose(RakuAST::Regex::CapturingGroup);
    parent(RakuAST::Regex::NamedCapture, RakuAST::Regex::Atom);
    add-attribute(RakuAST::Regex::NamedCapture, str, '$!name');
    add-attribute(RakuAST::Regex::NamedCapture, Bool, '$!array');
    add-attribute(RakuAST::Regex::NamedCapture, RakuAST::Term, '$!regex');
    add-method(RakuAST::Regex::NamedCapture, 'new', [RakuAST::Regex::NamedCapture, '', 0, 0, str, '$name', 1, 0, Bool, '$array', 1, 1, RakuAST::Term, '$regex', 1, 0], anon sub new ($SELF_CONT, :$name!, :$array?, :$regex!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $array := nqp::decont($array);
        $regex := nqp::decont($regex);
#line 417 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Regex::NamedCapture, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Regex::NamedCapture, '$!array',
            $array ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Regex::NamedCapture, '$!regex', $regex);
        $obj
    
    });
    add-method(RakuAST::Regex::NamedCapture, 'IMPL-REGEX-QAST', [RakuAST::Regex::NamedCapture, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 426 src/Raku/ast/regex.rakumod
        
        my $qast := nqp::getattr($SELF, RakuAST::Regex::NamedCapture, '$!regex').IMPL-REGEX-QAST($context, %mods);
        if ($qast.rxtype eq 'quant' || $qast.rxtype eq 'dynquant') &&
                $qast[0].rxtype eq 'subrule' {
            $SELF.IMPL-SUBRULE-ALIAS($qast[0], nqp::getattr_s($SELF, RakuAST::Regex::NamedCapture, '$!name'));
        }
        elsif $qast.rxtype eq 'subrule' {
            $SELF.IMPL-SUBRULE-ALIAS($qast, nqp::getattr_s($SELF, RakuAST::Regex::NamedCapture, '$!name'));
            $qast := QAST::Regex.new( :rxtype<quant>, :min(1), :max(1), $qast) if nqp::getattr($SELF, RakuAST::Regex::NamedCapture, '$!array');
        }
        else {
            $qast := QAST::Regex.new( :rxtype<subcapture>, :name(nqp::getattr_s($SELF, RakuAST::Regex::NamedCapture, '$!name')), $qast );
        }
        $qast
    
    });
    add-method(RakuAST::Regex::NamedCapture, 'visit-children', [RakuAST::Regex::NamedCapture, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 442 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::NamedCapture, '$!regex'));
    
    });
#line 415 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::NamedCapture, 'regex', [], anon sub regex ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::NamedCapture, '$!regex') });
#line 413 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::NamedCapture, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::NamedCapture, '$!name') });
#line 414 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::NamedCapture, 'array', [], anon sub array ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::NamedCapture, '$!array') });
    compose(RakuAST::Regex::NamedCapture);
    parent(RakuAST::Regex::Anchor, RakuAST::Regex::Atom);
    add-method(RakuAST::Regex::Anchor, 'new', [RakuAST::Regex::Anchor, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 451 src/Raku/ast/regex.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Regex::Anchor, 'quantifiable', [RakuAST::Regex::Anchor, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 455 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::Anchor, 'IMPL-REGEX-QAST', [RakuAST::Regex::Anchor, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 457 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<anchor>, :subtype($SELF.IMPL-QAST-SUBTYPE) )
    
    });
    compose(RakuAST::Regex::Anchor);
    parent(RakuAST::Regex::Anchor::BeginningOfString, RakuAST::Regex::Anchor);
    add-method(RakuAST::Regex::Anchor::BeginningOfString, 'IMPL-QAST-SUBTYPE', [RakuAST::Regex::Anchor::BeginningOfString, '', 0, 0], anon sub IMPL-QAST-SUBTYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 466 src/Raku/ast/regex.rakumod
         'bos' 
    });
    compose(RakuAST::Regex::Anchor::BeginningOfString);
    parent(RakuAST::Regex::Anchor::BeginningOfLine, RakuAST::Regex::Anchor);
    add-method(RakuAST::Regex::Anchor::BeginningOfLine, 'IMPL-QAST-SUBTYPE', [RakuAST::Regex::Anchor::BeginningOfLine, '', 0, 0], anon sub IMPL-QAST-SUBTYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 473 src/Raku/ast/regex.rakumod
         'bol' 
    });
    compose(RakuAST::Regex::Anchor::BeginningOfLine);
    parent(RakuAST::Regex::Anchor::EndOfString, RakuAST::Regex::Anchor);
    add-method(RakuAST::Regex::Anchor::EndOfString, 'IMPL-QAST-SUBTYPE', [RakuAST::Regex::Anchor::EndOfString, '', 0, 0], anon sub IMPL-QAST-SUBTYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 480 src/Raku/ast/regex.rakumod
         'eos' 
    });
    compose(RakuAST::Regex::Anchor::EndOfString);
    parent(RakuAST::Regex::Anchor::EndOfLine, RakuAST::Regex::Anchor);
    add-method(RakuAST::Regex::Anchor::EndOfLine, 'IMPL-QAST-SUBTYPE', [RakuAST::Regex::Anchor::EndOfLine, '', 0, 0], anon sub IMPL-QAST-SUBTYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 487 src/Raku/ast/regex.rakumod
         'eol' 
    });
    compose(RakuAST::Regex::Anchor::EndOfLine);
    parent(RakuAST::Regex::Anchor::LeftWordBoundary, RakuAST::Regex::Anchor);
    add-method(RakuAST::Regex::Anchor::LeftWordBoundary, 'IMPL-QAST-SUBTYPE', [RakuAST::Regex::Anchor::LeftWordBoundary, '', 0, 0], anon sub IMPL-QAST-SUBTYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 494 src/Raku/ast/regex.rakumod
         'lwb' 
    });
    compose(RakuAST::Regex::Anchor::LeftWordBoundary);
    parent(RakuAST::Regex::Anchor::RightWordBoundary, RakuAST::Regex::Anchor);
    add-method(RakuAST::Regex::Anchor::RightWordBoundary, 'IMPL-QAST-SUBTYPE', [RakuAST::Regex::Anchor::RightWordBoundary, '', 0, 0], anon sub IMPL-QAST-SUBTYPE ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 501 src/Raku/ast/regex.rakumod
         'rwb' 
    });
    compose(RakuAST::Regex::Anchor::RightWordBoundary);
    parent(RakuAST::Regex::MatchFrom, RakuAST::Regex::Atom);
    add-method(RakuAST::Regex::MatchFrom, 'new', [RakuAST::Regex::MatchFrom, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 508 src/Raku/ast/regex.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Regex::MatchFrom, 'quantifiable', [RakuAST::Regex::MatchFrom, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 512 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::MatchFrom, 'IMPL-REGEX-QAST', [RakuAST::Regex::MatchFrom, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 514 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<subrule>, :subtype<capture>,
            :backtrack<r>, :name('$!from'),
            QAST::NodeList.new(
                QAST::SVal.new( :value('!LITERAL') ),
                QAST::SVal.new( :value('') ) ) );
    
    });
    compose(RakuAST::Regex::MatchFrom);
    parent(RakuAST::Regex::MatchTo, RakuAST::Regex::Atom);
    add-method(RakuAST::Regex::MatchTo, 'new', [RakuAST::Regex::MatchTo, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 527 src/Raku/ast/regex.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Regex::MatchTo, 'quantifiable', [RakuAST::Regex::MatchTo, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 531 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::MatchTo, 'IMPL-REGEX-QAST', [RakuAST::Regex::MatchTo, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 533 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<subrule>, :subtype<capture>,
            :backtrack<r>, :name('$!to'),
            QAST::NodeList.new(
                QAST::SVal.new( :value('!LITERAL') ),
                QAST::SVal.new( :value('') ) ) );
    
    });
    compose(RakuAST::Regex::MatchTo);
    parent(RakuAST::Regex::CharClass, RakuAST::Regex::Atom);
    add-method(RakuAST::Regex::CharClass, 'new', [RakuAST::Regex::CharClass, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 549 src/Raku/ast/regex.rakumod
        
        nqp::create($SELF)
    
    });
    compose(RakuAST::Regex::CharClass);
    parent(RakuAST::Regex::CharClass::Any, RakuAST::Regex::CharClass);
    add-method(RakuAST::Regex::CharClass::Any, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Any, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 558 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<cclass>, :name<.> )
    
    });
    compose(RakuAST::Regex::CharClass::Any);
    parent(RakuAST::Regex::CharClass::Negatable, RakuAST::Regex::CharClass);
    add-attribute(RakuAST::Regex::CharClass::Negatable, Bool, '$!negated');
    add-method(RakuAST::Regex::CharClass::Negatable, 'new', [RakuAST::Regex::CharClass::Negatable, '', 0, 0, Bool, '$negated', 1, 1], anon sub new ($SELF_CONT, :$negated?) {
        my $SELF := nqp::decont($SELF_CONT);
        $negated := nqp::decont($negated);
#line 569 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::CharClass::Negatable, '$!negated',
            $negated ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
#line 567 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClass::Negatable, 'negated', [], anon sub negated ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::CharClass::Negatable, '$!negated') });
    compose(RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClassEnumerationElement, RakuAST::Node);
    add-method(RakuAST::Regex::CharClassEnumerationElement, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClassEnumerationElement, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 582 src/Raku/ast/regex.rakumod
         '' 
    });
    add-method(RakuAST::Regex::CharClassEnumerationElement, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClassEnumerationElement, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 584 src/Raku/ast/regex.rakumod
        
        nqp::die("Missing IMPL-CCLASS-ENUM-QAST implementation on " ~ $SELF.HOW.name($SELF));
    
    });
    add-method(RakuAST::Regex::CharClassEnumerationElement, 'IMPL-MAYBE-NEGATE', [RakuAST::Regex::CharClassEnumerationElement, '', 0, 0, Mu, '$qast', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-MAYBE-NEGATE ($SELF_CONT, $qast!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $qast := nqp::decont($qast);
        $negate := nqp::decont($negate);
#line 588 src/Raku/ast/regex.rakumod
        
        $qast.negate(!$qast.negate) if $negate;
        $qast
    
    });
    add-method(RakuAST::Regex::CharClassEnumerationElement, 'range-endpoint', [RakuAST::Regex::CharClassEnumerationElement, '', 0, 0], anon sub range-endpoint ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 596 src/Raku/ast/regex.rakumod
        
        my str $chars := $SELF.IMPL-CCLASS-ENUM-CHARS({});
        nqp::chars($chars) == 1 ?? $chars !! Nil
    
    });
    compose(RakuAST::Regex::CharClassEnumerationElement);
    parent(RakuAST::Regex::CharClass::BackSpace, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::BackSpace, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::BackSpace, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::BackSpace, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 608 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype('enumcharlist'), :negate($SELF.negated), "\b"
    
    });
    add-method(RakuAST::Regex::CharClass::BackSpace, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClass::BackSpace, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 613 src/Raku/ast/regex.rakumod
         $SELF.negated ?? "" !! "\b" 
    });
    add-method(RakuAST::Regex::CharClass::BackSpace, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::BackSpace, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 615 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::BackSpace);
    parent(RakuAST::Regex::CharClass::Digit, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::Digit, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::Digit, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Digit, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 625 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<cclass>, :name<d>, :negate($SELF.negated) )
    
    });
    add-method(RakuAST::Regex::CharClass::Digit, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::Digit, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 629 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::Digit);
    parent(RakuAST::Regex::CharClass::Escape, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::Escape, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::Escape, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Escape, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 639 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype('enumcharlist'), :negate($SELF.negated), "\c[27]"
    
    });
    add-method(RakuAST::Regex::CharClass::Escape, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClass::Escape, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 644 src/Raku/ast/regex.rakumod
         $SELF.negated ?? "" !! "\c[27]" 
    });
    add-method(RakuAST::Regex::CharClass::Escape, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::Escape, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 646 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::Escape);
    parent(RakuAST::Regex::CharClass::FormFeed, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::FormFeed, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::FormFeed, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::FormFeed, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 656 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype('enumcharlist'), :negate($SELF.negated), "\c[12]"
    
    });
    add-method(RakuAST::Regex::CharClass::FormFeed, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClass::FormFeed, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 661 src/Raku/ast/regex.rakumod
         $SELF.negated ?? "" !! "\c[12]" 
    });
    add-method(RakuAST::Regex::CharClass::FormFeed, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::FormFeed, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 663 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::FormFeed);
    parent(RakuAST::Regex::CharClass::HorizontalSpace, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::HorizontalSpace, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::HorizontalSpace, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::HorizontalSpace, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 673 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype('enumcharlist'), :negate($SELF.negated),
            "\x[09,20,a0,1680,180e,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,200a,202f,205f,3000]"
    
    });
    add-method(RakuAST::Regex::CharClass::HorizontalSpace, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::HorizontalSpace, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 679 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::HorizontalSpace);
    parent(RakuAST::Regex::CharClass::Newline, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::Newline, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::Newline, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Newline, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 689 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<cclass>, :name<n>, :negate($SELF.negated) )
    
    });
    add-method(RakuAST::Regex::CharClass::Newline, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::Newline, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 693 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::Newline);
    parent(RakuAST::Regex::CharClass::CarriageReturn, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::CarriageReturn, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::CarriageReturn, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::CarriageReturn, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 703 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype('enumcharlist'), :negate($SELF.negated), "\r"
    
    });
    add-method(RakuAST::Regex::CharClass::CarriageReturn, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClass::CarriageReturn, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 708 src/Raku/ast/regex.rakumod
         $SELF.negated ?? "" !! "\r" 
    });
    add-method(RakuAST::Regex::CharClass::CarriageReturn, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::CarriageReturn, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 710 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::CarriageReturn);
    parent(RakuAST::Regex::CharClass::Space, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::Space, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::Space, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Space, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 720 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<cclass>, :name<s>, :negate($SELF.negated) )
    
    });
    add-method(RakuAST::Regex::CharClass::Space, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::Space, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 724 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::Space);
    parent(RakuAST::Regex::CharClass::Tab, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::Tab, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::Tab, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Tab, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 734 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype('enumcharlist'), :negate($SELF.negated), "\t"
    
    });
    add-method(RakuAST::Regex::CharClass::Tab, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClass::Tab, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 739 src/Raku/ast/regex.rakumod
         $SELF.negated ?? "" !! "\t" 
    });
    add-method(RakuAST::Regex::CharClass::Tab, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::Tab, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 741 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::Tab);
    parent(RakuAST::Regex::CharClass::VerticalSpace, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::VerticalSpace, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::VerticalSpace, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::VerticalSpace, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 751 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype('enumcharlist'), :negate($SELF.negated),
            "\x[0a,0b,0c,0d,85,2028,2029]\r\n"
    
    });
    add-method(RakuAST::Regex::CharClass::VerticalSpace, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::VerticalSpace, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 757 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::VerticalSpace);
    parent(RakuAST::Regex::CharClass::Word, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::Word, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::Word, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Word, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 767 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<cclass>, :name<w>, :negate($SELF.negated) )
    
    });
    add-method(RakuAST::Regex::CharClass::Word, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::Word, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 771 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-MAYBE-NEGATE($SELF.IMPL-REGEX-QAST($context, %mods), $negate)
    
    });
    compose(RakuAST::Regex::CharClass::Word);
    parent(RakuAST::Regex::CharClass::Specified, RakuAST::Regex::CharClass::Negatable);
    parent(RakuAST::Regex::CharClass::Specified, RakuAST::Regex::CharClassEnumerationElement);
    parent(RakuAST::Regex::CharClass::Specified, RakuAST::CheckTime);
    add-attribute(RakuAST::Regex::CharClass::Specified, str, '$!characters');
    add-method(RakuAST::Regex::CharClass::Specified, 'new', [RakuAST::Regex::CharClass::Specified, '', 0, 0, Bool, '$negated', 1, 1, str, '$characters', 1, 0], anon sub new ($SELF_CONT, :$negated?, :$characters!) {
        my $SELF := nqp::decont($SELF_CONT);
        $negated := nqp::decont($negated);
        $characters := nqp::decont($characters);
#line 787 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::CharClass::Negatable, '$!negated',
            $negated ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr_s($obj, RakuAST::Regex::CharClass::Specified, '$!characters',
            $characters);
        $obj
    
    });
    add-method(RakuAST::Regex::CharClass::Specified, 'PERFORM-CHECK', [RakuAST::Regex::CharClass::Specified, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 796 src/Raku/ast/regex.rakumod
        
        if nqp::chars(nqp::getattr_s($SELF, RakuAST::Regex::CharClass::Specified, '$!characters')) > 1 {
            $SELF.add-sorry:
              $resolver.build-exception: 'X::NotSingleGrapheme',
                characters => nqp::getattr_s($SELF, RakuAST::Regex::CharClass::Specified, '$!characters');
        }
    
    });
    add-method(RakuAST::Regex::CharClass::Specified, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Specified, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 804 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-QAST($context, %mods, $SELF.negated)
    
    });
    add-method(RakuAST::Regex::CharClass::Specified, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClass::Specified, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 808 src/Raku/ast/regex.rakumod
        
        $SELF.negated || nqp::chars(nqp::getattr_s($SELF, RakuAST::Regex::CharClass::Specified, '$!characters')) != 1 ?? "" !! nqp::getattr_s($SELF, RakuAST::Regex::CharClass::Specified, '$!characters')
    
    });
    add-method(RakuAST::Regex::CharClass::Specified, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClass::Specified, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 812 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-QAST($context, %mods, $SELF.negated ?? !$negate !! $negate)
    
    });
    add-method(RakuAST::Regex::CharClass::Specified, 'IMPL-QAST', [RakuAST::Regex::CharClass::Specified, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negated', 0, 0], anon sub IMPL-QAST ($SELF_CONT, $context!, %mods!, $negated!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negated := nqp::decont($negated);
#line 816 src/Raku/ast/regex.rakumod
        
        if $negated {
            # Negated, it is treated like a "long character". Quoting S05:
            # > A consequence of this is that the negated form advances by a single
            # > position (matching as . does) when the long character doesn't match
            # > as a whole
            # Rakudo got this wrong pre-RakuAST; hopefully it's rare enough of a
            # construct that we can get away with doing it right here.
            QAST::Regex.new(
                :rxtype<concat>,
                QAST::Regex.new( :rxtype<literal>, :subtype<zerowidth>, :negate, nqp::getattr_s($SELF, RakuAST::Regex::CharClass::Specified, '$!characters') ),
                QAST::Regex.new( :rxtype<cclass>, :name<.> )
            )
        }
        else {
            # Non-negated, match the character(s)
            QAST::Regex.new( :rxtype<literal>, nqp::getattr_s($SELF, RakuAST::Regex::CharClass::Specified, '$!characters') )
        }
    
    });
#line 785 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClass::Specified, 'characters', [], anon sub characters ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::CharClass::Specified, '$!characters') });
    compose(RakuAST::Regex::CharClass::Specified);
    parent(RakuAST::Regex::CharClass::Nul, RakuAST::Regex::CharClass);
    parent(RakuAST::Regex::CharClass::Nul, RakuAST::Regex::CharClassEnumerationElement);
    add-method(RakuAST::Regex::CharClass::Nul, 'IMPL-REGEX-QAST', [RakuAST::Regex::CharClass::Nul, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 842 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new: :rxtype<literal>, "\0"
    
    });
    add-method(RakuAST::Regex::CharClass::Nul, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClass::Nul, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 846 src/Raku/ast/regex.rakumod
         "\0" 
    });
    compose(RakuAST::Regex::CharClass::Nul);
    parent(RakuAST::Regex::BackReference, RakuAST::Regex::Atom);
    add-method(RakuAST::Regex::BackReference, 'IMPL-REGEX-QAST', [RakuAST::Regex::BackReference, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 853 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new: :rxtype<subrule>, :subtype<method>, QAST::NodeList.new:
            QAST::SVal.new( :value('!BACKREF') ),
            QAST::SVal.new( :value($SELF.IMPL-CAPTURE-NAME) )
    
    });
    add-method(RakuAST::Regex::BackReference, 'IMPL-CAPTURE-NAME', [RakuAST::Regex::BackReference, '', 0, 0], anon sub IMPL-CAPTURE-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 859 src/Raku/ast/regex.rakumod
        
        nqp::die('IMPL-CAPTURE-NAME not implemented in ' ~ $SELF.HOW.name($SELF))
    
    });
    compose(RakuAST::Regex::BackReference);
    parent(RakuAST::Regex::BackReference::Positional, RakuAST::Regex::BackReference);
    add-attribute(RakuAST::Regex::BackReference::Positional, int, '$!index');
    add-method(RakuAST::Regex::BackReference::Positional, 'new', [RakuAST::Regex::BackReference::Positional, '', 0, 0, int, '$index', 0, 0], anon sub new ($SELF_CONT, $index!) {
        my $SELF := nqp::decont($SELF_CONT);
        $index := nqp::decont($index);
#line 870 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_i($obj, RakuAST::Regex::BackReference::Positional, '$!index', $index);
        $obj
    
    });
    add-method(RakuAST::Regex::BackReference::Positional, 'IMPL-CAPTURE-NAME', [RakuAST::Regex::BackReference::Positional, '', 0, 0], anon sub IMPL-CAPTURE-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 876 src/Raku/ast/regex.rakumod
         ~nqp::getattr_i($SELF, RakuAST::Regex::BackReference::Positional, '$!index') 
    });
#line 868 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::BackReference::Positional, 'index', [], anon sub index ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Regex::BackReference::Positional, '$!index') });
    compose(RakuAST::Regex::BackReference::Positional);
    parent(RakuAST::Regex::BackReference::Named, RakuAST::Regex::BackReference);
    add-attribute(RakuAST::Regex::BackReference::Named, str, '$!name');
    add-method(RakuAST::Regex::BackReference::Named, 'new', [RakuAST::Regex::BackReference::Named, '', 0, 0, str, '$name', 0, 0], anon sub new ($SELF_CONT, $name!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
#line 885 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Regex::BackReference::Named, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Regex::BackReference::Named, 'IMPL-CAPTURE-NAME', [RakuAST::Regex::BackReference::Named, '', 0, 0], anon sub IMPL-CAPTURE-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 891 src/Raku/ast/regex.rakumod
         nqp::getattr_s($SELF, RakuAST::Regex::BackReference::Named, '$!name') 
    });
#line 883 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::BackReference::Named, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::BackReference::Named, '$!name') });
    compose(RakuAST::Regex::BackReference::Named);
    parent(RakuAST::Regex::Statement, RakuAST::Regex::Atom);
    add-attribute(RakuAST::Regex::Statement, RakuAST::Statement, '$!statement');
    add-method(RakuAST::Regex::Statement, 'new', [RakuAST::Regex::Statement, '', 0, 0, RakuAST::Statement, '$statement', 0, 0], anon sub new ($SELF_CONT, $statement!) {
        my $SELF := nqp::decont($SELF_CONT);
        $statement := nqp::decont($statement);
#line 901 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Statement, '$!statement', $statement);
        $obj
    
    });
    add-method(RakuAST::Regex::Statement, 'IMPL-REGEX-QAST', [RakuAST::Regex::Statement, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 907 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new: :rxtype<qastnode>, :subtype<declarative>,
            nqp::getattr($SELF, RakuAST::Regex::Statement, '$!statement').IMPL-TO-QAST($context)
    
    });
    add-method(RakuAST::Regex::Statement, 'visit-children', [RakuAST::Regex::Statement, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 912 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Statement, '$!statement'));
    
    });
#line 899 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Statement, 'statement', [], anon sub statement ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Statement, '$!statement') });
    compose(RakuAST::Regex::Statement);
    parent(RakuAST::Regex::Block, RakuAST::Regex::Atom);
    add-attribute(RakuAST::Regex::Block, RakuAST::Block, '$!block');
    add-method(RakuAST::Regex::Block, 'new', [RakuAST::Regex::Block, '', 0, 0, RakuAST::Block, '$block', 0, 0], anon sub new ($SELF_CONT, $block!) {
        my $SELF := nqp::decont($SELF_CONT);
        $block := nqp::decont($block);
#line 923 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Block, '$!block', $block);
        $obj
    
    });
    add-method(RakuAST::Regex::Block, 'quantifiable', [RakuAST::Regex::Block, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 929 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::Block, 'IMPL-REGEX-QAST', [RakuAST::Regex::Block, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 931 src/Raku/ast/regex.rakumod
        
        my $block-call := $SELF.IMPL-REGEX-BLOCK-CALL($context, nqp::getattr($SELF, RakuAST::Regex::Block, '$!block'));
        QAST::Regex.new( $block-call, :rxtype<qastnode> )
    
    });
    add-method(RakuAST::Regex::Block, 'visit-children', [RakuAST::Regex::Block, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 936 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Block, '$!block'));
    
    });
#line 921 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Block, 'block', [], anon sub block ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Block, '$!block') });
    compose(RakuAST::Regex::Block);
    parent(RakuAST::Regex::Interpolation, RakuAST::Regex::Atom);
    parent(RakuAST::Regex::Interpolation, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Regex::Interpolation, RakuAST::Expression, '$!var');
    add-attribute(RakuAST::Regex::Interpolation, Bool, '$!sequential');
    add-method(RakuAST::Regex::Interpolation, 'new', [RakuAST::Regex::Interpolation, '', 0, 0, RakuAST::Expression, '$var', 1, 1, Bool, '$sequential', 1, 1], anon sub new ($SELF_CONT, :$var?, :$sequential?) {
        my $SELF := nqp::decont($SELF_CONT);
        $var := nqp::decont($var);
        $sequential := nqp::decont($sequential);
#line 951 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Interpolation, '$!var', $var);
        nqp::bindattr($obj, RakuAST::Regex::Interpolation, '$!sequential',
            $sequential ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Regex::Interpolation, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Regex::Interpolation, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 959 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('PseudoStash')),
        ])
    
    });
    add-method(RakuAST::Regex::Interpolation, 'IMPL-REGEX-QAST', [RakuAST::Regex::Interpolation, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 965 src/Raku/ast/regex.rakumod
        
        # Look for fast paths.
        if nqp::istype(nqp::getattr($SELF, RakuAST::Regex::Interpolation, '$!var'), RakuAST::Lookup) && nqp::getattr($SELF, RakuAST::Regex::Interpolation, '$!var').is-resolved {
            my $resolution := nqp::getattr($SELF, RakuAST::Regex::Interpolation, '$!var').resolution;
            # TODO contant case
            if !%mods<m> && nqp::istype($resolution, RakuAST::VarDeclaration::Simple) &&
                    $resolution.sigil eq '$' {
                my $type := $resolution.type;
                if $type && $type.is-known-to-be(Str) {
                    # Certainly a string.
                    return QAST::Regex.new:
                        :rxtype<subrule>, :subtype<method>,
                        QAST::NodeList.new:
                            QAST::SVal.new( :value('!LITERAL') ),
                            nqp::getattr($SELF, RakuAST::Regex::Interpolation, '$!var').IMPL-TO-QAST($context),
                            QAST::IVal.new( :value(%mods<i> ?? 1 !! 0) )
                }
            }
        }

        # Fallback to slow path.
        QAST::Regex.new:
            :rxtype<subrule>, :subtype<method>,
            QAST::NodeList.new:
                QAST::SVal.new( :value('INTERPOLATE') ),
                nqp::getattr($SELF, RakuAST::Regex::Interpolation, '$!var').IMPL-TO-QAST($context),
                QAST::IVal.new( :value((%mods<i> ?? 1 !! 0) + (%mods<m> ?? 2 !! 0)) ),
                QAST::IVal.new( :value(0) ),
                QAST::IVal.new( :value(nqp::getattr($SELF, RakuAST::Regex::Interpolation, '$!sequential') ?? 1 !! 0) ),
                QAST::IVal.new( :value(0) ),
                QAST::Op.new(
                    :op<callmethod>, :name<new>,
                   $SELF.get-implicit-lookups.AT-POS(0).IMPL-TO-QAST($context)
                )
    
    });
    add-method(RakuAST::Regex::Interpolation, 'visit-children', [RakuAST::Regex::Interpolation, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1001 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Interpolation, '$!var'));
    
    });
#line 948 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Interpolation, 'var', [], anon sub var ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Interpolation, '$!var') });
#line 949 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Interpolation, 'sequential', [], anon sub sequential ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Interpolation, '$!sequential') });
    compose(RakuAST::Regex::Interpolation);
    parent(RakuAST::Regex::Assertion, RakuAST::Regex::Atom);
    add-method(RakuAST::Regex::Assertion, 'IMPL-INTERPOLATE-ASSERTION', [RakuAST::Regex::Assertion, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Mu, '$expression-qast', 0, 0, Bool, '$sequential', 0, 0, Mu, '$PseudoStash', 0, 0], anon sub IMPL-INTERPOLATE-ASSERTION ($SELF_CONT, $context!, %mods!, $expression-qast!, $sequential!, $PseudoStash!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $expression-qast := nqp::decont($expression-qast);
        $sequential := nqp::decont($sequential);
        $PseudoStash := nqp::decont($PseudoStash);
#line 1012 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype<subrule>, :subtype<method>,
            QAST::NodeList.new:
                QAST::SVal.new( :value('INTERPOLATE_ASSERTION') ),
                $expression-qast,
                QAST::IVal.new( :value((%mods<i> ?? 1 !! 0) + (%mods<m> ?? 2 !! 0)) ),
                QAST::IVal.new( :value(0) ), # XXX 1 if MONKEY-SEE-NO-EVAL
                QAST::IVal.new( :value($sequential ?? 1 !! 0) ),
                QAST::IVal.new( :value(1) ),
                QAST::Op.new(
                    :op<callmethod>, :name<new>,
                    $PseudoStash.IMPL-TO-QAST($context)
                )
    
    });
    compose(RakuAST::Regex::Assertion);
    parent(RakuAST::Regex::Assertion::Pass, RakuAST::Regex::Assertion);
    add-method(RakuAST::Regex::Assertion::Pass, 'new', [RakuAST::Regex::Assertion::Pass, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1033 src/Raku/ast/regex.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Regex::Assertion::Pass, 'quantifiable', [RakuAST::Regex::Assertion::Pass, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1037 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::Assertion::Pass, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Pass, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1039 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<anchor>, :subtype<pass> )
    
    });
    compose(RakuAST::Regex::Assertion::Pass);
    parent(RakuAST::Regex::Assertion::Fail, RakuAST::Regex::Assertion);
    add-method(RakuAST::Regex::Assertion::Fail, 'new', [RakuAST::Regex::Assertion::Fail, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1048 src/Raku/ast/regex.rakumod
        
        nqp::create($SELF)
    
    });
    add-method(RakuAST::Regex::Assertion::Fail, 'quantifiable', [RakuAST::Regex::Assertion::Fail, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1052 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::Assertion::Fail, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Fail, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1054 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new( :rxtype<anchor>, :subtype<fail> )
    
    });
    compose(RakuAST::Regex::Assertion::Fail);
    parent(RakuAST::Regex::Assertion::Named, RakuAST::Regex::Assertion);
    parent(RakuAST::Regex::Assertion::Named, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Regex::Assertion::Named, RakuAST::Name, '$!name');
    add-attribute(RakuAST::Regex::Assertion::Named, Bool, '$!capturing');
    add-method(RakuAST::Regex::Assertion::Named, 'new', [RakuAST::Regex::Assertion::Named, '', 0, 0, RakuAST::Name, '$name', 1, 0, Bool, '$capturing', 1, 1], anon sub new ($SELF_CONT, :$name!, :$capturing?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $capturing := nqp::decont($capturing);
#line 1069 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Named, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Named, '$!capturing',
            $capturing ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::Named, 'set-capturing', [RakuAST::Regex::Assertion::Named, '', 0, 0, Bool, '$capturing', 0, 0], anon sub set-capturing ($SELF_CONT, $capturing!) {
        my $SELF := nqp::decont($SELF_CONT);
        $capturing := nqp::decont($capturing);
#line 1077 src/Raku/ast/regex.rakumod
        
        nqp::bindattr($SELF, RakuAST::Regex::Assertion::Named, '$!capturing',
            $capturing ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        Nil
    
    });
    add-method(RakuAST::Regex::Assertion::Named, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Regex::Assertion::Named, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1083 src/Raku/ast/regex.rakumod
        
        # A call like <foo> will look for <&foo> and only then do <.foo>
        # (but in both cases it captures).
        $SELF.IMPL-WRAP-LIST: nqp::getattr($SELF, RakuAST::Regex::Assertion::Named, '$!capturing') && nqp::getattr($SELF, RakuAST::Regex::Assertion::Named, '$!name').is-identifier
            ?? [RakuAST::Var::Lexical.new('&' ~ nqp::getattr($SELF, RakuAST::Regex::Assertion::Named, '$!name').canonicalize)]
            !! []
    
    });
    add-method(RakuAST::Regex::Assertion::Named, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Named, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1091 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-REGEX-QAST-CALL($context)
    
    });
    add-method(RakuAST::Regex::Assertion::Named, 'IMPL-REGEX-QAST-CALL', [RakuAST::Regex::Assertion::Named, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-REGEX-QAST-CALL ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1095 src/Raku/ast/regex.rakumod
        
        my $longname := nqp::getattr($SELF, RakuAST::Regex::Assertion::Named, '$!name');
        if $longname.is-identifier {
            my $name := $longname.canonicalize;
            if $name eq 'sym' {
                nqp::die('special <sym> name not yet compiled');
            }
            else {
                my $lookups := $SELF.get-implicit-lookups;
                my $qast;
                if $lookups.elems && $lookups.AT-POS(0).is-resolved {
                    $qast := QAST::Regex.new: :rxtype<subrule>,:subtype<method>,
                        QAST::NodeList.new:
                            QAST::SVal.new( :value('CALL_SUBRULE') ),
                            $lookups.AT-POS(0).IMPL-TO-QAST($context);
                }
                else {
                    $qast := QAST::Regex.new: :rxtype<subrule>,
                        QAST::NodeList.new(QAST::SVal.new( :value($name) ));
                }
                if nqp::getattr($SELF, RakuAST::Regex::Assertion::Named, '$!capturing') {
                    $qast.subtype('capture');
                    $qast.name($name);
                }
                $qast
            }
        }
        else {
            nqp::die('non-identifier rule calls not yet compiled');
        }
    
    });
    add-method(RakuAST::Regex::Assertion::Named, 'visit-children', [RakuAST::Regex::Assertion::Named, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1127 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::Named, '$!name'));
    
    });
#line 1066 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Named, 'name', [], anon sub name ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Named, '$!name') });
#line 1067 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Named, 'capturing', [], anon sub capturing ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Named, '$!capturing') });
    compose(RakuAST::Regex::Assertion::Named);
    parent(RakuAST::Regex::Assertion::Named::Args, RakuAST::Regex::Assertion::Named);
    add-attribute(RakuAST::Regex::Assertion::Named::Args, RakuAST::ArgList, '$!args');
    add-method(RakuAST::Regex::Assertion::Named::Args, 'new', [RakuAST::Regex::Assertion::Named::Args, '', 0, 0, RakuAST::Name, '$name', 1, 0, Bool, '$capturing', 1, 1, Raku::ArgList, '$args', 1, 0], anon sub new ($SELF_CONT, :$name!, :$capturing?, :$args!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $capturing := nqp::decont($capturing);
        $args := nqp::decont($args);
#line 1138 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Named, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Named, '$!capturing',
            $capturing ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Named::Args, '$!args', $args);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::Named::Args, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Named::Args, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1147 src/Raku/ast/regex.rakumod
        
        my $call := $SELF.IMPL-REGEX-QAST-CALL($context);
        nqp::getattr($SELF, RakuAST::Regex::Assertion::Named::Args, '$!args').IMPL-ADD-QAST-ARGS($context, $call[0]);
        $call
    
    });
    add-method(RakuAST::Regex::Assertion::Named::Args, 'visit-children', [RakuAST::Regex::Assertion::Named::Args, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1153 src/Raku/ast/regex.rakumod
        
        $visitor($SELF.name);
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::Named::Args, '$!args'));
    
    });
#line 1136 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Named::Args, 'args', [], anon sub args ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Named::Args, '$!args') });
    compose(RakuAST::Regex::Assertion::Named::Args);
    parent(RakuAST::Regex::Assertion::Named::RegexArg, RakuAST::Regex::Assertion::Named);
    parent(RakuAST::Regex::Assertion::Named::RegexArg, RakuAST::RegexThunk);
    add-attribute(RakuAST::Regex::Assertion::Named::RegexArg, RakuAST::Regex, '$!regex-arg');
    add-attribute(RakuAST::Regex::Assertion::Named::RegexArg, str, '$!unique-name');
    add-attribute(RakuAST::Regex::Assertion::Named::RegexArg, Mu, '$!body-qast');
    add-method(RakuAST::Regex::Assertion::Named::RegexArg, 'new', [RakuAST::Regex::Assertion::Named::RegexArg, '', 0, 0, RakuAST::Name, '$name', 1, 0, Bool, '$capturing', 1, 1, Raku::Regex, '$regex-arg', 1, 0], anon sub new ($SELF_CONT, :$name!, :$capturing?, :$regex-arg!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $capturing := nqp::decont($capturing);
        $regex-arg := nqp::decont($regex-arg);
#line 1170 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Named, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Named, '$!capturing',
            $capturing ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Named::RegexArg,
            '$!regex-arg', $regex-arg);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::Named::RegexArg, 'IMPL-UNIQUE-NAME', [RakuAST::Regex::Assertion::Named::RegexArg, '', 0, 0], anon sub IMPL-UNIQUE-NAME ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1180 src/Raku/ast/regex.rakumod
        
        my str $unique-name := nqp::getattr_s($SELF, RakuAST::Regex::Assertion::Named::RegexArg, '$!unique-name');
        unless $unique-name {
            nqp::bindattr_s($SELF, RakuAST::Regex::Assertion::Named::RegexArg, '$!unique-name',
                ($unique-name := QAST::Node.unique('!__REGEX_ARG_')));
        }
        $unique-name
    
    });
    add-method(RakuAST::Regex::Assertion::Named::RegexArg, 'IMPL-THUNKED-REGEX-QAST', [RakuAST::Regex::Assertion::Named::RegexArg, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-THUNKED-REGEX-QAST ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1189 src/Raku/ast/regex.rakumod
        
        nqp::getattr($SELF, RakuAST::Regex::Assertion::Named::RegexArg, '$!regex-arg').IMPL-REGEX-TOP-LEVEL-QAST($context, $SELF.meta-object, nqp::hash(),
            :body-qast(nqp::getattr($SELF, RakuAST::Regex::Assertion::Named::RegexArg, '$!body-qast') // nqp::die('Misordered regex compilation')),
            :no-scan);
    
    });
    add-method(RakuAST::Regex::Assertion::Named::RegexArg, 'IMPL-QAST-DECL-CODE', [RakuAST::Regex::Assertion::Named::RegexArg, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub IMPL-QAST-DECL-CODE ($SELF_CONT, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
#line 1195 src/Raku/ast/regex.rakumod
        
        # Form the block itself and link it with the meta-object. Install it
        # in the lexpad; we'll look it up when we need it. This means we can
        # avoid closure-cloning it per time we enter it, which may help if we
        # are scanning or it's in a quantified thing.
        my str $name := $SELF.IMPL-UNIQUE-NAME;
        my $block := $SELF.IMPL-QAST-FORM-BLOCK($context, :blocktype('declaration_static'));
        $SELF.IMPL-LINK-META-OBJECT($context, $block);
        QAST::Stmts.new(
            $block,
            QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :decl<var>, :scope<lexical>, :$name ),
                $SELF.IMPL-CLOSURE-QAST($context)
            )
        )
    
    });
    add-method(RakuAST::Regex::Assertion::Named::RegexArg, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Named::RegexArg, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1213 src/Raku/ast/regex.rakumod
        
        nqp::bindattr($SELF, RakuAST::Regex::Assertion::Named::RegexArg, '$!body-qast',
            nqp::getattr($SELF, RakuAST::Regex::Assertion::Named::RegexArg, '$!regex-arg').IMPL-REGEX-QAST($context, %mods));
        my $qast := $SELF.IMPL-REGEX-QAST-CALL($context);
        my str $name := $SELF.IMPL-UNIQUE-NAME;
        $qast[0].push(QAST::Var.new( :$name, :scope('lexical') ));
        $qast
    
    });
    add-method(RakuAST::Regex::Assertion::Named::RegexArg, 'visit-children', [RakuAST::Regex::Assertion::Named::RegexArg, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1222 src/Raku/ast/regex.rakumod
        
        $visitor($SELF.name);
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::Named::RegexArg, '$!regex-arg'));
    
    });
#line 1164 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Named::RegexArg, 'regex-arg', [], anon sub regex-arg ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Named::RegexArg, '$!regex-arg') });
    compose(RakuAST::Regex::Assertion::Named::RegexArg);
    parent(RakuAST::Regex::Assertion::Alias, RakuAST::Regex::Assertion);
    add-attribute(RakuAST::Regex::Assertion::Alias, str, '$!name');
    add-attribute(RakuAST::Regex::Assertion::Alias, RakuAST::Regex::Assertion, '$!assertion');
    add-method(RakuAST::Regex::Assertion::Alias, 'new', [RakuAST::Regex::Assertion::Alias, '', 0, 0, str, '$name', 1, 0, RakuAST::Regex::Assertion, '$assertion', 1, 0], anon sub new ($SELF_CONT, :$name!, :$assertion!) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $assertion := nqp::decont($assertion);
#line 1236 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Regex::Assertion::Alias, '$!name', $name);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Alias, '$!assertion', $assertion);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::Alias, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Alias, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1243 src/Raku/ast/regex.rakumod
        
        my $qast := nqp::getattr($SELF, RakuAST::Regex::Assertion::Alias, '$!assertion').IMPL-REGEX-QAST($context, %mods);
        if $qast.rxtype eq 'subrule' {
            $SELF.IMPL-SUBRULE-ALIAS($qast, nqp::getattr_s($SELF, RakuAST::Regex::Assertion::Alias, '$!name'));
        }
        else {
            QAST::Regex.new( $qast, :name(nqp::getattr_s($SELF, RakuAST::Regex::Assertion::Alias, '$!name')), :rxtype<subcapture> );
        }
    
    });
    add-method(RakuAST::Regex::Assertion::Alias, 'visit-children', [RakuAST::Regex::Assertion::Alias, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1253 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::Alias, '$!assertion'));
    
    });
#line 1233 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Alias, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::Assertion::Alias, '$!name') });
#line 1234 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Alias, 'assertion', [], anon sub assertion ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Alias, '$!assertion') });
    compose(RakuAST::Regex::Assertion::Alias);
    parent(RakuAST::Regex::Assertion::Lookahead, RakuAST::Regex::Assertion);
    add-attribute(RakuAST::Regex::Assertion::Lookahead, Bool, '$!negated');
    add-attribute(RakuAST::Regex::Assertion::Lookahead, RakuAST::Regex::Assertion, '$!assertion');
    add-method(RakuAST::Regex::Assertion::Lookahead, 'new', [RakuAST::Regex::Assertion::Lookahead, '', 0, 0, Bool, '$negated', 1, 1, RakuAST::Regex::Assertion, '$assertion', 1, 0], anon sub new ($SELF_CONT, :$negated?, :$assertion!) {
        my $SELF := nqp::decont($SELF_CONT);
        $negated := nqp::decont($negated);
        $assertion := nqp::decont($assertion);
#line 1266 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Lookahead, '$!negated',
            $negated ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Lookahead, '$!assertion', $assertion);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::Lookahead, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Lookahead, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1274 src/Raku/ast/regex.rakumod
        
        my $qast := nqp::getattr($SELF, RakuAST::Regex::Assertion::Lookahead, '$!assertion').IMPL-REGEX-QAST($context, %mods);
        $qast.subtype('zerowidth');
        if nqp::getattr($SELF, RakuAST::Regex::Assertion::Lookahead, '$!negated') {
            $qast.negate(!$qast.negate);
        }
        $qast
    
    });
    add-method(RakuAST::Regex::Assertion::Lookahead, 'visit-children', [RakuAST::Regex::Assertion::Lookahead, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1283 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::Lookahead, '$!assertion'));
    
    });
#line 1263 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Lookahead, 'negated', [], anon sub negated ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Lookahead, '$!negated') });
#line 1264 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Lookahead, 'assertion', [], anon sub assertion ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Lookahead, '$!assertion') });
    compose(RakuAST::Regex::Assertion::Lookahead);
    parent(RakuAST::Regex::Assertion::InterpolatedBlock, RakuAST::Regex::Assertion);
    parent(RakuAST::Regex::Assertion::InterpolatedBlock, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Regex::Assertion::InterpolatedBlock, RakuAST::Block, '$!block');
    add-attribute(RakuAST::Regex::Assertion::InterpolatedBlock, Bool, '$!sequential');
    add-method(RakuAST::Regex::Assertion::InterpolatedBlock, 'new', [RakuAST::Regex::Assertion::InterpolatedBlock, '', 0, 0, RakuAST::Block, '$block', 1, 0, Bool, '$sequential', 1, 1], anon sub new ($SELF_CONT, :$block!, :$sequential?) {
        my $SELF := nqp::decont($SELF_CONT);
        $block := nqp::decont($block);
        $sequential := nqp::decont($sequential);
#line 1297 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::InterpolatedBlock, '$!block', $block);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::InterpolatedBlock, '$!sequential',
            $sequential ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::InterpolatedBlock, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Regex::Assertion::InterpolatedBlock, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1305 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('PseudoStash')),
        ])
    
    });
    add-method(RakuAST::Regex::Assertion::InterpolatedBlock, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::InterpolatedBlock, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1311 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-INTERPOLATE-ASSERTION(
          $context,
          %mods,
          $SELF.IMPL-REGEX-BLOCK-CALL($context, nqp::getattr($SELF, RakuAST::Regex::Assertion::InterpolatedBlock, '$!block')),
          nqp::getattr($SELF, RakuAST::Regex::Assertion::InterpolatedBlock, '$!sequential'),
          $SELF.get-implicit-lookups.AT-POS(0)
        )
    
    });
    add-method(RakuAST::Regex::Assertion::InterpolatedBlock, 'visit-children', [RakuAST::Regex::Assertion::InterpolatedBlock, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1321 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::InterpolatedBlock, '$!block'));
    
    });
#line 1295 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::InterpolatedBlock, 'sequential', [], anon sub sequential ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::InterpolatedBlock, '$!sequential') });
#line 1294 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::InterpolatedBlock, 'block', [], anon sub block ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::InterpolatedBlock, '$!block') });
    compose(RakuAST::Regex::Assertion::InterpolatedBlock);
    parent(RakuAST::Regex::Assertion::InterpolatedVar, RakuAST::Regex::Assertion);
    parent(RakuAST::Regex::Assertion::InterpolatedVar, RakuAST::ImplicitLookups);
    add-attribute(RakuAST::Regex::Assertion::InterpolatedVar, RakuAST::Expression, '$!var');
    add-attribute(RakuAST::Regex::Assertion::InterpolatedVar, Bool, '$!sequential');
    add-method(RakuAST::Regex::Assertion::InterpolatedVar, 'new', [RakuAST::Regex::Assertion::InterpolatedVar, '', 0, 0, RakuAST::Expression, '$var', 1, 0, Bool, '$sequential', 1, 1], anon sub new ($SELF_CONT, :$var!, :$sequential?) {
        my $SELF := nqp::decont($SELF_CONT);
        $var := nqp::decont($var);
        $sequential := nqp::decont($sequential);
#line 1335 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::InterpolatedVar, '$!var', $var);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::InterpolatedVar, '$!sequential',
            $sequential ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::InterpolatedVar, 'PRODUCE-IMPLICIT-LOOKUPS', [RakuAST::Regex::Assertion::InterpolatedVar, '', 0, 0], anon sub PRODUCE-IMPLICIT-LOOKUPS ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1343 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-WRAP-LIST([
            RakuAST::Type::Setting.new(RakuAST::Name.from-identifier('PseudoStash')),
        ])
    
    });
    add-method(RakuAST::Regex::Assertion::InterpolatedVar, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::InterpolatedVar, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1349 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-INTERPOLATE-ASSERTION(
          $context,
          %mods,
          nqp::getattr($SELF, RakuAST::Regex::Assertion::InterpolatedVar, '$!var').IMPL-TO-QAST($context),
          nqp::getattr($SELF, RakuAST::Regex::Assertion::InterpolatedVar, '$!sequential'),
          $SELF.get-implicit-lookups.AT-POS(0)
        )
    
    });
    add-method(RakuAST::Regex::Assertion::InterpolatedVar, 'visit-children', [RakuAST::Regex::Assertion::InterpolatedVar, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1359 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::InterpolatedVar, '$!var'));
    
    });
#line 1332 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::InterpolatedVar, 'var', [], anon sub var ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::InterpolatedVar, '$!var') });
#line 1333 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::InterpolatedVar, 'sequential', [], anon sub sequential ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::InterpolatedVar, '$!sequential') });
    compose(RakuAST::Regex::Assertion::InterpolatedVar);
    parent(RakuAST::Regex::Assertion::Callable, RakuAST::Regex::Assertion);
    add-attribute(RakuAST::Regex::Assertion::Callable, RakuAST::Expression, '$!callee');
    add-attribute(RakuAST::Regex::Assertion::Callable, RakuAST::ArgList, '$!args');
    add-method(RakuAST::Regex::Assertion::Callable, 'new', [RakuAST::Regex::Assertion::Callable, '', 0, 0, RakuAST::Expression, '$callee', 1, 0, Raku::ArgList, '$args', 1, 1], anon sub new ($SELF_CONT, :$callee!, :$args?) {
        my $SELF := nqp::decont($SELF_CONT);
        $callee := nqp::decont($callee);
        $args := nqp::decont($args);
#line 1372 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Callable, '$!callee', $callee);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::Callable, '$!args',
            $args // RakuAST::ArgList);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::Callable, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Callable, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1380 src/Raku/ast/regex.rakumod
        
        my $node-list := QAST::NodeList.new:
            QAST::SVal.new( :value('CALL_SUBRULE') ),
            nqp::getattr($SELF, RakuAST::Regex::Assertion::Callable, '$!callee').IMPL-TO-QAST($context);
        nqp::getattr($SELF, RakuAST::Regex::Assertion::Callable, '$!args').IMPL-ADD-QAST-ARGS($context, $node-list) if nqp::getattr($SELF, RakuAST::Regex::Assertion::Callable, '$!args');
        QAST::Regex.new( :rxtype<subrule>, :subtype<method>, $node-list )
    
    });
    add-method(RakuAST::Regex::Assertion::Callable, 'visit-children', [RakuAST::Regex::Assertion::Callable, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1388 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::Callable, '$!callee'));
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::Callable, '$!args')) if nqp::getattr($SELF, RakuAST::Regex::Assertion::Callable, '$!args');
    
    });
#line 1369 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Callable, 'callee', [], anon sub callee ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Callable, '$!callee') });
#line 1370 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Callable, 'args', [], anon sub args ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Callable, '$!args') });
    compose(RakuAST::Regex::Assertion::Callable);
    parent(RakuAST::Regex::Assertion::PredicateBlock, RakuAST::Regex::Assertion);
    add-attribute(RakuAST::Regex::Assertion::PredicateBlock, Bool, '$!negated');
    add-attribute(RakuAST::Regex::Assertion::PredicateBlock, RakuAST::Block, '$!block');
    add-method(RakuAST::Regex::Assertion::PredicateBlock, 'new', [RakuAST::Regex::Assertion::PredicateBlock, '', 0, 0, Bool, '$negated', 1, 1, RakuAST::Block, '$block', 1, 0], anon sub new ($SELF_CONT, :$negated?, :$block!) {
        my $SELF := nqp::decont($SELF_CONT);
        $negated := nqp::decont($negated);
        $block := nqp::decont($block);
#line 1402 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::PredicateBlock, '$!negated',
            $negated ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Regex::Assertion::PredicateBlock, '$!block', $block);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::PredicateBlock, 'quantifiable', [RakuAST::Regex::Assertion::PredicateBlock, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1410 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::Assertion::PredicateBlock, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::PredicateBlock, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1412 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype<qastnode>, :subtype<zerowidth>, :negate(nqp::getattr($SELF, RakuAST::Regex::Assertion::PredicateBlock, '$!negated') ?? 1 !! 0),
            $SELF.IMPL-REGEX-BLOCK-CALL($context, nqp::getattr($SELF, RakuAST::Regex::Assertion::PredicateBlock, '$!block'))
    
    });
    add-method(RakuAST::Regex::Assertion::PredicateBlock, 'visit-children', [RakuAST::Regex::Assertion::PredicateBlock, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1418 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Assertion::PredicateBlock, '$!block'));
    
    });
#line 1399 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::PredicateBlock, 'negated', [], anon sub negated ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::PredicateBlock, '$!negated') });
#line 1400 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::PredicateBlock, 'block', [], anon sub block ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::PredicateBlock, '$!block') });
    compose(RakuAST::Regex::Assertion::PredicateBlock);
    parent(RakuAST::Regex::Assertion::CharClass, RakuAST::Regex::Assertion);
    add-attribute(RakuAST::Regex::Assertion::CharClass, Mu, '$!elements');
    add-method(RakuAST::Regex::Assertion::CharClass, 'new', [RakuAST::Regex::Assertion::CharClass, '', 0, 0, Any, '@elements', 0, 0], anon sub new ($SELF_CONT, *@elements) {
        my $SELF := nqp::decont($SELF_CONT);
        @elements := nqp::decont(@elements);
#line 1429 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        if nqp::elems(@elements) == 0 {
            nqp::die('RakuAST::Regex::Assertion::CharClass must have at least one element');
        }
        for @elements {
            unless nqp::istype($_, RakuAST::Regex::CharClassElement) {
                nqp::die('Can only construct a RakuAST::Regex::Assertion::CharClass with elements of type RakuAST::Regex::CharClassElement')
            }
        }
        nqp::bindattr($obj, RakuAST::Regex::Assertion::CharClass, '$!elements',
            @elements);
        $obj
    
    });
    add-method(RakuAST::Regex::Assertion::CharClass, 'elements', [RakuAST::Regex::Assertion::CharClass, '', 0, 0], anon sub elements ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1444 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Regex::Assertion::CharClass, '$!elements'))
    
    });
    add-method(RakuAST::Regex::Assertion::CharClass, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::CharClass, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1448 src/Raku/ast/regex.rakumod
        
        # Compile the first element.
        my $first := nqp::getattr($SELF, RakuAST::Regex::Assertion::CharClass, '$!elements')[0];
        my $qast := $first.IMPL-CCLASS-QAST($context, %mods, (Bool.WHO)<True>);

        # Add further elements, exactly how depending on the exact nature of
        # the elements
        if nqp::elems(nqp::getattr($SELF, RakuAST::Regex::Assertion::CharClass, '$!elements')) > 1 {
            my int $i := 1;
            while $i < nqp::elems(nqp::getattr($SELF, RakuAST::Regex::Assertion::CharClass, '$!elements')) {
                my $elem := nqp::getattr($SELF, RakuAST::Regex::Assertion::CharClass, '$!elements')[$i];
                my $elem-qast := $elem.IMPL-CCLASS-QAST($context, %mods, (Bool.WHO)<False>);
                if $elem.negated {
                    $elem-qast.subtype('zerowidth');
                    $qast := QAST::Regex.new:
                        :rxtype<concat>, :subtype<zerowidth>, :negate,
                        QAST::Regex.new( :rxtype<conj>, :subtype<zerowidth>, $elem-qast ),
                        $qast;
                }
                else {
                    $qast := QAST::Regex.new( :rxtype<alt>, $qast, $elem-qast );
                }
                $i++;
            }
        }

        $qast
    
    });
    add-method(RakuAST::Regex::Assertion::CharClass, 'visit-children', [RakuAST::Regex::Assertion::CharClass, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1477 src/Raku/ast/regex.rakumod
        
        for nqp::getattr($SELF, RakuAST::Regex::Assertion::CharClass, '$!elements') {
            $visitor($_);
        }
    
    });
    compose(RakuAST::Regex::Assertion::CharClass);
    parent(RakuAST::Regex::Assertion::Recurse, RakuAST::Regex::Assertion);
    add-attribute(RakuAST::Regex::Assertion::Recurse, RakuAST::Regex::Term, '$!node');
    add-method(RakuAST::Regex::Assertion::Recurse, 'new', [RakuAST::Regex::Assertion::Recurse, '', 0, 0, RakuAST::Regex, '$node', 0, 0], anon sub new ($SELF_CONT, $node!) {
        my $SELF := nqp::decont($SELF_CONT);
        $node := nqp::decont($node);
#line 1489 src/Raku/ast/regex.rakumod
        
    my $obj := nqp::create($SELF);
    nqp::bindattr($obj, RakuAST::Regex::Assertion::Recurse, '$!node', $node);
    $obj;
  
    });
    add-method(RakuAST::Regex::Assertion::Recurse, 'IMPL-REGEX-QAST', [RakuAST::Regex::Assertion::Recurse, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1495 src/Raku/ast/regex.rakumod
        
     QAST::Regex.new:
        :rxtype<subrule>, :subtype<method>,
        QAST::NodeList.new( QAST::SVal.new( :value('RECURSE') ), :node(nqp::getattr($SELF, RakuAST::Regex::Assertion::Recurse, '$!node')));
  
    });
#line 1487 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Assertion::Recurse, 'node', [], anon sub node ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Assertion::Recurse, '$!node') });
    compose(RakuAST::Regex::Assertion::Recurse);
    parent(RakuAST::Regex::CharClassElement, RakuAST::Node);
    add-attribute(RakuAST::Regex::CharClassElement, Bool, '$!negated');
#line 1507 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClassElement, 'negated', [], anon sub negated ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::CharClassElement, '$!negated') });
    compose(RakuAST::Regex::CharClassElement);
    parent(RakuAST::Regex::CharClassElement::Rule, RakuAST::Regex::CharClassElement);
    add-attribute(RakuAST::Regex::CharClassElement::Rule, str, '$!name');
    add-method(RakuAST::Regex::CharClassElement::Rule, 'new', [RakuAST::Regex::CharClassElement::Rule, '', 0, 0, str, '$name', 1, 0, Bool, '$negated', 1, 1], anon sub new ($SELF_CONT, :$name!, :$negated?) {
        my $SELF := nqp::decont($SELF_CONT);
        $name := nqp::decont($name);
        $negated := nqp::decont($negated);
#line 1516 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::CharClassElement, '$!negated',
            $negated ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr_s($obj, RakuAST::Regex::CharClassElement::Rule, '$!name', $name);
        $obj
    
    });
    add-method(RakuAST::Regex::CharClassElement::Rule, 'IMPL-CCLASS-QAST', [RakuAST::Regex::CharClassElement::Rule, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$first', 0, 0], anon sub IMPL-CCLASS-QAST ($SELF_CONT, $context!, %mods!, $first!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $first := nqp::decont($first);
#line 1524 src/Raku/ast/regex.rakumod
        
        my $negate := $SELF.negated;
        my $name := QAST::NodeList.new(QAST::SVal.new( :value(nqp::getattr_s($SELF, RakuAST::Regex::CharClassElement::Rule, '$!name')) ));
        if $negate && $first {
            QAST::Regex.new: :rxtype<concat>,
                QAST::Regex.new( :rxtype<subrule>, :subtype<zerowidth>, :$negate, $name ),
                QAST::Regex.new( :rxtype<cclass>, :name<.> );
        }
        else {
            QAST::Regex.new( :rxtype<subrule>, :subtype<method>, :$negate, $name )
        }
    
    });
#line 1514 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClassElement::Rule, 'name', [], anon sub name ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::CharClassElement::Rule, '$!name') });
    compose(RakuAST::Regex::CharClassElement::Rule);
    parent(RakuAST::Regex::CharClassElement::Property, RakuAST::Regex::CharClassElement);
    add-attribute(RakuAST::Regex::CharClassElement::Property, str, '$!property');
    add-attribute(RakuAST::Regex::CharClassElement::Property, Bool, '$!inverted');
    add-attribute(RakuAST::Regex::CharClassElement::Property, RakuAST::Expression, '$!predicate');
    add-method(RakuAST::Regex::CharClassElement::Property, 'new', [RakuAST::Regex::CharClassElement::Property, '', 0, 0, str, '$property', 1, 0, Bool, '$inverted', 1, 1, RakuAST::Expression, '$predicate', 1, 1, Bool, '$negated', 1, 1], anon sub new ($SELF_CONT, :$property!, :$inverted?, :$predicate?, :$negated?) {
        my $SELF := nqp::decont($SELF_CONT);
        $property := nqp::decont($property);
        $inverted := nqp::decont($inverted);
        $predicate := nqp::decont($predicate);
        $negated := nqp::decont($negated);
#line 1547 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::CharClassElement, '$!negated',
            $negated ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr_s($obj, RakuAST::Regex::CharClassElement::Property, '$!property',
            $property);
        nqp::bindattr($obj, RakuAST::Regex::CharClassElement::Property, '$!inverted',
            $inverted ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Regex::CharClassElement::Property, '$!predicate',
            $predicate // RakuAST::Expression);
        $obj
    
    });
    add-method(RakuAST::Regex::CharClassElement::Property, 'IMPL-CCLASS-QAST', [RakuAST::Regex::CharClassElement::Property, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$first', 0, 0], anon sub IMPL-CCLASS-QAST ($SELF_CONT, $context!, %mods!, $first!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $first := nqp::decont($first);
#line 1560 src/Raku/ast/regex.rakumod
        
        my $negate := $SELF.negated ?? !nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Property, '$!inverted') !! nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Property, '$!inverted');
        my $qast := QAST::Regex.new( :rxtype<uniprop>, :$negate, nqp::getattr_s($SELF, RakuAST::Regex::CharClassElement::Property, '$!property') );
        $qast.push(nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Property, '$!predicate').IMPL-TO-QAST($context)) if nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Property, '$!predicate');
        $qast
    
    });
    add-method(RakuAST::Regex::CharClassElement::Property, 'visit-children', [RakuAST::Regex::CharClassElement::Property, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1567 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Property, '$!predicate')) if nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Property, '$!predicate');
    
    });
#line 1542 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClassElement::Property, 'property', [], anon sub property ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::CharClassElement::Property, '$!property') });
#line 1544 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClassElement::Property, 'predicate', [], anon sub predicate ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::CharClassElement::Property, '$!predicate') });
#line 1543 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClassElement::Property, 'inverted', [], anon sub inverted ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::CharClassElement::Property, '$!inverted') });
    compose(RakuAST::Regex::CharClassElement::Property);
    parent(RakuAST::Regex::CharClassElement::Enumeration, RakuAST::Regex::CharClassElement);
    parent(RakuAST::Regex::CharClassElement::Enumeration, RakuAST::CheckTime);
    add-attribute(RakuAST::Regex::CharClassElement::Enumeration, Mu, '$!elements');
    add-method(RakuAST::Regex::CharClassElement::Enumeration, 'new', [RakuAST::Regex::CharClassElement::Enumeration, '', 0, 0, List, '$elements', 1, 0, Bool, '$negated', 1, 1], anon sub new ($SELF_CONT, :$elements!, :$negated?) {
        my $SELF := nqp::decont($SELF_CONT);
        $elements := nqp::decont($elements);
        $negated := nqp::decont($negated);
#line 1580 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::CharClassElement, '$!negated',
            $negated ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        my @elements := $SELF.IMPL-UNWRAP-LIST($elements);
        nqp::bindattr($obj, RakuAST::Regex::CharClassElement::Enumeration,
          '$!elements', $SELF.IMPL-UNWRAP-LIST($elements));
        $obj
    
    });
    add-method(RakuAST::Regex::CharClassElement::Enumeration, 'elements', [RakuAST::Regex::CharClassElement::Enumeration, '', 0, 0], anon sub elements ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1590 src/Raku/ast/regex.rakumod
        
        $SELF.IMPL-WRAP-LIST(nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Enumeration, '$!elements'))
    
    });
    add-method(RakuAST::Regex::CharClassElement::Enumeration, 'PERFORM-CHECK', [RakuAST::Regex::CharClassElement::Enumeration, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1594 src/Raku/ast/regex.rakumod
        
        if nqp::elems(nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Enumeration, '$!elements')) {
            for nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Enumeration, '$!elements') {
                unless nqp::istype($_,RakuAST::Regex::CharClassEnumerationElement) {
                    $SELF.add-sorry:
                      $resolver.build-exception: 'X::AdHoc',
                        payload => "Character classes can only be built with RakuAST::Regex::CharClassEnumerationElement objects,\n not with " ~ $_.HOW.name($_) ~ " elements";
                }
            }
        }
        else {
            $SELF.add-worry:
              $resolver.build-exception: 'X::AdHoc',
                payload => "Character classes without elements will never match"
        }
    
    });
    add-method(RakuAST::Regex::CharClassElement::Enumeration, 'IMPL-CCLASS-QAST', [RakuAST::Regex::CharClassElement::Enumeration, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$first', 0, 0], anon sub IMPL-CCLASS-QAST ($SELF_CONT, $context!, %mods!, $first!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $first := nqp::decont($first);
#line 1611 src/Raku/ast/regex.rakumod
        
        # Go through the elements, which either produce characters to go into an
        # enumeration or a QAST node.
        my str $enum := '';
        my @alts;
        for nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Enumeration, '$!elements') {
            my str $enum-contrib := $_.IMPL-CCLASS-ENUM-CHARS(%mods);
            if $enum-contrib ne '' {
                $enum := $enum ~ $enum-contrib;
            }
            else {
                @alts.push($_.IMPL-CCLASS-ENUM-QAST($context, %mods, $SELF.negated));
            }
        }

        # If we collected characters, add the enumeration to the alternation
        # parts we'll compile into.
        if $enum {
            @alts.push: QAST::Regex.new:
                :rxtype<enumcharlist>, :negate($SELF.negated),
                :subtype(%mods<m> ?? 'ignoremark' !! ''),
                $enum
        }

        # A single alternation part can compile into just that.
        if nqp::elems(@alts) == 1 {
            @alts[0]
        }

        # An empty enumation always fails.
        elsif nqp::elems(@alts) == 0 {
            QAST::Regex.new( :rxtype<anchor>, :subtype<fail> )
        }

        else {
            $SELF.negated ??
                QAST::Regex.new( :rxtype<concat>, :negate(1),
                    QAST::Regex.new( :rxtype<conj>, :subtype<zerowidth>, |@alts ),
                    QAST::Regex.new( :rxtype<cclass>, :name<.> ) ) !!
                QAST::Regex.new( :rxtype<alt>, |@alts );
        }
    
    });
    add-method(RakuAST::Regex::CharClassElement::Enumeration, 'visit-children', [RakuAST::Regex::CharClassElement::Enumeration, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1654 src/Raku/ast/regex.rakumod
        
        for nqp::getattr($SELF, RakuAST::Regex::CharClassElement::Enumeration, '$!elements') {
            $visitor($_);
        }
    
    });
    compose(RakuAST::Regex::CharClassElement::Enumeration);
    parent(RakuAST::Regex::CharClassEnumerationElement::Character, RakuAST::Regex::CharClassEnumerationElement);
    add-attribute(RakuAST::Regex::CharClassEnumerationElement::Character, str, '$!character');
    add-method(RakuAST::Regex::CharClassEnumerationElement::Character, 'new', [RakuAST::Regex::CharClassEnumerationElement::Character, '', 0, 0, str, '$character', 0, 0], anon sub new ($SELF_CONT, $character!) {
        my $SELF := nqp::decont($SELF_CONT);
        $character := nqp::decont($character);
#line 1668 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj, RakuAST::Regex::CharClassEnumerationElement::Character,
            '$!character', $character);
        $obj
    
    });
    add-method(RakuAST::Regex::CharClassEnumerationElement::Character, 'IMPL-CCLASS-ENUM-CHARS', [RakuAST::Regex::CharClassEnumerationElement::Character, '', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-CCLASS-ENUM-CHARS ($SELF_CONT, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        %mods := nqp::decont(%mods);
#line 1675 src/Raku/ast/regex.rakumod
        
        my str $c := %mods<m>
            ?? nqp::chr(nqp::ordbaseat(nqp::getattr_s($SELF, RakuAST::Regex::CharClassEnumerationElement::Character, '$!character'), 0))
            !! nqp::getattr_s($SELF, RakuAST::Regex::CharClassEnumerationElement::Character, '$!character');
        %mods<i>
            ?? nqp::fc($c) ~ nqp::uc($c)
            !! $c
    
    });
#line 1666 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClassEnumerationElement::Character, 'character', [], anon sub character ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::CharClassEnumerationElement::Character, '$!character') });
    compose(RakuAST::Regex::CharClassEnumerationElement::Character);
    parent(RakuAST::Regex::CharClassEnumerationElement::Range, RakuAST::CheckTime);
    parent(RakuAST::Regex::CharClassEnumerationElement::Range, RakuAST::Regex::CharClassEnumerationElement);
    add-attribute(RakuAST::Regex::CharClassEnumerationElement::Range, int, '$!from');
    add-attribute(RakuAST::Regex::CharClassEnumerationElement::Range, int, '$!to');
    add-method(RakuAST::Regex::CharClassEnumerationElement::Range, 'new', [RakuAST::Regex::CharClassEnumerationElement::Range, '', 0, 0, int, '$from', 1, 0, int, '$to', 1, 0], anon sub new ($SELF_CONT, :$from!, :$to!) {
        my $SELF := nqp::decont($SELF_CONT);
        $from := nqp::decont($from);
        $to := nqp::decont($to);
#line 1695 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_i($obj, RakuAST::Regex::CharClassEnumerationElement::Range,
            '$!from', $from);
        nqp::bindattr_i($obj, RakuAST::Regex::CharClassEnumerationElement::Range,
            '$!to', $to);
        $obj
    
    });
    add-method(RakuAST::Regex::CharClassEnumerationElement::Range, 'PERFORM-CHECK', [RakuAST::Regex::CharClassEnumerationElement::Range, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1704 src/Raku/ast/regex.rakumod
        
        if nqp::getattr_i($SELF, RakuAST::Regex::CharClassEnumerationElement::Range, '$!from') > nqp::getattr_i($SELF, RakuAST::Regex::CharClassEnumerationElement::Range, '$!to') {
            $SELF.add-sorry:
              $resolver.build-exception: 'X::AdHoc',
                payload => "Illegal reversed character range";
        }
    
    });
    add-method(RakuAST::Regex::CharClassEnumerationElement::Range, 'IMPL-CCLASS-ENUM-QAST', [RakuAST::Regex::CharClassEnumerationElement::Range, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0, Bool, '$negate', 0, 0], anon sub IMPL-CCLASS-ENUM-QAST ($SELF_CONT, $context!, %mods!, $negate!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
        $negate := nqp::decont($negate);
#line 1712 src/Raku/ast/regex.rakumod
        
        QAST::Regex.new:
            :rxtype<charrange>, :$negate,
            %mods<m>
                ?? (%mods<i> ?? 'ignorecase+ignoremark' !! 'ignoremark')
                !! (%mods<i> ?? 'ignorecase' !! ''),
            QAST::IVal.new( :value(nqp::getattr_i($SELF, RakuAST::Regex::CharClassEnumerationElement::Range, '$!from')) ),
            QAST::IVal.new( :value(nqp::getattr_i($SELF, RakuAST::Regex::CharClassEnumerationElement::Range, '$!to')) )
    
    });
#line 1693 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClassEnumerationElement::Range, 'to', [], anon sub to ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Regex::CharClassEnumerationElement::Range, '$!to') });
#line 1692 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::CharClassEnumerationElement::Range, 'from', [], anon sub from ($self) { nqp::getattr_i(nqp::decont($self), RakuAST::Regex::CharClassEnumerationElement::Range, '$!from') });
    compose(RakuAST::Regex::CharClassEnumerationElement::Range);
    parent(RakuAST::Regex::InternalModifier, RakuAST::Regex::Atom);
    add-attribute(RakuAST::Regex::InternalModifier, str, '$!modifier');
    add-attribute(RakuAST::Regex::InternalModifier, Bool, '$!negated');
    add-method(RakuAST::Regex::InternalModifier, 'new', [RakuAST::Regex::InternalModifier, '', 0, 0, str, '$modifier', 1, 1, Bool, '$negated', 1, 1], anon sub new ($SELF_CONT, :$modifier?, :$negated?) {
        my $SELF := nqp::decont($SELF_CONT);
        $modifier := nqp::decont($modifier);
        $negated := nqp::decont($negated);
#line 1730 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr_s($obj,RakuAST::Regex::InternalModifier,'$!modifier',
          $modifier // $SELF.key);
        nqp::bindattr(  $obj,RakuAST::Regex::InternalModifier,'$!negated',
          $negated ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Regex::InternalModifier, 'quantifiable', [RakuAST::Regex::InternalModifier, '', 0, 0], anon sub quantifiable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1739 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::InternalModifier, 'whitespace-wrappable', [RakuAST::Regex::InternalModifier, '', 0, 0], anon sub whitespace-wrappable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1740 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
    add-method(RakuAST::Regex::InternalModifier, 'IMPL-REGEX-QAST', [RakuAST::Regex::InternalModifier, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1742 src/Raku/ast/regex.rakumod
        
        %mods{$SELF.key} := !$SELF.negated;
        Nil
    
    });
#line 1728 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::InternalModifier, 'negated', [], anon sub negated ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::InternalModifier, '$!negated') });
#line 1727 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::InternalModifier, 'modifier', [], anon sub modifier ($self) { nqp::getattr_s(nqp::decont($self), RakuAST::Regex::InternalModifier, '$!modifier') });
    compose(RakuAST::Regex::InternalModifier);
    parent(RakuAST::Regex::InternalModifier::IgnoreCase, RakuAST::Regex::InternalModifier);
    add-method(RakuAST::Regex::InternalModifier::IgnoreCase, 'key', [RakuAST::Regex::InternalModifier::IgnoreCase, '', 0, 0], anon sub key ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1752 src/Raku/ast/regex.rakumod
         'i' 
    });
    compose(RakuAST::Regex::InternalModifier::IgnoreCase);
    parent(RakuAST::Regex::InternalModifier::IgnoreMark, RakuAST::Regex::InternalModifier);
    add-method(RakuAST::Regex::InternalModifier::IgnoreMark, 'key', [RakuAST::Regex::InternalModifier::IgnoreMark, '', 0, 0], anon sub key ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1759 src/Raku/ast/regex.rakumod
         'm' 
    });
    compose(RakuAST::Regex::InternalModifier::IgnoreMark);
    parent(RakuAST::Regex::InternalModifier::Ratchet, RakuAST::Regex::InternalModifier);
    add-method(RakuAST::Regex::InternalModifier::Ratchet, 'key', [RakuAST::Regex::InternalModifier::Ratchet, '', 0, 0], anon sub key ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1766 src/Raku/ast/regex.rakumod
         'r' 
    });
    compose(RakuAST::Regex::InternalModifier::Ratchet);
    parent(RakuAST::Regex::InternalModifier::Sigspace, RakuAST::Regex::InternalModifier);
    add-method(RakuAST::Regex::InternalModifier::Sigspace, 'key', [RakuAST::Regex::InternalModifier::Sigspace, '', 0, 0], anon sub key ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 1773 src/Raku/ast/regex.rakumod
         's' 
    });
    compose(RakuAST::Regex::InternalModifier::Sigspace);
    parent(RakuAST::Regex::QuantifiedAtom, RakuAST::Regex::Term);
    parent(RakuAST::Regex::QuantifiedAtom, RakuAST::CheckTime);
    add-attribute(RakuAST::Regex::QuantifiedAtom, RakuAST::Atom, '$!atom');
    add-attribute(RakuAST::Regex::QuantifiedAtom, RakuAST::Quantifier, '$!quantifier');
    add-attribute(RakuAST::Regex::QuantifiedAtom, RakuAST::Regex::Term, '$!separator');
    add-attribute(RakuAST::Regex::QuantifiedAtom, Bool, '$!trailing-separator');
    add-method(RakuAST::Regex::QuantifiedAtom, 'new', [RakuAST::Regex::QuantifiedAtom, '', 0, 0, RakuAST::Atom, '$atom', 1, 0, RakuAST::Quantifier, '$quantifier', 1, 0, RakuAST::Separator, '$separator', 1, 1, Bool, '$trailing-separator', 1, 1], anon sub new ($SELF_CONT, :$atom!, :$quantifier!, :$separator?, :$trailing-separator?) {
        my $SELF := nqp::decont($SELF_CONT);
        $atom := nqp::decont($atom);
        $quantifier := nqp::decont($quantifier);
        $separator := nqp::decont($separator);
        $trailing-separator := nqp::decont($trailing-separator);
#line 1788 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::QuantifiedAtom, '$!atom', $atom);
        nqp::bindattr($obj, RakuAST::Regex::QuantifiedAtom, '$!quantifier', $quantifier);
        nqp::bindattr($obj, RakuAST::Regex::QuantifiedAtom, '$!separator',
            $separator // RakuAST::Regex::Term);
        nqp::bindattr($obj, RakuAST::Regex::QuantifiedAtom, '$!trailing-separator',
            $trailing-separator ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Regex::QuantifiedAtom, 'replace-atom', [RakuAST::Regex::QuantifiedAtom, '', 0, 0, RakuAST::Atom, '$atom', 0, 0], anon sub replace-atom ($SELF_CONT, $atom!) {
        my $SELF := nqp::decont($SELF_CONT);
        $atom := nqp::decont($atom);
#line 1799 src/Raku/ast/regex.rakumod
        
        nqp::bindattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!atom', $atom);
        Nil
    
    });
    add-method(RakuAST::Regex::QuantifiedAtom, 'PERFORM-CHECK', [RakuAST::Regex::QuantifiedAtom, '', 0, 0, RakuAST::Resolver, '$resolver', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0], anon sub PERFORM-CHECK ($SELF_CONT, $resolver!, $context!) {
        my $SELF := nqp::decont($SELF_CONT);
        $resolver := nqp::decont($resolver);
        $context := nqp::decont($context);
#line 1804 src/Raku/ast/regex.rakumod
        
        unless nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!atom').quantifiable {
            $SELF.add-sorry:
              $resolver.build-exception: 'X::Syntax::Regex::NonQuantifiable';
        }
    
    });
    add-method(RakuAST::Regex::QuantifiedAtom, 'IMPL-REGEX-QAST', [RakuAST::Regex::QuantifiedAtom, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1811 src/Raku/ast/regex.rakumod
        
        my $atom := nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!atom').IMPL-REGEX-QAST($context, %mods);
        my $quantified := nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!quantifier').IMPL-QAST-QUANTIFY($context, $atom, %mods);
        if nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!separator') {
            $quantified.push(nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!separator').IMPL-REGEX-QAST($context, %mods));
            if nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!trailing-separator') {
                QAST::Regex.new(
                    :rxtype<concat>,
                    $quantified,
                    QAST::Regex.new(
                        :rxtype<quant>, :min(0), :max(1),
                        nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!separator').IMPL-REGEX-QAST($context, %mods)
                    )
                )
            }
            else {
                $quantified
            }
        }
        else {
            $quantified
        }
    
    });
    add-method(RakuAST::Regex::QuantifiedAtom, 'visit-children', [RakuAST::Regex::QuantifiedAtom, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1835 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!atom'));
        $visitor(nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!quantifier'));
        $visitor(nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!separator')) if nqp::getattr($SELF, RakuAST::Regex::QuantifiedAtom, '$!separator');
    
    });
#line 1785 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::QuantifiedAtom, 'trailing-separator', [], anon sub trailing-separator ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::QuantifiedAtom, '$!trailing-separator') });
#line 1784 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::QuantifiedAtom, 'separator', [], anon sub separator ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::QuantifiedAtom, '$!separator') });
#line 1783 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::QuantifiedAtom, 'quantifier', [], anon sub quantifier ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::QuantifiedAtom, '$!quantifier') });
#line 1782 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::QuantifiedAtom, 'atom', [], anon sub atom ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::QuantifiedAtom, '$!atom') });
    compose(RakuAST::Regex::QuantifiedAtom);
    parent(RakuAST::Regex::Quantifier, RakuAST::Node);
    add-attribute(RakuAST::Regex::Quantifier, RakuAST::Regex::Backtrack, '$!backtrack');
    add-method(RakuAST::Regex::Quantifier, 'new', [RakuAST::Regex::Quantifier, '', 0, 0, RakuAST::Regex::Backtrack, '$backtrack', 1, 1], anon sub new ($SELF_CONT, :$backtrack?) {
        my $SELF := nqp::decont($SELF_CONT);
        $backtrack := nqp::decont($backtrack);
#line 1848 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Quantifier, '$!backtrack',
            nqp::istype($backtrack, RakuAST::Regex::Backtrack)
                ?? $backtrack
                !! RakuAST::Regex::Backtrack);
        $obj
    
    });
    add-method(RakuAST::Regex::Quantifier, 'visit-children', [RakuAST::Regex::Quantifier, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1857 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Quantifier, '$!backtrack')) if nqp::getattr($SELF, RakuAST::Regex::Quantifier, '$!backtrack');
    
    });
#line 1846 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Quantifier, 'backtrack', [], anon sub backtrack ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Quantifier, '$!backtrack') });
    compose(RakuAST::Regex::Quantifier);
    parent(RakuAST::Regex::Quantifier::ZeroOrOne, RakuAST::Regex::Quantifier);
    add-method(RakuAST::Regex::Quantifier::ZeroOrOne, 'IMPL-QAST-QUANTIFY', [RakuAST::Regex::Quantifier::ZeroOrOne, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$atom-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-QUANTIFY ($SELF_CONT, $context!, $atom-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $atom-qast := nqp::decont($atom-qast);
        %mods := nqp::decont(%mods);
#line 1866 src/Raku/ast/regex.rakumod
        
        $SELF.backtrack.IMPL-QAST-APPLY:
            QAST::Regex.new( :rxtype<quant>, :min(0), :max(1), $atom-qast ),
            %mods
    
    });
    compose(RakuAST::Regex::Quantifier::ZeroOrOne);
    parent(RakuAST::Regex::Quantifier::ZeroOrMore, RakuAST::Regex::Quantifier);
    add-method(RakuAST::Regex::Quantifier::ZeroOrMore, 'IMPL-QAST-QUANTIFY', [RakuAST::Regex::Quantifier::ZeroOrMore, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$atom-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-QUANTIFY ($SELF_CONT, $context!, $atom-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $atom-qast := nqp::decont($atom-qast);
        %mods := nqp::decont(%mods);
#line 1877 src/Raku/ast/regex.rakumod
        
        $SELF.backtrack.IMPL-QAST-APPLY:
            QAST::Regex.new( :rxtype<quant>, :min(0), :max(-1), $atom-qast ),
            %mods
    
    });
    compose(RakuAST::Regex::Quantifier::ZeroOrMore);
    parent(RakuAST::Regex::Quantifier::OneOrMore, RakuAST::Regex::Quantifier);
    add-method(RakuAST::Regex::Quantifier::OneOrMore, 'IMPL-QAST-QUANTIFY', [RakuAST::Regex::Quantifier::OneOrMore, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$atom-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-QUANTIFY ($SELF_CONT, $context!, $atom-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $atom-qast := nqp::decont($atom-qast);
        %mods := nqp::decont(%mods);
#line 1888 src/Raku/ast/regex.rakumod
        
        $SELF.backtrack.IMPL-QAST-APPLY:
            QAST::Regex.new( :rxtype<quant>, :min(1), :max(-1), $atom-qast ),
            %mods
    
    });
    compose(RakuAST::Regex::Quantifier::OneOrMore);
    parent(RakuAST::Regex::Quantifier::Range, RakuAST::Regex::Quantifier);
    add-attribute(RakuAST::Regex::Quantifier::Range, Int, '$!min');
    add-attribute(RakuAST::Regex::Quantifier::Range, Int, '$!max');
    add-attribute(RakuAST::Regex::Quantifier::Range, Bool, '$!excludes-min');
    add-attribute(RakuAST::Regex::Quantifier::Range, Bool, '$!excludes-max');
    add-method(RakuAST::Regex::Quantifier::Range, 'new', [RakuAST::Regex::Quantifier::Range, '', 0, 0, Int, '$min', 1, 1, Int, '$max', 1, 1, Bool, '$excludes-max', 1, 1, Bool, '$excludes-min', 1, 1, RakuAST::Regex::Backtrack, '$backtrack', 1, 1], anon sub new ($SELF_CONT, :$min?, :$max?, :$excludes-max?, :$excludes-min?, :$backtrack?) {
        my $SELF := nqp::decont($SELF_CONT);
        $min := nqp::decont($min);
        $max := nqp::decont($max);
        $excludes-max := nqp::decont($excludes-max);
        $excludes-min := nqp::decont($excludes-min);
        $backtrack := nqp::decont($backtrack);
#line 1905 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Quantifier, '$!backtrack',
            nqp::istype($backtrack, RakuAST::Regex::Backtrack)
                ?? $backtrack
                !! RakuAST::Regex::Backtrack);
        nqp::bindattr($obj, RakuAST::Regex::Quantifier::Range, '$!min', $min // Int);
        nqp::bindattr($obj, RakuAST::Regex::Quantifier::Range, '$!max', $max // Int);
        nqp::bindattr($obj, RakuAST::Regex::Quantifier::Range, '$!excludes-min',
            $excludes-min ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        nqp::bindattr($obj, RakuAST::Regex::Quantifier::Range, '$!excludes-max',
            $excludes-max ?? (Bool.WHO)<True> !! (Bool.WHO)<False>);
        $obj
    
    });
    add-method(RakuAST::Regex::Quantifier::Range, 'IMPL-QAST-QUANTIFY', [RakuAST::Regex::Quantifier::Range, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$atom-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-QUANTIFY ($SELF_CONT, $context!, $atom-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $atom-qast := nqp::decont($atom-qast);
        %mods := nqp::decont(%mods);
#line 1920 src/Raku/ast/regex.rakumod
        
        my int $min := nqp::getattr($SELF, RakuAST::Regex::Quantifier::Range, '$!min') // 0;
        $min++ if nqp::getattr($SELF, RakuAST::Regex::Quantifier::Range, '$!excludes-min');
        my int $max := -1;
        if nqp::getattr($SELF, RakuAST::Regex::Quantifier::Range, '$!max') {
            $max := nqp::getattr($SELF, RakuAST::Regex::Quantifier::Range, '$!max');
            $max-- if nqp::getattr($SELF, RakuAST::Regex::Quantifier::Range, '$!excludes-max');
        }
        $SELF.backtrack.IMPL-QAST-APPLY:
            QAST::Regex.new( :rxtype<quant>, :min($min), :max($max), $atom-qast ),
            %mods
    
    });
#line 1899 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Quantifier::Range, 'min', [], anon sub min ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Quantifier::Range, '$!min') });
#line 1900 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Quantifier::Range, 'max', [], anon sub max ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Quantifier::Range, '$!max') });
#line 1901 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Quantifier::Range, 'excludes-min', [], anon sub excludes-min ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Quantifier::Range, '$!excludes-min') });
#line 1902 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Quantifier::Range, 'excludes-max', [], anon sub excludes-max ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Quantifier::Range, '$!excludes-max') });
    compose(RakuAST::Regex::Quantifier::Range);
    parent(RakuAST::Regex::Quantifier::BlockRange, RakuAST::Regex::Quantifier);
    add-attribute(RakuAST::Regex::Quantifier::BlockRange, RakuAST::Block, '$!block');
    add-method(RakuAST::Regex::Quantifier::BlockRange, 'new', [RakuAST::Regex::Quantifier::BlockRange, '', 0, 0, RakuAST::Block, '$block', 1, 0, RakuAST::Regex::Backtrack, '$backtrack', 1, 1], anon sub new ($SELF_CONT, :$block!, :$backtrack?) {
        my $SELF := nqp::decont($SELF_CONT);
        $block := nqp::decont($block);
        $backtrack := nqp::decont($backtrack);
#line 1940 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::Quantifier, '$!backtrack',
            nqp::istype($backtrack, RakuAST::Regex::Backtrack)
                ?? $backtrack
                !! RakuAST::Regex::Backtrack);
        nqp::bindattr($obj, RakuAST::Regex::Quantifier::BlockRange, '$!block', $block);
        $obj
    
    });
    add-method(RakuAST::Regex::Quantifier::BlockRange, 'IMPL-QAST-QUANTIFY', [RakuAST::Regex::Quantifier::BlockRange, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Mu, '$atom-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-QUANTIFY ($SELF_CONT, $context!, $atom-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        $atom-qast := nqp::decont($atom-qast);
        %mods := nqp::decont(%mods);
#line 1950 src/Raku/ast/regex.rakumod
        
        $SELF.backtrack.IMPL-QAST-APPLY:
            QAST::Regex.new(
                :rxtype<dynquant>,
                $atom-qast,
                QAST::Op.new(
                    :op('callmethod'), :name('DYNQUANT_LIMITS'),
                    QAST::Var.new( :name('$¢'), :scope('lexical') ),
                    RakuAST::Regex.IMPL-REGEX-BLOCK-CALL($context, nqp::getattr($SELF, RakuAST::Regex::Quantifier::BlockRange, '$!block'))
                ),
            ),
            %mods
    
    });
    add-method(RakuAST::Regex::Quantifier::BlockRange, 'visit-children', [RakuAST::Regex::Quantifier::BlockRange, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1964 src/Raku/ast/regex.rakumod
        
        $visitor($SELF.backtrack);
        $visitor(nqp::getattr($SELF, RakuAST::Regex::Quantifier::BlockRange, '$!block'));
    
    });
#line 1938 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::Quantifier::BlockRange, 'block', [], anon sub block ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::Quantifier::BlockRange, '$!block') });
    compose(RakuAST::Regex::Quantifier::BlockRange);
    parent(RakuAST::Regex::BacktrackModifiedAtom, RakuAST::Regex::Term);
    add-attribute(RakuAST::Regex::BacktrackModifiedAtom, RakuAST::Atom, '$!atom');
    add-attribute(RakuAST::Regex::BacktrackModifiedAtom, RakuAST::Regex::Backtrack, '$!backtrack');
    add-method(RakuAST::Regex::BacktrackModifiedAtom, 'new', [RakuAST::Regex::BacktrackModifiedAtom, '', 0, 0, RakuAST::Atom, '$atom', 1, 0, RakuAST::Regex::Backtrack, '$backtrack', 1, 0], anon sub new ($SELF_CONT, :$atom!, :$backtrack!) {
        my $SELF := nqp::decont($SELF_CONT);
        $atom := nqp::decont($atom);
        $backtrack := nqp::decont($backtrack);
#line 1977 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::BacktrackModifiedAtom, '$!atom', $atom);
        nqp::bindattr($obj, RakuAST::Regex::BacktrackModifiedAtom, '$!backtrack', $backtrack);
        $obj
    
    });
    add-method(RakuAST::Regex::BacktrackModifiedAtom, 'IMPL-REGEX-QAST', [RakuAST::Regex::BacktrackModifiedAtom, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 1984 src/Raku/ast/regex.rakumod
        
        my $atom := nqp::getattr($SELF, RakuAST::Regex::BacktrackModifiedAtom, '$!atom').IMPL-REGEX-QAST($context, %mods);
        $atom.backtrack ?? $atom !! nqp::getattr($SELF, RakuAST::Regex::BacktrackModifiedAtom, '$!backtrack').IMPL-QAST-APPLY($atom, %mods)
    
    });
    add-method(RakuAST::Regex::BacktrackModifiedAtom, 'visit-children', [RakuAST::Regex::BacktrackModifiedAtom, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 1989 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::BacktrackModifiedAtom, '$!atom'));
        $visitor(nqp::getattr($SELF, RakuAST::Regex::BacktrackModifiedAtom, '$!backtrack'));
    
    });
#line 1975 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::BacktrackModifiedAtom, 'backtrack', [], anon sub backtrack ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::BacktrackModifiedAtom, '$!backtrack') });
#line 1974 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::BacktrackModifiedAtom, 'atom', [], anon sub atom ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::BacktrackModifiedAtom, '$!atom') });
    compose(RakuAST::Regex::BacktrackModifiedAtom);
    parent(RakuAST::Regex::Backtrack, RakuAST::Node);
    add-method(RakuAST::Regex::Backtrack, 'new', [RakuAST::Regex::Backtrack, '', 0, 0], anon sub new ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2005 src/Raku/ast/regex.rakumod
         $SELF 
    });
    add-method(RakuAST::Regex::Backtrack, 'IMPL-QAST-APPLY', [RakuAST::Regex::Backtrack, '', 0, 0, Mu, '$quant-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-APPLY ($SELF_CONT, $quant-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $quant-qast := nqp::decont($quant-qast);
        %mods := nqp::decont(%mods);
#line 2007 src/Raku/ast/regex.rakumod
        
        $quant-qast.backtrack('r') if %mods<r>;
        $quant-qast
    
    });
    compose(RakuAST::Regex::Backtrack);
    parent(RakuAST::Regex::Backtrack::Greedy, RakuAST::Regex::Backtrack);
    add-method(RakuAST::Regex::Backtrack::Greedy, 'IMPL-QAST-APPLY', [RakuAST::Regex::Backtrack::Greedy, '', 0, 0, Mu, '$quant-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-APPLY ($SELF_CONT, $quant-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $quant-qast := nqp::decont($quant-qast);
        %mods := nqp::decont(%mods);
#line 2015 src/Raku/ast/regex.rakumod
        
        $quant-qast.backtrack('g');
        $quant-qast
    
    });
    compose(RakuAST::Regex::Backtrack::Greedy);
    parent(RakuAST::Regex::Backtrack::Frugal, RakuAST::Regex::Backtrack);
    add-method(RakuAST::Regex::Backtrack::Frugal, 'IMPL-QAST-APPLY', [RakuAST::Regex::Backtrack::Frugal, '', 0, 0, Mu, '$quant-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-APPLY ($SELF_CONT, $quant-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $quant-qast := nqp::decont($quant-qast);
        %mods := nqp::decont(%mods);
#line 2023 src/Raku/ast/regex.rakumod
        
        $quant-qast.backtrack('f');
        $quant-qast
    
    });
    compose(RakuAST::Regex::Backtrack::Frugal);
    parent(RakuAST::Regex::Backtrack::Ratchet, RakuAST::Regex::Backtrack);
    add-method(RakuAST::Regex::Backtrack::Ratchet, 'IMPL-QAST-APPLY', [RakuAST::Regex::Backtrack::Ratchet, '', 0, 0, Mu, '$quant-qast', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-QAST-APPLY ($SELF_CONT, $quant-qast!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $quant-qast := nqp::decont($quant-qast);
        %mods := nqp::decont(%mods);
#line 2031 src/Raku/ast/regex.rakumod
        
        $quant-qast.backtrack('r');
        $quant-qast
    
    });
    compose(RakuAST::Regex::Backtrack::Ratchet);
    parent(RakuAST::Regex::WithWhitespace, RakuAST::Regex::Atom);
    add-attribute(RakuAST::Regex::WithWhitespace, RakuAST::Regex::Term, '$!regex');
    add-method(RakuAST::Regex::WithWhitespace, 'new', [RakuAST::Regex::WithWhitespace, '', 0, 0, RakuAST::Regex::Term, '$regex', 0, 0], anon sub new ($SELF_CONT, $regex!) {
        my $SELF := nqp::decont($SELF_CONT);
        $regex := nqp::decont($regex);
#line 2043 src/Raku/ast/regex.rakumod
        
        my $obj := nqp::create($SELF);
        nqp::bindattr($obj, RakuAST::Regex::WithWhitespace, '$!regex', $regex);
        $obj
    
    });
    add-method(RakuAST::Regex::WithWhitespace, 'IMPL-REGEX-QAST', [RakuAST::Regex::WithWhitespace, '', 0, 0, RakuAST::IMPL::QASTContext, '$context', 0, 0, Any, '%mods', 0, 0], anon sub IMPL-REGEX-QAST ($SELF_CONT, $context!, %mods!) {
        my $SELF := nqp::decont($SELF_CONT);
        $context := nqp::decont($context);
        %mods := nqp::decont(%mods);
#line 2049 src/Raku/ast/regex.rakumod
        
        my $qast := nqp::getattr($SELF, RakuAST::Regex::WithWhitespace, '$!regex').IMPL-REGEX-QAST($context, %mods);
        %mods<s>
          ?? QAST::Regex.new(:rxtype<concat>,
               $qast,
               QAST::Regex.new:
                 :rxtype<subrule>, :subtype<method>, :name<ws>,
                 QAST::NodeList.new(QAST::SVal.new( :value('ws') ))
             )
          !! $qast
    
    });
    add-method(RakuAST::Regex::WithWhitespace, 'visit-children', [RakuAST::Regex::WithWhitespace, '', 0, 0, Code, '$visitor', 0, 0], anon sub visit-children ($SELF_CONT, $visitor!) {
        my $SELF := nqp::decont($SELF_CONT);
        $visitor := nqp::decont($visitor);
#line 2061 src/Raku/ast/regex.rakumod
        
        $visitor(nqp::getattr($SELF, RakuAST::Regex::WithWhitespace, '$!regex'));
    
    });
    add-method(RakuAST::Regex::WithWhitespace, 'whitespace-wrappable', [RakuAST::Regex::WithWhitespace, '', 0, 0], anon sub whitespace-wrappable ($SELF_CONT) {
        my $SELF := nqp::decont($SELF_CONT);
#line 2064 src/Raku/ast/regex.rakumod
         (Bool.WHO)<False> 
    });
#line 2041 src/Raku/ast/regex.rakumod
    add-method(RakuAST::Regex::WithWhitespace, 'regex', [], anon sub regex ($self) { nqp::getattr(nqp::decont($self), RakuAST::Regex::WithWhitespace, '$!regex') });
    compose(RakuAST::Regex::WithWhitespace);
#line 1 src/Raku/ast/rakuast-epilogue.nqp
        EXPORT::DEFAULT.WHO<RakuAST> := RakuAST;
        EXPORT::DEFAULT.WHO<OperatorProperties> := OperatorProperties;
}