01:29 guifa left 01:50 guifa joined
Geth rakudo: ugexe++ created pull request #6377:
RakuAST: fix BEGIN-time cloning and routine trait arguments		 02:09
02:09 guifa left
Geth rakudo: ugexe++ created pull request #6378:
RakuAST: do not curry a Whatever operand of a short-circuit operator		 03:00
rakudo: ugexe++ created pull request #6379:
RakuAST: let a module declare its own `my package EXPORT`		 04:16
rakudo: ugexe++ created pull request #6380:
RakuAST: fix a heredoc used as an attribute default		 04:51
rakudo: ugexe++ created pull request #6381:
RakuAST: give a method literal its enclosing package		 05:23
rakudo/main: def58d5a14 | (Nick Logan)++ (committed using GitHub Web editor) | 3 files
RakuAST: Join a role group declared under a setting-named package (#6355)

Declaring a parametric role more than once forms a role group across its variants. When the compound name's first part was a setting type, the second declaration failed with "Redeclaration of symbol", so a module like Hash::Sorted (`role Hash::Sorted[...]` declared twice) would not compile.
... (5 more lines)		 05:27
rakudo/main: 4aaa9164fb | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: Handle a trailing :: in an indirect package lookup (#6356)

  `$p::` designates the package that is the value of `$p`, so `$p::.WHO` is that
package's stash. Compiling it died with "No such method
  'IMPL-QAST-INDIRECT-LOOKUP-PART' for RakuAST::Name::Part::Empty", so modules
using `$pkg::.WHO` such as UML::Translators would not compile.
A trailing `::` is an empty final name part. The indirect lookup already drops a leading empty part but iterated over a trailing one, which has no lookup chunk to contribute. Drop it too, leaving the package the earlier parts resolve to.
rakudo/main: c0a95616fd | (Nick Logan)++ (committed using GitHub Web editor) | 4 files
RakuAST: Treat a parenthesized whatever `where` as a closure (#6357)

A `where (* > 0)` constraint is the same WhateverCode as `where * > 0`. The parentheses only group. The unparenthesized form is recognized as curried and used directly, but the parenthesized form was not, because
  `Circumfix::Parentheses` keeps an empty thunk chain (the CurryThunk sits on the
inner expression) and so reports `IMPL-CURRIED` false. It was then wrapped in a ... (12 more lines)
rakudo/main: 5c7ba33974 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: Join a my-scoped role group inside a package (#6358)

A `my`-scoped parametric role declared with several variants inside a package body was rejected at the second variant with `Redeclaration of symbol`. At the top level it worked.
  `install-in-scope` resolves an existing role group to join, then installs the
... (11 more lines)
rakudo/main: b36b74b090 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: Handle a pod block before an `is repr(...)` class (#6359)

A pod block before a class parses into the following `is repr('CStruct')` trait's circumfix as a leading Doc::Block statement, so the circumfix holds two statements: the doc block and the repr value. `handle-is-repr` took the first statement of the circumfix, which was then the doc block, and reported `is repr(...) trait value must be known at compile time`. ... (8 more lines)
rakudo/main: bfef7f4f2b | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: Serialize a WhateverCode role argument (#6360)

A role parameterized by a WhateverCode and punned into a class, like
  `class C does Role[* cmp * == More]`, died on load from a precompiled module:
   provided outer frame ... does not match expected static frame '<unit>'
... (12 more lines)
rakudo/main: 0f8e3a4436 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: Flatten a Slip held in a container in `for` (#6361)

A `for` over a source that sits in a container iterates it as a single item, so `my $s = slip(1, 2, 3); .say for $s` ran the body once with the whole Slip as the topic, instead of once per element. A Slip is meant to flatten even from a container.
The `iscont` branch of the `for` codegen used `map(:item)`, which keeps the value as one item. Wrapping the source with `infix:<,>` instead gives `($x,)`, which is one element for an ordinary value and the flattened elements for a Slip, matching the legacy frontend.
rakudo/main: bba915cb58 | (Nick Logan)++ | 2 files
RakuAST: Decontainerize the value of an `INIT` prefix

  `my $x = INIT $y` bound the Scalar the INIT phaser caches its result in, rather
than the value in it, so `$x` was a container and a later `$x.method` hit the Scalar instead of the value. It broke Test::Scheduler, which keeps
  `INIT $*SCHEDULER` and later calls `.cue` on it.
The phaser caches its result in a Scalar and `IMPL-EXPR-QAST` handed that Scalar straight back. Decontainerize it, so the prefix yields the value the block produced, the same as the unphased expression.		 05:30
rakudo/main: b1c717431d | (Nick Logan)++ | 3 files
RakuAST: Handle a null or BEGIN-time `INIT` value

Two edge cases in the value of an `INIT` prefix produced a raw VMNull or the phaser block instead of Mu.
An `INIT` block that bound nothing, for example one reading a variable not yet bound when INIT runs, left its cache Scalar holding a null. Reading it handed ... (7 more lines)
rakudo/main: 055e3e09e8 | (Nick Logan)++ (committed using GitHub Web editor) | 3 files
Merge pull request #6363 from ugexe/ugexe/rakuast-init-container-edge-cases

RakuAST: Fix the value of an INIT statement prefix
rakudo/main: 37d708d78a | (Nick Logan)++ | 2 files
RakuAST: declare sub-signature type captures block-local

A type capture in a sub-signature, as in `-> $p ($n, ::T) { }` or
  `sub f($p (::T :$value, |)) { }`, was never given a frame slot, so the
binder had nowhere to store the captured type and a reference to `T` in the body died with "Lexical with name 'T' does not exist in this frame". Configuration hit this in its accessor loop ... (11 more lines)
rakudo/main: f2d579140d | (Nick Logan)++ | 4 files
RakuAST: declare list-declaration type captures block-local

A type capture in a list declaration, as in `my (::T, $x) := (Int, 5)`, was never given a frame slot, so referring to `T` afterward died with
  "Lexical with name 'T' does not exist in this frame". A routine or block
surfaces its own signature's captures through PRODUCE-IMPLICIT- DECLARATIONS, but a `my (...)` declaration binds against a signature it ... (8 more lines)
rakudo/main: cac89efb35 | (Nick Logan)++ (committed using GitHub Web editor) | 4 files
Merge pull request #6365 from ugexe/ugexe/rakuast-subsig-type-capture

RakuAST: declare sub-signature and list-declaration type captures block-local
rakudo/main: 18f8e535e2 | (Nick Logan)++ | 2 files
RakuAST: keep a once's state inside a run-once phaser thunk

A `once` written directly under a phaser, as in `INIT once { ... }`, never ran its body. The phaser thunks the statement into its own block, but the once's state variable was left in the enclosing scope. The thunk call runs in a fresh frame whose state init never fires for that outer variable, so p6stateinit stayed false and the body was skipped. ... (7 more lines)
rakudo/main: 7d1927048f | (Nick Logan)++ | 4 files
RakuAST: fire a once in ENTER, LEAVE, and start bodies

A `once` in a phaser or thunk body never ran. The once's state variable lives in the enclosing scope, but the body runs in a thunk frame of its own, whose state init never fires for that outer variable, so nqp::p6stateinit stayed false and the once was skipped. An ENTER block additionally got a fresh clone on every entry, so state the block itself ... (19 more lines)
rakudo/main: 2df39f4b3c | (Nick Logan)++ (committed using GitHub Web editor) | 5 files
Merge pull request #6369 from ugexe/ugexe/rakuast-phaser-once-per-entry

RakuAST: fire a once in phaser and start bodies
10:01 [Tux] left 10:04 [Tux] joined 10:50 [Tux] left 11:08 [Tux] joined 11:27 [Tux] left 11:30 [Tux] joined 12:13 lizmat left 12:14 lizmat joined 12:38 finanalyst joined 13:03 apogee_ntv joined 13:27 librasteve_ joined
Geth rakudo/main: 0b072f218e | (Nick Logan)++ | 2 files
RakuAST: don't crash on an unrecognized `<| >` boundary assertion

Previously a `<|w>` or `<|c>` boundary assertion compiled, but any other boundary name like `<|b>` left the assertion's AST unset. The metachar assertion handler then called `to-begin-time` on that null node and the compile died with "Cannot find method 'to-begin-time' on object of type NQPMu". ... (7 more lines)		 14:39
rakudo/main: b121e53e1b | (Nick Logan)++ | 4 files
Make an unrecognized `<| >` regex boundary an error from 6.e

A `<| ... >` boundary assertion only defines two boundaries: `<|w>` (word) and `<|c>` (codepoint). Any other name like `<|b>` was silently accepted and matched the empty string. That is the odd one out among regex constructs, since an undefined named rule, an unknown metacharacter and an unknown backslash all complain. The silent no-op just hides what is almost ... (9 more lines)
rakudo/main: 7eba80c08e | (Nick Logan)++ (committed using GitHub Web editor) | 4 files
Merge pull request #6347 from ugexe/ugexe/rakuast-regex-boundary-6e-strict

Make an unrecognized `<| >` regex boundary a no-op before 6.e and an error after
rakudo/main: 9d47b03698 | (Nick Logan)++ (committed using GitHub Web editor) | 4 files
RakuAST: box the evaluated argument of pragmas, use, import, and require (#6371)

  `use lib "{$*PROGRAM.dirname}/../lib"` failed to compile with "Cannot
find method 'List' on object of type BOOTStr". The pragma evaluates its argument at BEGIN time, and an expression without a compile-time value is compiled into a thunk and called. The call returns the block's value as the VM sees it, so the interpolated string came back as an unboxed ... (10 more lines)
rakudo/main: 94fab5b3f0 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: declare a constant's anonymous variable in its own thunk (#6372)

A constant computes its value with a thunk that is compiled on its own. An anonymous variable declared in that value, such as the
  `(my uint32 $ = -1)` idiom for a native constant, had its declaration
left in the enclosing scope. The thunk then referred to storage it could not reach and compilation died with "No lexical found with name ... (6 more lines)
rakudo/main: f4da9e9183 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: leave no backtrack point after a ratchet regex (#6373)

A token or rule is ratchet, so a call to one cannot be re-entered to look for a further match. That is arranged by the regex's terminating `pass` node carrying a ratchet backtrack, which keeps the cursor from storing a restart continuation. The RakuAST frontend built that pass node without it, so every token's cursor kept a restart pointing back at the token's ... (11 more lines)
rakudo/main: 08c7d88536 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: keep an operator name's colonpair in its package lookup key (#6374)

An `our`-scoped operator variable such as `our &infix:<++> = &concat` is reached at runtime through a package lookup, while the container is bound into the package under the name's full canonical form. A name's colonpairs live on the name rather than on its parts, and the package lookup built its key from the parts alone, so the lookup asked for ... (9 more lines)
rakudo/main: 43a4df20d2 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: do not sink the result of take (#6375)

  `take` and `take-rw` stash their argument into the enclosing gather and
hand the very same value back. When such a call sits in sink context, for example as the last statement of a `for` loop body inside a gather, its result was sunk. Sinking a Seq drains and clears its iterator, so the value the gather had already stored was consumed before anything could ... (8 more lines)
rakudo/main: aa7f92eebb | (Nick Logan)++ (committed using GitHub Web editor) | 4 files
RakuAST: make a term visible within its own initializer (#6376)

A sigilless term declaration was installed only after its initializer had been parsed, so a reference to the term from inside that initializer could not resolve. A self-referential lazy binding, such as a sequence defined in terms of itself, failed to compile.
... (5 more lines)
rakudo/main: 4 commits pushed by (Nick Logan)++
rakudo/main: e6525c1db4 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: let a module declare its own `my package EXPORT` (#6379)

A module defines its export tags by declaring `my package EXPORT` and populating it. That name collides with the compunit's implicit EXPORT lexical, so RakuAST rejected it with "Redeclaration of symbol 'EXPORT'" while the legacy frontend replaced the implicit and carried on.
... (5 more lines)
rakudo/main: 74247ff71e | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: fix a heredoc used as an attribute default (#6380)

An attribute whose default is a value known at compile time takes it as the build value straight away, when the attribute is begun. A heredoc's body is not spliced in until the end of the line, after that point, so the value taken there was the placeholder (the terminator word) rather than the heredoc body. `has $.style = q:to/END/; ... END` ended up as "END".
Leave a heredoc default to the method path, which compiles the expression once the body is in place.
rakudo/main: 66e32459bf | (Nick Logan)++ (committed using GitHub Web editor) | 3 files
RakuAST: Keep -n/-p declarations in the compunit mainline (#6343)

  -n and -p wrap the program in a per-line for-loop. RakuAST built that
loop as an AST node containing the program, so the program's lexical declarations landed in the loop-body scope and were re-instantiated each line. A BEGIN-declared variable therefore did not persist, so
  `raku -ne 'BEGIN my $w = 0; $w += .words.elems; END say $w'` printed only
... (12 more lines)		 14:45
rakudo/main: 7 commits pushed by (Nick Logan)++ 14:48
15:23 finanalyst left 15:37 librasteve_ left 16:08 vrurg_ joined 16:11 vrurg left
Geth rakudo: ugexe++ created pull request #6382:
RakuAST: fix \h and \v inside a character class		 16:46
16:52 finanalyst joined 17:18 apogee_ntv left 17:22 Pixi` joined 17:25 Pixi left 17:27 Pixi joined 17:29 Pixi` left 17:41 apogee_ntv joined
Geth rakudo: ugexe++ created pull request #6383:
RakuAST: default a bare `package EXPORTHOW` to `my`		 17:53
17:54 finanalyst left 17:57 finanalyst joined
[Coke] releasable6: next 18:21
releasable6 [Coke], Next release in ≈21 days and ≈0 hours. There are no known blockers. 53 out of 86 commits logged
[Coke], Details: gist.github.com/63ef36cd3a9cd8f61b...c98ae804bc
[Coke] ... weird. it already updated in the whateverable channel.
releasable6: next
releasable6 [Coke], Next release in ≈21 days and ≈0 hours. There are no known blockers. 53 out of 86 commits logged
[Coke], Details: gist.github.com/3a9fb11b51ad89c50a...8f2ca03d82
Geth rakudo: ugexe++ created pull request #6384:
RakuAST: use the base type for a `is Type:D` container		 18:29
18:41 finanalyst left 18:42 finanalyst joined 19:00 finanalyst_ joined 19:03 finanalyst left
[Coke] releasable6: next 19:07
releasable6 [Coke], Next release in ≈20 days and ≈23 hours. There are no known blockers. 86 out of 86 commits logged
Geth rakudo/main: 7007920283 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: give a method literal its enclosing package (#6381)

An anonymous or lexical `method { }` literal, unlike a sub, left its
  `.package` unset (Mu) rather than recording the enclosing package. The
setting's `Mu.raku` decides whether a type has its own `.raku`/`.perl` by testing whether the found method's package is Mu, so a custom `.gist`/`.perl` installed with `add_method` was taken for the default one and `Mu.raku` then ... (5 more lines)		 19:08
19:08 guifa joined
rakudo/main: 30de61f06a | (Nick Logan)++ | 2 files
RakuAST: merge \h and \v into an adjacent character enumeration

A character class combining an enumerable class with literal characters, for example `<-[\v>|]>`, compiled `\v` as a separate enumcharlist from the `>|` literals. That leaves the class as two alternatives wrapped in a zerowidth-conjunction rather than a single enumcharlist, and such a class does not order correctly against another one under longest-token matching. So a ... (7 more lines)		 19:09
rakudo/main: e5f4c8afd7 | (Nick Logan)++ | 2 files
RakuAST: exclude the CR LF grapheme from \v inside a character class

On its own, \v matches the two-codepoint CR LF grapheme as well as the single vertical-space codepoints. Inside a character class it matches only the single codepoints, as the legacy frontend does with a separate enumeration for cclass_backslash:sym<v>. RakuAST used the codepoints-plus-CRLF enumeration in both places, so `<[\v]>` matched a `\r\n` grapheme where legacy did not, and
  `<[\V]>` excluded it.
Give VerticalSpace a character-class enumeration without the CR LF grapheme, leaving the standalone form as it was.
rakudo/main: 61dc84299d | (Nick Logan)++ (committed using GitHub Web editor) | 3 files
Merge pull request #6382 from ugexe/ugexe/rakuast-regex-vspace-class-crlf

RakuAST: fix \h and \v inside a character class
rakudo/main: a3f1218ff5 | (Nick Logan)++ (committed using GitHub Web editor) | 3 files
RakuAST: default a bare `package EXPORTHOW` to `my` (#6383)

A module supplies compile-time declarator overrides by declaring an EXPORTHOW package; the consumer reads it from the module's handle. A bare `package EXPORTHOW` is `our`-scoped, so it landed in GLOBAL and, on load, clashed with the setting's own EXPORTHOW ("Merging GLOBAL symbols failed: duplicate definition of symbol class"). The setting declares `my module EXPORTHOW`, and a bare one should be lexical too.
Default a bare `package EXPORTHOW` (one with no explicit scope) to `my` so it stays out of GLOBAL and no longer clashes with the setting's EXPORTHOW on load.
19:12 guifa left
Geth rakudo/main: 02b04de984 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: use the base type for a `is Type:D` container (#6384)

  `my @a is List:D = ...` names a definite type as the container base. A container
cannot be an instance of a definite type, so building one died "You cannot create an instance of this type (List:D)". The sigil-default path (a plain `my @a`) and the legacy frontend use the base type there.
Strip the definiteness in IMPL-EXPLICIT-CONTAINER-BASE-TYPE so every reader of the explicit base sees the base type, covering the `my`, `state`, and meta-object paths alike.		 19:14
19:45 finanalyst__ joined 19:47 vrurg joined 19:48 finanalyst_ left 19:50 vrurg_ left 19:54 finanalyst__ left
Geth rakudo: ugexe++ created pull request #6385:
RakuAST: key an our-scoped twigil variable's package slot by its full name		 20:33
rakudo/main: 1ec6555109 | (Nick Logan)++ | 5 files
RakuAST: key an our-scoped twigil variable's package slot by its full name

An `our @.foo` in a class installs its package slot under the full name including the twigil, `@.foo`, the same name self.name and the meta-object use. The declaration looked the slot up without the twigil, as `@foo`, so it missed the installed slot and global-fallback vivified an orphan `@foo` in GLOBAL. Pulling the class in through two paths, directly and via a module that ... (6 more lines)		 21:25
rakudo/main: dcf25cf51f | (Nick Logan)++ | 3 files
RakuAST: carry a Var::Package twigil instead of folding it into the sigil

A package-qualified `$?` variable like `$?CALLER::PACKAGE` built its Var::Package with the twigil concatenated onto the sigil, `:sigil($sigil ~ $twigil)`, so the lookup, bind and error-report paths all saw a `$?` "sigil". This is the same shape the package-slot lookup used before it gained a `:twigil`.
... (8 more lines)
rakudo/main: 9d737d4a6a | (Nick Logan)++ (committed using GitHub Web editor) | 7 files
Merge pull request #6385 from ugexe/ugexe/rakuast-our-twigil-package-key

RakuAST: key an our-scoped twigil variable's package slot by its full name
rakudo/main: 27b4e5f65c | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: do not curry a bare Whatever operand of a short-circuit operator (#6378)

  `0 // *` produced a WhateverCode rather than 0. The table that decides whether
an infix operator curries a Whatever operand had no entry for `//`, `and`, `or`,
  `andthen`, `orelse`, `notandthen`, and `xor`, so they took the default of
currying both a Whatever and a WhateverCode. A short-circuiting operator thunks an operand, so a bare Whatever standing there is a literal Whatever term for the ... (12 more lines)		 21:47
rakudo: ugexe++ created pull request #6386:
Compile the proxy readers with the Raku HLL		 22:03
rakudo: ugexe++ created pull request #6387:
RakuAST: ratchet the atom position, not the quantifier		 22:52
[Coke] changelog up to date 23:15
Geth rakudo/main: f0844d93f4 | (Nick Logan)++ (committed using GitHub Web editor) | 3 files
Compile the proxy readers with the Raku HLL (#6386)

A native call with a Proxy argument, like an element of a CArray, returned its result as a BOOT type rather than the Raku type: an int32 return came back a BOOTInt on which ordinary method calls like .defined die "No such method". The ONNX::Native test suite hits this passing a CArray[OrtSessionOptionsHandle] element to a native function and checking the returned status code. ... (26 more lines)		 23:20
rakudo: ugexe++ created pull request #6388:
Map a container-held foreign value when binding a value parameter		 23:30
rakudo/main: 7d3a0c0e3d | (Nick Logan)++ (committed using GitHub Web editor) | 2 files
RakuAST: ratchet the atom position, not the quantifier (#6387)

In a `rule`, `<foo>? <bar>` where `<foo>` can also match `<bar>`'s input failed to parse. ASN::Grammar hits this: its `optional-or-default` rule has
  `'DEFAULT' <id-string>? <value>`, and `<id-string>` also matches the FALSE that
  `<value>` needs, so a `criticality BOOLEAN DEFAULT FALSE` line no longer parsed
and the whole module returned Any. `<word>+ %% ' '` and `<word> ** {0..1}` ... (17 more lines)		 23:37
rakudo/7d3a0c0e3-but-build-rakudo-with-rakuast: da5abc5860 | (Will Coleda)++ | src/main.nqp
Introduce RAKUDO_LEGACY

Change default build to RAKUAST		 23:56
[Coke] c: 7d3a0c0e3d 3.say 23:57
committable6 [Coke], ¦7d3a0c0: «3␤»
[Coke] c: da5abc586 pi.say
committable6 [Coke], ¦da5abc5: «Cannot find this revision (did you mean “8c3ac50”?)»
[Coke] c: da5abc586 pi.say 23:59
committable6 [Coke], ¦da5abc5: «Cannot find this revision (did you mean “8c3ac50”?)»

Powered by Cro and the Raku® Programming Language.

Please report any issues / comments / feature requests as an issue on App::Raku::Log.

Thank you!