Skip to content

Instantly share code, notes, and snippets.

@Whateverable

Whateverable/query

Created January 18, 2019 12:18
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save Whateverable/0ca63181ecb8b067420aed07f21daa3a to your computer and use it in GitHub Desktop.
Save Whateverable/0ca63181ecb8b067420aed07f21daa3a to your computer and use it in GitHub Desktop.
Download ZIP
bisectable6
Raw
query
class A is Array[Str] {}
Raw
result
Bisecting: 4617 revisions left to test after this (roughly 12 steps)
[b3cd299e1ce062fd472f4bf70fa3a16d0a191a38] Throw on IO::Handle.comb/.split when in bin mode
»»»»» Testing b3cd299e1ce062fd472f4bf70fa3a16d0a191a38
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot resolve caller trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%sp…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is different
»»»»» Therefore, marking this revision as “new”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 221633ac8221aceced1e1bb08b62c2f87817ef97
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot resolve caller trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%sp…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is different
»»»»» Therefore, marking this revision as “new”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 21f0be1f3442d9ea3303c1c2a87f84d926832253
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot resolve caller trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%sp…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is different
»»»»» Therefore, marking this revision as “new”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 4ed9fa9fbc7b8037d60756a9b377f5d3a665d986
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is identical
»»»»» Therefore, marking this revision as “old”
»»»»» -------------------------------------------------------------------------
»»»»» Testing ec6c3b89c51c64a615bdeb649918fed032085c26
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is identical
»»»»» Therefore, marking this revision as “old”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 19e91e889c5112876d0ca37434d8bd2cd5d0fae7
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is identical
»»»»» Therefore, marking this revision as “old”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 41736009bf12c41ce2458d9cea42f0a40063575c
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot resolve caller trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%sp…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is different
»»»»» Therefore, marking this revision as “new”
»»»»» -------------------------------------------------------------------------
»»»»» Testing de5db8cfe6bcfae5981e6d1ada38d6cf8bea1142
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is identical
»»»»» Therefore, marking this revision as “old”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 1254bbe0904f8ebd2582aa59acaba43b36bbd44c
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is identical
»»»»» Therefore, marking this revision as “old”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 60731a0a24d4c951ef45d5e71fe6023245e7c533
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is identical
»»»»» Therefore, marking this revision as “old”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 57d66ee76aa727b7ed875c45d555c564dd569181
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is identical
»»»»» Therefore, marking this revision as “old”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 2095ed65d1858864076b1bb87d7c3cd3e8165051
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is identical
»»»»» Therefore, marking this revision as “old”
»»»»» -------------------------------------------------------------------------
»»»»» Testing 8cfa6c76ece381e900efe0839dc0495c05e3506b
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot resolve caller trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%sp…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is different
»»»»» Therefore, marking this revision as “new”
»»»»» -------------------------------------------------------------------------
»»»»» Testing b6902e5192929a733a37079d5dc414430078bc7d
»»»»» Script output:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot resolve caller trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%sp…
»»»»» (output was trimmed because it is too large)
»»»»» Script exit code: 1
»»»»» Bisecting by output
»»»»» Output on “old” revision is:
===SORRY!=== Error while compiling /tmp/gcu1o4ogBr
Cannot call trait_mod:<is>(A, Array, Array); none of these signatures match:
(Mu:U $child, Mu:U $parent)
(Mu:U $child, :$DEPRECATED!)
(Mu:U $type, :$rw!)
(Mu:U $type, :$nativesize!)
(Mu:U $type, :$ctype!)
(Mu:U $type, :$unsigned!)
(Mu:U $type, :$hidden!)
(Mu:U $type, Mu :$array_type!)
(Mu:U $type, *%fail)
(Attribute:D $attr, |c is raw)
(Attribute:D $attr, :$rw!)
(Attribute:D $attr, :$readonly!)
(Attribute $attr, :$required!)
(Attribute $attr, :$default!)
(Attribute:D $attr, :$box_target!)
(Attribute:D $attr, :$DEPRECATED!)
(Attribute:D $attr, :$leading_docs!)
(Attribute:D $attr, :$trailing_docs!)
(Routine:D $r, |c is raw)
(Routine:D $r, :$rw!)
(Routine:D $r, :$raw!)
(Routine:D $r, :$default!)
(Routine:D $r, :$DEPRECATED!)
(Routine:D $r, Mu :$inlinable!)
(Routine:D $r, :$onlystar!)
(Routine:D $r, :prec(%spec)!)
(Routine $r, :&equiv!)
(Routine $r, :&tighter!)
(Routine $r, :&looser!)
(Routine $r, :$assoc!)
(Parameter:D $param, |c is raw)
(Parameter:D $param, :$readonly!)
(Parameter:D $param, :$rw!)
(Parameter:D $param, :$copy!)
(Parameter:D $param, :$required!)
(Parameter:D $param, :$raw!)
(Parameter:D $param, :$onearg!)
(Parameter:D $param, :$leading_docs!)
(Parameter:D $param, :$trailing_docs!)
(Routine:D \r, :$export!)
(Mu:U \type, :$export!)
(Mu \sym, :$export!, :$SYMBOL!)
(Block:D $r, :$leading_docs!)
(Block:D $r, :$trailing_docs!)
(Routine:D $r, :$leading_docs!)
(Routine:D $r, :$trailing_docs!)
(Mu:U $docee, :$leading_docs!)
(Mu:U $docee, :$trailing_docs!)
(Routine:D $r, :$hidden-from-backtrace!)
(Routine:D $r, :$hidden-from-USAGE!)
(Routine:D $r, :$pure!)
(Routine:D $r, :$nodal!)
(Variable:D $v, |c is raw)
(Variable:D $v, Mu :$default!)
(Variable:D $v, :$dynamic!)
(Variable:D $v, :$export!)
(Routine $r, Str :$equiv!)
(Routine $r, Str :$tighter!)
(Routine $r, Str :$looser!)
at /tmp/gcu1o4ogBr:1
»»»»» The output is different
»»»»» Therefore, marking this revision as “new”
»»»»» -------------------------------------------------------------------------
b6902e5192929a733a37079d5dc414430078bc7d is the first new commit
commit b6902e5192929a733a37079d5dc414430078bc7d
Author: TimToady <larry@wall.org>
Date: Thu Jun 9 10:18:05 2016 -0700
s/call/resolve caller/
"Cannot call foo(Bar); none of these signatures match" is confusing insofar
as it can be taken to mean that foo(Bar) actually exists as a candidate.
Message now reads "Cannot resolve caller foo(Bar)".
:040000 040000 f8177ab71f4c38aa5cea2e12b7baf68cc8aa01c3 104fdd7380caa15c11f92c2c837d31a28915c5e1 M src
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment