From 4bbe308befcfddbef5b5ca1634b524ed673449db Mon Sep 17 00:00:00 2001
From: Ben Davies <kaiepi@outlook.com>
Date: Sun, 29 Mar 2020 14:41:29 -0300
Subject: [PATCH] Make a bunch of traits around 2% faster

The performance benefits of not creating any symbols for unused named
parameters aren't huge, but they exist.
---
 lib/NativeCall.rakumod  |  6 +++---
 src/core.c/Variable.pm6 | 30 +++++++++++++++---------------
 src/core.c/traits.pm6   | 34 +++++++++++++++++-----------------
 3 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/lib/NativeCall.rakumod b/lib/NativeCall.rakumod
index 237b0843a1e..3fce004928c 100644
--- a/lib/NativeCall.rakumod
+++ b/lib/NativeCall.rakumod
@@ -669,17 +669,17 @@ multi explicitly-manage(Str $x, :$encoding = 'utf8') is export(:DEFAULT,
 role CPPConst {
     method cpp-const(--> 1) { }
 }
-multi trait_mod:<is>(Routine $p, :$cpp-const!) is export(:DEFAULT, :traits) {
+multi trait_mod:<is>(Routine $p, :cpp-const($)!) is export(:DEFAULT, :traits) {
     $p does CPPConst;
 }
-multi trait_mod:<is>(Parameter $p, :$cpp-const!) is export(:DEFAULT, :traits) {
+multi trait_mod:<is>(Parameter $p, :cpp-const($)!) is export(:DEFAULT, :traits) {
     $p does CPPConst;
 }
 
 role CPPRef {
     method cpp-ref(--> 1) { }
 }
-multi trait_mod:<is>(Parameter $p, :$cpp-ref!) is export(:DEFAULT, :traits) {
+multi trait_mod:<is>(Parameter $p, :cpp-ref($)!) is export(:DEFAULT, :traits) {
     $p does CPPRef;
 }
 
diff --git a/src/core.c/Variable.pm6 b/src/core.c/Variable.pm6
index e842a5bb06d..75224293140 100644
--- a/src/core.c/Variable.pm6
+++ b/src/core.c/Variable.pm6
@@ -136,62 +136,62 @@ multi sub trait_mod:<will>(Variable:D $v, $block, |c ) {
                     'compose'),
     );
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$begin! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :begin($)! ) {
     $block($v.var); # no need to delay execution
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$check! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :check($)! ) {
     $*W.add_phaser($v.slash, 'CHECK', $block);
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$final! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :final($)! ) {
     $v.throw( 'X::Comp::NYI',
       feature => "Variable trait 'will final {...}'",
     );
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$init! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :init($)! ) {
     $v.throw( 'X::Comp::NYI',
       feature => "Variable trait 'will init {...}'",
     );
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$end! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :end($)! ) {
     $*W.add_object($block);
     $*W.add_phaser($v.slash, 'END', $block);
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$enter! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :enter($)! ) {
     $v.block.add_phaser('ENTER', $v.willdo($block, 1) );
     $v.implicit-lexical-usage = True;
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$leave! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :leave($)! ) {
     $v.block.add_phaser('LEAVE', $v.willdo($block) );
     $v.implicit-lexical-usage = True;
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$keep! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :keep($)! ) {
     $v.block.add_phaser('KEEP', $v.willdo($block));
     $v.implicit-lexical-usage = True;
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$undo! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :undo($)! ) {
     $v.block.add_phaser('UNDO', $v.willdo($block));
     $v.implicit-lexical-usage = True;
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$first! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :first($)! ) {
     $v.block.add_phaser('FIRST', $v.willdo($block, 1));
     $v.implicit-lexical-usage = True;
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$next! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :next($)! ) {
     $v.block.add_phaser('NEXT', $block);
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$last! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :last($)! ) {
     $v.block.add_phaser('LAST', $block);
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$pre! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :pre($)! ) {
     $v.block.add_phaser('PRE', $v.willdo($block, 1));
     $v.implicit-lexical-usage = True;
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$post! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :post($)! ) {
     $v.throw( 'X::Comp::NYI',
       feature => "Variable trait 'will post {...}'",
     );
 }
-multi sub trait_mod:<will>(Variable:D $v, $block, :$compose! ) {
+multi sub trait_mod:<will>(Variable:D $v, $block, :compose($)! ) {
     $v.throw( 'X::Comp::NYI',
       feature => "Variable trait 'will compose {...}'",
     );
diff --git a/src/core.c/traits.pm6 b/src/core.c/traits.pm6
index 5b07b853ec9..126e0b3f954 100644
--- a/src/core.c/traits.pm6
+++ b/src/core.c/traits.pm6
@@ -43,12 +43,12 @@ multi sub trait_mod:<is>(Mu:U \child, Mu:U \parent, @subtypes) {
     # re-dispatch properly parameterized R#2611
     trait_mod:<is>(child,parent.^parameterize(|@subtypes))
 }
-multi sub trait_mod:<is>(Mu:U $child, :$DEPRECATED!) {
+multi sub trait_mod:<is>(Mu:U $child, :DEPRECATED($)!) {
 # add COMPOSE phaser for this child, which will add an ENTER phaser to an
 # existing "new" method, or create a "new" method with a call to DEPRECATED
 # and a nextsame.
 }
-multi sub trait_mod:<is>(Mu:U $type, :$rw!) {
+multi sub trait_mod:<is>(Mu:U $type, :rw($)!) {
     $type.^set_rw;
 }
 multi sub trait_mod:<is>(Mu:U $type, :$nativesize!) {
@@ -60,7 +60,7 @@ multi sub trait_mod:<is>(Mu:U $type, :$ctype!) {
 multi sub trait_mod:<is>(Mu:U $type, :$unsigned!) {
     $type.^set_unsigned($unsigned);
 }
-multi sub trait_mod:<is>(Mu:U $type, :$hidden!) {
+multi sub trait_mod:<is>(Mu:U $type, :hidden($)!) {
     $type.^set_hidden;
 }
 multi sub trait_mod:<is>(Mu:U $type, Mu :$array_type!) {
@@ -96,11 +96,11 @@ multi sub trait_mod:<is>(Attribute:D $attr, |c ) {
       highexpect => <rw readonly box_target leading_docs trailing_docs>,
     ).throw;
 }
-multi sub trait_mod:<is>(Attribute:D $attr, :$rw!) {
+multi sub trait_mod:<is>(Attribute:D $attr, :rw($)!) {
     $attr.set_rw();
     warn "useless use of 'is rw' on $attr.name()" unless $attr.has_accessor;
 }
-multi sub trait_mod:<is>(Attribute:D $attr, :$readonly!) {
+multi sub trait_mod:<is>(Attribute:D $attr, :readonly($)!) {
     $attr.set_readonly();
     warn "useless use of 'is readonly' on $attr.name()" unless $attr.has_accessor;
 }
@@ -114,7 +114,7 @@ multi sub trait_mod:<is>(Attribute:D $attr, Mu :$default!) {
     $attr.container_descriptor.set_default(nqp::decont($default));
     $attr.container = nqp::decont($default) if nqp::iscont($attr.container);
 }
-multi sub trait_mod:<is>(Attribute:D $attr, :$box_target!) {
+multi sub trait_mod:<is>(Attribute:D $attr, :box_target($)!) {
     $attr.set_box_target();
 }
 multi sub trait_mod:<is>(Attribute:D $attr, :$DEPRECATED!) {
@@ -154,13 +154,13 @@ multi sub trait_mod:<is>(Routine:D $r, |c ) {
           ),
         ).throw;
 }
-multi sub trait_mod:<is>(Routine:D $r, :$rw!) {
+multi sub trait_mod:<is>(Routine:D $r, :rw($)!) {
     $r.set_rw();
 }
-multi sub trait_mod:<is>(Routine:D $r, :$raw!) {
+multi sub trait_mod:<is>(Routine:D $r, :raw($)!) {
     $r.set_rw(); # for now, until we have real raw handling
 }
-multi sub trait_mod:<is>(Routine:D $r, :$default!) {
+multi sub trait_mod:<is>(Routine:D $r, :default($)!) {
     $r.^mixin: role { method default(--> True) { } }
 }
 multi sub trait_mod:<is>(Routine:D $r, :$DEPRECATED!) {
@@ -172,7 +172,7 @@ multi sub trait_mod:<is>(Routine:D $r, :$DEPRECATED!) {
 multi sub trait_mod:<is>(Routine:D $r, Mu :$inlinable!) {
     $r.set_inline_info(nqp::decont($inlinable));
 }
-multi sub trait_mod:<is>(Routine:D $r, :$onlystar!) {
+multi sub trait_mod:<is>(Routine:D $r, :onlystar($)!) {
     $r.set_onlystar();
 }
 multi sub trait_mod:<is>(Routine:D $r, :prec(%spec)!) {
@@ -241,22 +241,22 @@ multi sub trait_mod:<is>(Parameter:D $param, |c ) {
       highexpect => <rw readonly copy required raw leading_docs trailing_docs>,
     ).throw;
 }
-multi sub trait_mod:<is>(Parameter:D $param, :$readonly!) {
+multi sub trait_mod:<is>(Parameter:D $param, :readonly($)!) {
     # This is the default.
 }
-multi sub trait_mod:<is>(Parameter:D $param, :$rw!) {
+multi sub trait_mod:<is>(Parameter:D $param, :rw($)!) {
     $param.set_rw();
 }
-multi sub trait_mod:<is>(Parameter:D $param, :$copy!) {
+multi sub trait_mod:<is>(Parameter:D $param, :copy($)!) {
     $param.set_copy();
 }
-multi sub trait_mod:<is>(Parameter:D $param, :$required!) {
+multi sub trait_mod:<is>(Parameter:D $param, :required($)!) {
     $param.set_required();
 }
-multi sub trait_mod:<is>(Parameter:D $param, :$raw!) {
+multi sub trait_mod:<is>(Parameter:D $param, :raw($)!) {
     $param.set_raw();
 }
-multi sub trait_mod:<is>(Parameter:D $param, :$onearg!) {
+multi sub trait_mod:<is>(Parameter:D $param, :onearg($)!) {
     $param.set_onearg();
 }
 multi sub trait_mod:<is>(Parameter:D $param, :$leading_docs!) {
@@ -386,7 +386,7 @@ multi sub trait_mod:<is>(Routine:D $r, :$implementation-detail!) {
     $r.^mixin( role is-implementation-detail {
         method is-implementation-detail(--> True) { }
     }) if $implementation-detail;
-}   
+}
 
 multi sub trait_mod:<is>(Routine:D $r, :$hidden-from-backtrace!) {
     $r.^mixin( role is-hidden-from-backtrace {