1Scope::Upper(3) User Contributed Perl Documentation Scope::Upper(3)
2
6 Scope::Upper - Act on upper scopes.
7
9 Version 0.34
10
12 "reap", "localize", "localize_elem", "localize_delete" and "WORDS" :
13 package Scope;
15 use Scope::Upper qw<
17 reap localize localize_elem localize_delete
18 :words
19 >;
20 sub new {
22 my ($class, $name) = @_;
23 localize '$tag' => bless({ name => $name }, $class) => UP;
25 reap { print Scope->tag->name, ": end\n" } UP;
27 }
28 # Get the tag stored in the caller namespace
30 sub tag {
31 my $l = 0;
32 my $pkg = __PACKAGE__;
33 $pkg = caller $l++ while $pkg eq __PACKAGE__;
34 no strict 'refs';
36 ${$pkg . '::tag'};
37 }
38 sub name { shift->{name} }
40 # Locally capture warnings and reprint them with the name prefixed
42 sub catch {
43 localize_elem '%SIG', '__WARN__' => sub {
44 print Scope->tag->name, ': ', @_;
45 } => UP;
46 }
47 # Locally clear @INC
49 sub private {
50 for (reverse 0 .. $#INC) {
51 # First UP is the for loop, second is the sub boundary
52 localize_delete '@INC', $_ => UP UP;
53 }
54 }
55 ...
57 package UserLand;
59 {
61 Scope->new("top"); # initializes $UserLand::tag
62 {
64 Scope->catch;
65 my $one = 1 + undef; # prints "top: Use of uninitialized value..."
66 {
68 Scope->private;
69 eval { require Cwd };
70 print $@; # prints "Can't locate Cwd.pm in @INC
71 } # (@INC contains:) at..."
72 require Cwd; # loads Cwd.pm
74 }
75 } # prints "top: done"
77 "unwind" and "want_at" :
79 package Try;
81 use Scope::Upper qw<unwind want_at :words>;
83 sub try (&) {
85 my @result = shift->();
86 my $cx = SUB UP; # Point to the sub above this one
87 unwind +(want_at($cx) ? @result : scalar @result) => $cx;
88 }
89 ...
91 sub zap {
93 try {
94 my @things = qw<a b c>;
95 return @things; # returns to try() and then outside zap()
96 # not reached
97 };
98 # not reached
99 }
100 my @stuff = zap(); # @stuff contains qw<a b c>
102 my $stuff = zap(); # $stuff contains 3
103 "uplevel" :
105 package Uplevel;
107 use Scope::Upper qw<uplevel CALLER>;
109 sub target {
111 faker(@_);
112 }
113 sub faker {
115 uplevel {
116 my $sub = (caller 0)[3];
117 print "$_[0] from $sub()";
118 } @_ => CALLER(1);
119 }
120 target('hello'); # "hello from Uplevel::target()"
122 "uid" and "validate_uid" :
124 use Scope::Upper qw<uid validate_uid>;
126 my $uid;
128 {
130 $uid = uid();
131 {
132 if ($uid eq uid(UP)) { # yes
133 ...
134 }
135 if (validate_uid($uid)) { # yes
136 ...
137 }
138 }
139 }
140 if (validate_uid($uid)) { # no
142 ...
143 }
144
146 This module lets you defer actions at run-time that will take place
147 when the control flow returns into an upper scope. Currently, you can:
148 • hook an upper scope end with "reap" ;
150 • localize variables, array/hash values or deletions of elements in
152 higher contexts with respectively "localize", "localize_elem" and
153 "localize_delete" ;
154 • return values immediately to an upper level with "unwind", "yield"
156 and "leave" ;
157 • gather information about an upper context with "want_at" and
159 "context_info" ;
160 • execute a subroutine in the setting of an upper subroutine stack
162 frame with "uplevel" ;
163 • uniquely identify contexts with "uid" and "validate_uid".
165
167 In all those functions, $context refers to the target scope.
168 You have to use one or a combination of "WORDS" to build the $context
170 passed to these functions. This is needed in order to ensure that the
171 module still works when your program is ran in the debugger. The only
172 thing you can assume is that it is an absolute indicator of the frame,
173 which means that you can safely store it at some point and use it when
174 needed, and it will still denote the original scope.
175 "reap"
177 reap { ... };
178 reap { ... } $context;
179 &reap($callback, $context);
180 Adds a destructor that calls $callback (in void context) when the upper
182 scope represented by $context ends.
183 "localize"
185 localize $what, $value;
186 localize $what, $value, $context;
187 Introduces a "local" delayed to the time of first return into the upper
189 scope denoted by $context. $what can be :
190 • A glob, in which case $value can either be a glob or a reference.
192 "localize" follows then the same syntax as "local *x = $value".
193 For example, if $value is a scalar reference, then the "SCALAR"
194 slot of the glob will be set to $$value - just like "local *x = \1"
195 sets $x to 1.
196 • A string beginning with a sigil, representing the symbol to
198 localize and to assign to. If the sigil is '$', "localize" follows
199 the same syntax as "local $x = $value", i.e. $value isn't
200 dereferenced. For example,
201 localize '$x', \'foo' => HERE;
203 will set $x to a reference to the string 'foo'. Other sigils ('@',
205 '%', '&' and '*') require $value to be a reference of the
206 corresponding type.
207 When the symbol is given by a string, it is resolved when the
209 actual localization takes place and not when "localize" is called.
210 Thus, if the symbol name is not qualified, it will refer to the
211 variable in the package where the localization actually takes place
212 and not in the one where the "localize" call was compiled. For
213 example,
214 {
216 package Scope;
217 sub new { localize '$tag', $_[0] => UP }
218 }
219 {
221 package Tool;
222 {
223 Scope->new;
224 ...
225 }
226 }
227 will localize $Tool::tag and not $Scope::tag. If you want the
229 other behaviour, you just have to specify $what as a glob or a
230 qualified name.
231 Note that if $what is a string denoting a variable that wasn't
233 declared beforehand, the relevant slot will be vivified as needed
234 and won't be deleted from the glob when the localization ends.
235 This situation never arises with "local" because it only compiles
236 when the localized variable is already declared. Although I
237 believe it shouldn't be a problem as glob slots definedness is
238 pretty much an implementation detail, this behaviour may change in
239 the future if proved harmful.
240 "localize_elem"
242 localize_elem $what, $key, $value;
243 localize_elem $what, $key, $value, $context;
244 Introduces a "local $what[$key] = $value" or "local $what{$key} =
246 $value" delayed to the time of first return into the upper scope
247 denoted by $context. Unlike "localize", $what must be a string and the
248 type of localization is inferred from its sigil. The two only valid
249 types are array and hash ; for anything besides those, "localize_elem"
250 will throw an exception. $key is either an array index or a hash key,
251 depending of which kind of variable you localize.
252 If $what is a string pointing to an undeclared variable, the variable
254 will be vivified as soon as the localization occurs and emptied when it
255 ends, although it will still exist in its glob.
256 "localize_delete"
258 localize_delete $what, $key;
259 localize_delete $what, $key, $context;
260 Introduces the deletion of a variable or an array/hash element delayed
262 to the time of first return into the upper scope denoted by $context.
263 $what can be:
264 • A glob, in which case $key is ignored and the call is equivalent to
266 "local *x".
267 • A string beginning with '@' or '%', for which the call is
269 equivalent to respectively "local $a[$key]; delete $a[$key]" and
270 "local $h{$key}; delete $h{$key}".
271 • A string beginning with '&', which more or less does "undef &func"
273 in the upper scope. It's actually more powerful, as &func won't
274 even "exists" anymore. $key is ignored.
275 "unwind"
277 unwind;
278 unwind @values, $context;
279 Returns @values from the subroutine, eval or format context pointed by
281 or just above $context, and immediately restarts the program flow at
282 this point - thus effectively returning @values to an upper scope. If
283 @values is empty, then the $context parameter is optional and defaults
284 to the current context (making the call equivalent to a bare "return;")
285 ; otherwise it is mandatory.
286 The upper context isn't coerced onto @values, which is hence always
288 evaluated in list context. This means that
289 my $num = sub {
291 my @a = ('a' .. 'z');
292 unwind @a => HERE;
293 # not reached
294 }->();
295 will set $num to 'z'. You can use "want_at" to handle these cases.
297 "yield"
299 yield;
300 yield @values, $context;
301 Returns @values from the context pointed by or just above $context, and
303 immediately restarts the program flow at this point. If @values is
304 empty, then the $context parameter is optional and defaults to the
305 current context ; otherwise it is mandatory.
306 "yield" differs from "unwind" in that it can target any upper scope
308 (besides a "s///e" substitution context) and not necessarily a sub, an
309 eval or a format. Hence you can use it to return values from a "do" or
310 a "map" block :
311 my $now = do {
313 local $@;
314 eval { require Time::HiRes } or yield time() => HERE;
315 Time::HiRes::time();
316 };
317 my @uniq = map {
319 yield if $seen{$_}++; # returns the empty list from the block
320 ...
321 } @things;
322 Like for "unwind", the upper context isn't coerced onto @values. You
324 can use the fifth value returned by "context_info" to handle context
325 coercion.
326 "leave"
328 leave;
329 leave @values;
330 Immediately returns @values from the current block, whatever it may be
332 (besides a "s///e" substitution context). "leave" is actually a
333 synonym for "yield HERE", while "leave @values" is a synonym for "yield
334 @values, HERE".
335 Like for "yield", you can use the fifth value returned by
337 "context_info" to handle context coercion.
338 "want_at"
340 my $want = want_at;
341 my $want = want_at $context;
342 Like "wantarray" in perlfunc, but for the subroutine, eval or format
344 context located at or just above $context.
345 It can be used to revise the example showed in "unwind" :
347 my $num = sub {
349 my @a = ('a' .. 'z');
350 unwind +(want_at(HERE) ? @a : scalar @a) => HERE;
351 # not reached
352 }->();
353 will rightfully set $num to 26.
355 "context_info"
357 my ($package, $filename, $line, $subroutine, $hasargs,
358 $wantarray, $evaltext, $is_require, $hints, $bitmask,
359 $hinthash) = context_info $context;
360 Gives information about the context denoted by $context, akin to what
362 "caller" in perlfunc provides but not limited only to subroutine, eval
363 and format contexts. When $context is omitted, it defaults to the
364 current context.
365 The returned values are, in order :
367 • (index 0) : the namespace in use when the context was created ;
369 • (index 1) : the name of the file at the point where the context was
371 created ;
372 • (index 2) : the line number at the point where the context was
374 created ;
375 • (index 3) : the name of the subroutine called for this context, or
377 "undef" if this is not a subroutine context ;
378 • (index 4) : a boolean indicating whether a new instance of @_ was
380 set up for this context, or "undef" if this is not a subroutine
381 context ;
382 • (index 5) : the context (in the sense of "wantarray" in perlfunc)
384 in which the context (in our sense) is executed ;
385 • (index 6) : the contents of the string being compiled for this
387 context, or "undef" if this is not an eval context ;
388 • (index 7) : a boolean indicating whether this eval context was
390 created by "require", or "undef" if this is not an eval context ;
391 • (index 8) : the value of the lexical hints in use when the context
393 was created ;
394 • (index 9) : a bit string representing the warnings in use when the
396 context was created ;
397 • (index 10) : a reference to the lexical hints hash in use when the
399 context was created (only on perl 5.10 or greater).
400 "uplevel"
402 my @ret = uplevel { ...; return @ret };
403 my @ret = uplevel { my @args = @_; ...; return @ret } @args, $context;
404 my @ret = &uplevel($callback, @args, $context);
405 Executes the code reference $callback with arguments @args as if it
407 were located at the subroutine stack frame pointed by $context,
408 effectively fooling "caller" and "die" into believing that the call
409 actually happened higher in the stack. The code is executed in the
410 context of the "uplevel" call, and what it returns is returned as-is by
411 "uplevel".
412 sub target {
414 faker(@_);
415 }
416 sub faker {
418 uplevel {
419 map { 1 / $_ } @_;
420 } @_ => CALLER(1);
421 }
422 my @inverses = target(1, 2, 4); # @inverses contains (0, 0.5, 0.25)
424 my $count = target(1, 2, 4); # $count is 3
425 Note that if @args is empty, then the $context parameter is optional
427 and defaults to the current context ; otherwise it is mandatory.
428 Sub::Uplevel also implements a pure-Perl version of "uplevel". Both
430 are identical, with the following caveats :
431 • The Sub::Uplevel implementation of "uplevel" may execute a code
433 reference in the context of any upper stack frame. The
434 Scope::Upper version can only uplevel to a subroutine stack frame,
435 and will croak if you try to target an "eval" or a format.
436 • Exceptions thrown from the code called by this version of "uplevel"
438 will not be caught by "eval" blocks between the target frame and
439 the uplevel call, while they will for Sub::Uplevel's version. This
440 means that :
441 eval {
443 sub {
444 local $@;
445 eval {
446 sub {
447 uplevel { die 'wut' } CALLER(2); # for Scope::Upper
448 # uplevel(3, sub { die 'wut' }) # for Sub::Uplevel
449 }->();
450 };
451 print "inner block: $@";
452 $@ and exit;
453 }->();
454 };
455 print "outer block: $@";
456 will print "inner block: wut..." with Sub::Uplevel and "outer
458 block: wut..." with Scope::Upper.
459 • Sub::Uplevel globally overrides the Perl keyword "caller", while
461 Scope::Upper does not.
462 A simple wrapper lets you mimic the interface of "uplevel" in
464 Sub::Uplevel :
465 use Scope::Upper;
467 sub uplevel {
469 my $frame = shift;
470 my $code = shift;
471 my $cxt = Scope::Upper::CALLER($frame);
472 &Scope::Upper::uplevel($code => @_ => $cxt);
473 }
474 Albeit the three exceptions listed above, it passes all the tests of
476 Sub::Uplevel.
477 "uid"
479 my $uid = uid;
480 my $uid = uid $context;
481 Returns an unique identifier (UID) for the context (or dynamic scope)
483 pointed by $context, or for the current context if $context is omitted.
484 This UID will only be valid for the life time of the context it
485 represents, and another UID will be generated next time the same scope
486 is executed.
487 my $uid;
489 {
491 $uid = uid;
492 if ($uid eq uid()) { # yes, this is the same context
493 ...
494 }
495 {
496 if ($uid eq uid()) { # no, we are one scope below
497 ...
498 }
499 if ($uid eq uid(UP)) { # yes, UP points to the same scope as $uid
500 ...
501 }
502 }
503 }
504 # $uid is now invalid
506 {
508 if ($uid eq uid()) { # no, this is another block
509 ...
510 }
511 }
512 For example, each loop iteration gets its own UID :
514 my %uids;
516 for (1 .. 5) {
518 my $uid = uid;
519 $uids{$uid} = $_;
520 }
521 # %uids has 5 entries
523 The UIDs are not guaranteed to be numbers, so you must use the "eq"
525 operator to compare them.
526 To check whether a given UID is valid, you can use the "validate_uid"
528 function.
529 "validate_uid"
531 my $is_valid = validate_uid $uid;
532 Returns true if and only if $uid is the UID of a currently valid
534 context (that is, it designates a scope that is higher than the current
535 one in the call stack).
536 my $uid;
538 {
540 $uid = uid();
541 if (validate_uid($uid)) { # yes
542 ...
543 }
544 {
545 if (validate_uid($uid)) { # yes
546 ...
547 }
548 }
549 }
550 if (validate_uid($uid)) { # no
552 ...
553 }
554
556 "SU_THREADSAFE"
557 True iff the module could have been built when thread-safety features.
558
560 Constants
561 "TOP"
562 my $top_context = TOP;
564 Returns the context that currently represents the highest scope.
566 "HERE"
568 my $current_context = HERE;
570 The context of the current scope.
572 Getting a context from a context
574 For any of those functions, $from is expected to be a context. When
575 omitted, it defaults to the current context.
576 "UP"
578 my $upper_context = UP;
580 my $upper_context = UP $from;
581 The context of the scope just above $from. If $from points to the top-
583 level scope in the current stack, then a warning is emitted and $from
584 is returned (see "DIAGNOSTICS" for details).
585 "SUB"
587 my $sub_context = SUB;
589 my $sub_context = SUB $from;
590 The context of the closest subroutine above $from. If $from already
592 designates a subroutine context, then it is returned as-is ; hence "SUB
593 SUB == SUB". If no subroutine context is present in the call stack,
594 then a warning is emitted and the current context is returned (see
595 "DIAGNOSTICS" for details).
596 "EVAL"
598 my $eval_context = EVAL;
600 my $eval_context = EVAL $from;
601 The context of the closest eval above $from. If $from already
603 designates an eval context, then it is returned as-is ; hence "EVAL
604 EVAL == EVAL". If no eval context is present in the call stack, then a
605 warning is emitted and the current context is returned (see
606 "DIAGNOSTICS" for details).
607 Getting a context from a level
609 Here, $level should denote a number of scopes above the current one.
610 When omitted, it defaults to 0 and those functions return the same
611 context as "HERE".
612 "SCOPE"
614 my $context = SCOPE;
616 my $context = SCOPE $level;
617 The $level-th upper context, regardless of its type. If $level points
619 above the top-level scope in the current stack, then a warning is
620 emitted and the top-level context is returned (see "DIAGNOSTICS" for
621 details).
622 "CALLER"
624 my $context = CALLER;
626 my $context = CALLER $level;
627 The context of the $level-th upper subroutine/eval/format. It kind of
629 corresponds to the context represented by "caller $level", but while
630 e.g. "caller 0" refers to the caller context, "CALLER 0" will refer to
631 the top scope in the current context. If $level points above the top-
632 level scope in the current stack, then a warning is emitted and the
633 top-level context is returned (see "DIAGNOSTICS" for details).
634 Examples
636 Where "reap" fires depending on the $cxt :
637 sub {
639 eval {
640 sub {
641 {
642 reap \&cleanup => $cxt;
643 ...
644 } # $cxt = SCOPE(0) = HERE
645 ...
646 }->(); # $cxt = SCOPE(1) = UP = SUB = CALLER(0)
647 ...
648 }; # $cxt = SCOPE(2) = UP UP = UP SUB = EVAL = CALLER(1)
649 ...
650 }->(); # $cxt = SCOPE(3) = SUB UP SUB = SUB EVAL = CALLER(2)
651 ...
652 Where "localize", "localize_elem" and "localize_delete" act depending
654 on the $cxt :
655 sub {
657 eval {
658 sub {
659 {
660 localize '$x' => 1 => $cxt;
661 # $cxt = SCOPE(0) = HERE
662 ...
663 }
664 # $cxt = SCOPE(1) = UP = SUB = CALLER(0)
665 ...
666 }->();
667 # $cxt = SCOPE(2) = UP UP = UP SUB = EVAL = CALLER(1)
668 ...
669 };
670 # $cxt = SCOPE(3) = SUB UP SUB = SUB EVAL = CALLER(2)
671 ...
672 }->();
673 # $cxt = SCOPE(4), UP SUB UP SUB = UP SUB EVAL = UP CALLER(2) = TOP
674 ...
675 Where "unwind", "yield", "want_at", "context_info" and "uplevel" point
677 to depending on the $cxt:
678 sub {
680 eval {
681 sub {
682 {
683 unwind @things => $cxt; # or yield @things => $cxt
684 # or uplevel { ... } $cxt
685 ...
686 }
687 ...
688 }->(); # $cxt = SCOPE(0) = SCOPE(1) = HERE = UP = SUB = CALLER(0)
689 ...
690 }; # $cxt = SCOPE(2) = UP UP = UP SUB = EVAL = CALLER(1) (*)
691 ...
692 }->(); # $cxt = SCOPE(3) = SUB UP SUB = SUB EVAL = CALLER(2)
693 ...
694 # (*) Note that uplevel() will croak if you pass that scope frame,
696 # because it cannot target eval scopes.
697
699 "Cannot target a scope outside of the current stack"
700 This warning is emitted when "UP", "SCOPE" or "CALLER" end up pointing
701 to a context that is above the top-level context of the current stack.
702 It indicates that you tried to go higher than the main scope, or to
703 point across a "DESTROY" method, a signal handler, an overloaded or
704 tied method call, a "require" statement or a "sort" callback. In this
705 case, the resulting context is the highest reachable one.
706 "No targetable %s scope in the current stack"
708 This warning is emitted when you ask for an "EVAL" or "SUB" context and
709 no such scope can be found in the call stack. The resulting context is
710 the current one.
711
713 The functions "reap", "localize", "localize_elem", "localize_delete",
714 "unwind", "yield", "leave", "want_at", "context_info" and "uplevel" are
715 only exported on request, either individually or by the tags ':funcs'
716 and ':all'.
717 The constant "SU_THREADSAFE" is also only exported on request,
719 individually or by the tags ':consts' and ':all'.
720 Same goes for the words "TOP", "HERE", "UP", "SUB", "EVAL", "SCOPE" and
722 "CALLER" that are only exported on request, individually or by the tags
723 ':words' and ':all'.
724
726 It is not possible to act upon a scope that belongs to another perl
727 'stack', i.e. to target a scope across a "DESTROY" method, a signal
728 handler, an overloaded or tied method call, a "require" statement or a
729 "sort" callback.
730 Be careful that local variables are restored in the reverse order in
732 which they were localized. Consider those examples:
733 local $x = 0;
735 {
736 reap sub { print $x } => HERE;
737 local $x = 1;
738 ...
739 }
740 # prints '0'
741 ...
742 {
743 local $x = 1;
744 reap sub { $x = 2 } => HERE;
745 ...
746 }
747 # $x is 0
748 The first case is "solved" by moving the "local" before the "reap", and
750 the second by using "localize" instead of "reap".
751 The effects of "reap", "localize" and "localize_elem" can't cross
753 "BEGIN" blocks, hence calling those functions in "import" is deemed to
754 be useless. This is an hopeless case because "BEGIN" blocks are
755 executed once while localizing constructs should do their job at each
756 run. However, it's possible to hook the end of the current scope
757 compilation with B::Hooks::EndOfScope.
758 Some rare oddities may still happen when running inside the debugger.
760 It may help to use a perl higher than 5.8.9 or 5.10.0, as they contain
761 some context-related fixes.
762 Calling "goto" to replace an "uplevel"'d code frame does not work :
764 • for a "perl" older than the 5.8 series ;
766 • for a "DEBUGGING" "perl" run with debugging flags set (as in "perl
768 -D ...") ;
769 • when the runloop callback is replaced by another module.
771 In those three cases, "uplevel" will look for a "goto &sub" statement
773 in its callback and, if there is one, throw an exception before
774 executing the code.
775 Moreover, in order to handle "goto" statements properly, "uplevel"
777 currently has to suffer a run-time overhead proportional to the size of
778 the callback in every case (with a small ratio), and proportional to
779 the size of all the code executed as the result of the "uplevel" call
780 (including subroutine calls inside the callback) when a "goto"
781 statement is found in the "uplevel" callback. Despite this
782 shortcoming, this XS version of "uplevel" should still run way faster
783 than the pure-Perl version from Sub::Uplevel.
784 Starting from "perl" 5.19.4, it is unfortunately no longer possible to
786 reliably throw exceptions from "uplevel"'d code while the debugger is
787 in use. This may be solved in a future version depending on how the
788 core evolves.
789
791 perl 5.6.1.
792 A C compiler. This module may happen to build with a C++ compiler as
794 well, but don't rely on it, as no guarantee is made in this regard.
795 XSLoader (core since perl 5.6.0).
797
799 "local" in perlfunc, "Temporary Values via local()" in perlsub.
800 Alias, Hook::Scope, Scope::Guard, Guard.
802 Sub::Uplevel.
804 Continuation::Escape is a thin wrapper around Scope::Upper that gives
806 you a continuation passing style interface to "unwind". It's easier to
807 use, but it requires you to have control over the scope where you want
808 to return.
809 Scope::Escape.
811
813 Vincent Pit "<vpit at cpan.org>".
814 You can contact me by mail or on "irc.perl.org" (vincent).
816
818 Please report any bugs or feature requests to "bug-scope-upper at
819 rt.cpan.org", or through the web interface at
820 <http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Scope-Upper>. I will
821 be notified, and then you'll automatically be notified of progress on
822 your bug as I make changes.
823
825 You can find documentation for this module with the perldoc command.
826 perldoc Scope::Upper
828
830 Inspired by Ricardo Signes.
831 The reimplementation of a large part of this module for perl 5.24 was
833 provided by David Mitchell. His work was sponsored by the Perl 5 Core
834 Maintenance Grant from The Perl Foundation.
835 Thanks to Shawn M. Moore for motivation.
837
839 Copyright
840 2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2021,2023
841 Vincent Pit, all rights reserved.
842 This program is free software; you can redistribute it and/or modify it
844 under the same terms as Perl itself.
845perl v5.36.0 2023-03-27 Scope::Upper(3)