>>> tree-sitter-haskell: Building testing/tree-sitter-haskell 0.23.0-r0 (using abuild 3.13.0-r5) started Fri, 06 Sep 2024 13:49:27 +0000
>>> tree-sitter-haskell: Checking sanity of /home/buildozer/aports/testing/tree-sitter-haskell/APKBUILD...
>>> tree-sitter-haskell: Analyzing dependencies...
>>> tree-sitter-haskell: Installing for build: build-base tree-sitter-dev tree-sitter-cli
(1/6) Installing oniguruma (6.9.9-r0)
(2/6) Installing jq (1.7.1-r0)
(3/6) Installing tree-sitter (0.22.2-r1)
(4/6) Installing tree-sitter-dev (0.22.2-r1)
(5/6) Installing tree-sitter-cli (0.22.5-r0)
(6/6) Installing .makedepends-tree-sitter-haskell (20240906.134929)
Executing busybox-1.36.1-r31.trigger
OK: 451 MiB in 114 packages
>>> tree-sitter-haskell: Cleaning up srcdir
>>> tree-sitter-haskell: Cleaning up pkgdir
>>> tree-sitter-haskell: Cleaning up tmpdir
>>> tree-sitter-haskell: Fetching https://distfiles.alpinelinux.org/distfiles/edge/tree-sitter-haskell-0.23.0.tar.gz
>>> tree-sitter-haskell: Fetching https://distfiles.alpinelinux.org/distfiles/edge/tree-sitter-haskell-0.23.0.tar.gz
>>> tree-sitter-haskell: Checking sha512sums...
tree-sitter-haskell-0.23.0.tar.gz: OK
>>> tree-sitter-haskell: Unpacking /var/cache/distfiles/edge/tree-sitter-haskell-0.23.0.tar.gz...
+ gcc -fPIC -Wall -I ./ '-std=c99' -Os -fstack-clash-protection -Wformat '-Werror=format-security' -c ./parser.c ./scanner.c
In file included from ./scanner.c:63:
./scanner.c: In function 'pop':
./tree_sitter/array.h:106:42: warning: value computed is not used [-Wunused-value]
  106 | #define array_pop(self) ((self)->contents[--(self)->size])
      |                         ~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
./scanner.c:971:9: note: in expansion of macro 'array_pop'
  971 |         array_pop(&env->state->contexts);
      |         ^~~~~~~~~
+ find -name '*.cc'
+ grep -q .
+ gcc -shared -Wl,--as-needed,-O1,--sort-common -Wl,-z,pack-relative-relocs -o haskell.so ./parser.o ./scanner.o
Warning: Found non-static non-tree-sitter functions in the external scannner
  `_fini`
  `_init`
Consider making these functions static, they can cause conflicts when another tree-sitter project uses the same function name
  char:
    ✓ char: [a-zA-Z0-9_]
    ✓ char: symbols
    ✓ char: special symbols
    ✓ char: character escape
    ✓ char: space
    ✓ char: escape ascii
    ✓ char: Escape Control Characters
    ✓ char: non-ascii unicode
    ✓ char: unicode whitespace
    ✓ char: magic hash
  class:
    ✓ class: minimal
    ✓ class: context variants
    ✓ class: method with context
    ✓ class: braces
    ✓ class: fixity
    ✓ class: binding list
    ✓ class: multi param
    ✓ class: default signature
    ✓ class: type variable kind
    ✓ class: associated family
    ✓ class: associated data
    ✓ class: fundeps
    ✓ class: infix operator name
    ✓ class: infix constructor operator name
    ✓ class: prefix operator name
    ✓ class: ticked name
    ✓ class: multiple type families unannotated
    ✓ class: where on new line
  comment:
    ✓ comment: line
    ✓ comment: multi
    ✓ comment: hash inside
    ✓ comment: newline termination
    ✓ comment: nested
    ✓ comment: unicode symbol
    ✓ comment: repeated minus before multiline end
    ✓ comment: double brace before nested begin
    ✓ comment: terminated by eof
    ✓ comment: end of line
    ✓ comment: escaped heralds
    ✓ comment: multiple braces
    ✓ comment: symop char after first space
    ✓ comment: haddock
  consym:
    ✓ consym: valid
    ✓ consym: error: ::
  context:
    ✓ context: smoke
    ✓ context: trivial
    ✓ context: infix constraint simple
    ✓ context: apply in left infix operand
    ✓ context: apply in both infix operands
    ✓ context: quantified
    ✓ context: apply constraint
    ✓ context: parens apply constraint
    ✓ context: type annotation
    ✓ context: constraint, then forall, then infix constraint
    ✓ context: in fun arg
    ✓ context: ctuple
    ✓ context: multi, multi line
    ✓ context: multi, single line
    ✓ context: forall/context in constraint
    ✓ context: multiple nested foralls/contexts in constraint
    ✓ context: double parenthesis
    ✓ context: annotated constraint tuple
    ✓ context: annotated quantified constraint
    ✓ context: parenthesized contexts
    ✓ context: double context, infix, apply right
    ✓ context: double context, infix, apply left
    ✓ context: double context, apply
    ✓ context: promoted varsym
    ✓ context: promoted consym
    ✓ context: splice
    ✓ context: parens around class apply constructor
    ✓ context: type application
    ✓ context: comment before arrow
    ✓ context: symbol
    ✓ context: char
    ✓ context: prime newline skip
    ✓ context: prime char false positive
    ✓ context: nonzero-indent lookahead rejection
    ✓ context: zero-indent brace context
    ✓ context: conflict between symop and context lookahead reset
    ✓ context: after deriving via
    ✓ context: left infix nesting
    ✓ context: tight infix tilde
    ✓ context: annotated infix in tuple
    ✓ context: infix in constraint context
    ✓ context: empty
  cpp:
    ✓ cpp: keep layout from first if branch
    ✓ cpp: multiline
    ✓ cpp: newline after decl in layout with one-way if
    ✓ cpp: incomplete #if/#else
    ✓ cpp: mid-line #endif
    ✓ cpp: do-let in #if
    ✓ cpp: layout ended in #else first
    ✓ cpp: lambdacase layout interrupted by #else
    ✓ cpp: #include as function body
    ✓ cpp: nested #if
    ✓ cpp: precedence over comments
    ✓ cpp: label after newline
    ✓ cpp: hash operator in brace layout
    ✓ cpp: only spaces after herald
    ✓ cpp: endif with trailing C comments
    ✓ cpp: endif at eof
    ✓ cpp: first line if
    ✓ cpp: shebang
    ✓ cpp: mid-line label after block comment
    ✓ cpp: mid-line label after newline
    ✓ cpp: after do keyword
    ✓ cpp: newline continuation
  data:
    ✓ data: empty
    ✓ data: one nullary con
    ✓ data: one unary con
    ✓ data: strict
    ✓ data: lazy
    ✓ data: tyvars
    ✓ data: unpack strict
    ✓ data: record
    ✓ data: record zero indent
    ✓ data: multiple cons
    ✓ data: deriving basic
    ✓ data: deriving empty
    ✓ data: deriving multi, strategy
    ✓ data: deriving via
    ✓ data: deriving on newline, multiple
    ✓ data: deriving with forall/context
    ✓ data: deriving prefix op
    ✓ data: deriving with annotation
    ✓ data: deriving with all features
    ✓ data: deriving empty
    ✓ data: datatype context trivial
    ✓ data: datatype context apply
    ✓ data: datatype context tuple
    ✓ data: datatype context infix basic
    ✓ data: datatype context infix parens
    ✓ data: MagicHash
    ✓ data: forall
    ✓ data: constructor context
    ✓ data: tyvar kind
    ✓ data: signature
    ✓ data: type operator varsym
    ✓ data: type operator consym
    ✓ data: type operator applied parenthesized consym 1
    ✓ data: type operator applied parenthesized consym 2
    ✓ data: type data
    ✓ data: empty record
    ✓ data: special type heads
    ✓ data: special constructors
    ✓ data: lenient trailing comma in record
    ✓ data: infix bang
    ✓ data: ticked constructor
    ✓ data: ticked context
    ✓ data: complicated field type
    ✓ data: invisible binders
    ✓ data: parens in prefix head
    ✓ data: constructor context infix parens
  decl:
    ✓ decl: two trivial successive functions
    ✓ decl: do and where
    ✓ decl: empty where
    ✓ decl: where
    ✓ decl: case and where
    ✓ decl: do, let, where
    ✓ decl: variable binding list
    ✓ decl: operator binding list
    ✓ decl: primop
    ✓ decl: ticked infix pattern
    ✓ decl: comment association
    ✓ decl: fixity
    ✓ decl: infix function with extra args
    ✓ decl: symop constructor pattern in infix varop decl
    ✓ decl: infix varop decl
    ✓ decl: error: varop in operand of infix varop decl
    ✓ decl: tuple pattern binder
    ✓ decl: con application pattern binder
    ✓ decl: parens con application pattern binder
    ✓ decl: function head with parens
    ✓ decl: implicit parameter in where
    ✓ decl: implicit parameter in do-let
    ✓ decl: function/bind ambiguity
    ✓ decl: special name
    ✓ decl: local fixity
    ✓ decl: regression test for ambiguity bug
    ✓ decl: guards
  default:
    ✓ default: default decl
  exp:
    ✓ exp: application
    ✓ exp: con application
    ✓ exp: unit
    ✓ exp: comprehension
    ✓ exp: operator section right
    ✓ exp: operator section left
    ✓ exp: left section with infix id
    ✓ exp: left section operator after newline
    ✓ exp: infix operator
    ✓ exp: infix assoc
    ✓ exp: infix con/var
    ✓ exp: error: infix TH-quoted consym
    ✓ exp: lambda simple
    ✓ exp: double lambda
    ✓ exp: lambda and infix
    ✓ exp: parenthesized infix
    ✓ exp: apply in operand of qualified varop
    ✓ exp: tuple section
    ✓ exp: conditional
    ✓ exp: implicit
    ✓ exp: let basic
    ✓ exp: lambda case simple
    ✓ exp: lambda case and infix
    ✓ exp: n-ary cases
    ✓ exp: do and let
    ✓ exp: do statement with pattern lhs
    ✓ exp: qualified do
    ✓ exp: i at eol (scanner tests for `in`)
    ✓ exp: record construction with wildcard
    ✓ exp: record update
    ✓ exp: record field pun
    ✓ exp: record zero indent update
    ✓ exp: record and minus
    ✓ exp: type application
    ✓ exp: repeated type application
    ✓ exp: type application with promoted literal
    ✓ exp: block argument: lambda basic
    ✓ exp: block argument: lambda case
    ✓ exp: block argument: do
    ✓ exp: block argument: let
    ✓ exp: block argument: case
    ✓ exp: greedy block argument: let
    ✓ exp: greedy block argument: lambda
    ✓ exp: greedy block argument: cond
    ✓ exp: empty lambda case
    ✓ exp: empty case
    ✓ exp: multi-way if
    ✓ exp: multi-way if with two matches in a guard rhs
    ✓ exp: list with multi-way if
    ✓ exp: let with sig on rhs
    ✓ exp: list con
    ✓ exp: tuple con
    ✓ exp: qualified symop
    ✓ exp: th-promoted qualified symop
    ✓ exp: negation in tuple
    ✓ exp: negation in section
    ✓ exp: unboxed tuple
    ✓ exp: unboxed unit
    ✓ exp: unboxed solo
    ✓ exp: section of unboxed tuple
    ✓ exp: unboxed sum
    ✓ exp: error: unboxed sum with missing space between bar and closing bracket
    ✓ exp: label
    ✓ exp: TransformListComp
    ✓ exp: brace layout after lambda case
    ✓ exp: unicode do bind arrow
    ✓ exp: field projection with OverloadedRecordDot
    ✓ exp: projection in infix
    ✓ exp: projection with special name
    ✓ exp: field selector from projection
    ✓ exp: OverloadedRecordUpdate
    ✓ exp: lambda with $ in list
    ✓ exp: annotation on list element
    ✓ exp: greedy block arg in arithmetic sequence
    ✓ exp: annotation on tuple element
    ✓ exp: lenient trailing comma in list
    ✓ exp: dollar infix with applications in operands
    ✓ exp: pattern guard annotation
    ✓ exp: ParallelListComp
    ✓ exp: case with multiple alternatives and matches
    ✓ exp: identifier named then#
    ✓ exp: explicit namespace for required type arguments
    ✓ exp: inline case with constructor after of
    ✓ exp: qualified constructor in apply argument
    ✓ exp: type application before infix operator
    ✓ exp: th-quoted type before infix operator
    ✓ exp: lambda after varid with prime followed by n with prime
  family:
    ✓ family: closed, nullary
    ✓ family: closed, tyvars
    ✓ family: closed, pattern matching
    ✓ family: closed, signature
    ✓ family: closed, variable kind
    ✓ family: closed, multiple equations
    ✓ family: open
    ✓ family: data family
    ✓ family: data instance adt
    ✓ family: data instance gadt
    ✓ family: data instance newtype simple
    ✓ family: data instance newtype gadt
    ✓ family: data instance newtype record
    ✓ family: injectivity annotation
    ✓ family: infix basic
    ✓ family: infix pattern mistaken as infix head
    ✓ family: kind signature in pattern
    ✓ family: kind application
    ✓ family: symbolic prefix
    ✓ family: forall before equation
    ✓ family: abstract closed family, hs-boot
    ✓ family: arrow in pattern
    ✓ family: infix asterisk
    ✓ family: closed qualified
    ✓ family: open qualified
  foreign:
    ✓ foreign: decl
  gadt:
    ✓ gadt: empty
    ✓ gadt: basic
    ✓ gadt: record
    ✓ gadt: signature
    ✓ gadt: context
    ✓ gadt: con context
    ✓ gadt: forall
    ✓ gadt: simple deriving
    ✓ gadt: deriving
    ✓ gadt: symbolic operator
    ✓ gadt: newtype
    ✓ gadt: symbolic type
    ✓ gadt: strict/lazy
    ✓ gadt: type data
    ✓ gadt: multiplicity arrow
    ✓ gadt: con list
    ✓ gadt: record with context
  id:
    ✓ id: variable
    ✓ id: constructor
    ✓ id: unicode
    ✓ id: hashes
  implicit:
    ✓ implicit: synonym plain
    ✓ implicit: synonym parens
    ✓ implicit: synonym parens kind annotation
    ✓ implicit: synonym parens constrained
    ✓ implicit: synonym parens constrained
    ✓ implicit: synonym tuple
    ✓ implicit: synonym context
    ✓ implicit: synonym forall/context in annotation
    ✓ implicit: signature with function in annotation
  import:
    ✓ import: unqualified module plain
    ✓ import: unqualified module with empty export list
    ✓ import: unqualified module with alias
    ✓ import: qualified module
    ✓ import: var only
    ✓ import: type only
    ✓ import: type with constructor
    ✓ import: type with var
    ✓ import: type with symbolic var
    ✓ import: type dotdot
    ✓ import: qualified basic
    ✓ import: qualified as
    ✓ import: prim
    ✓ import: package
    ✓ import: consym
    ✓ import: operator
    ✓ import: pattern/type
    ✓ import: trailing comma
    ✓ import: type operator with namespace
    ✓ import: namespace for type child
    ✓ import: partially typed import before the end of the block
  instance:
    ✓ instance: minimal
    ✓ instance: type
    ✓ instance: forall
    ✓ instance: context
    ✓ instance: method inline
    ✓ instance: signature
    ✓ instance: infix context
    ✓ instance: equality constraint
    ✓ instance: associated type instance
    ✓ instance: associated data instance
    ✓ instance: infix pattern lhs method
    ✓ instance: standalone deriving
    ✓ instance: deriving via
    ✓ instance: qualified class
    ✓ instance: nullary method
    ✓ instance: annotation
    ✓ instance: minus
  layout:
    ✓ layout: where on same level as case alt with nothing following
    ✓ layout: error: where on same level as case alt with following alt
    ✓ layout: where on deeper level than case alt with following alt
    ✓ layout: where with subsequent top decl
    ✓ layout: indented empty where with subsequent top decl
    ✓ layout: where after case alt in do, then immediate top level where indented equally
    ✓ layout: double where in lambda case in do
    ✓ layout: double where in lambda cases in do
    ✓ layout: where after case alt in do, then immediate toplevel where at do indent
    ✓ layout: where after case alt inline, then immediate toplevel where at case indent
    ✓ layout: where inline after do statement
    ✓ layout: do nested
    ✓ layout: do and indented where
    ✓ layout: if and indented where
    ✓ layout: do and empty line
    ✓ layout: recursive do with rec keyword
    ✓ layout: in after let on same indent
    ✓ layout: identifier named "whe" in place of valid "where" in case
    ✓ layout: identifier named "whe" in place of valid "where" as topdecl
    ✓ layout: identifier "i" should not prematurely fail the scanner due to "in" parser
    ✓ layout: empty file
    ✓ layout: indented let/in
    ✓ layout: let layout ended by in with smaller indent
    ✓ layout: let layout ended by in with larger indent
    ✓ layout: let with explicit semicolon
    ✓ layout: let with multiple explicit semicolons before and after newline
    ✓ layout: let with explicit braces
    ✓ layout: where in do-let binding
    ✓ layout: conditional with explicit semicolon
    ✓ layout: where after statement, on deeper or same indent
    ✓ layout: empty where, then indented binds after inline where
    ✓ layout: parenthesized case inline
    ✓ layout: parenthesized case newline
    ✓ layout: comment between where and decl
    ✓ layout: comment in empty where on next line indented
    ✓ layout: module in first line
    ✓ layout: empty line before module
    ✓ layout: indented module keyword, binds further left
    ✓ layout: closing exports paren in column 0
    ✓ layout: comment in column 0 before first decl in column 2
    ✓ layout: decl in line 0
    ✓ layout: module with smaller indent after nonzero indent at top level
    ✓ layout: smaller indent after nonzero indent at top level
    ✓ layout: end two layouts at the same position
    ✓ layout: case in a list terminated by bracket
    ✓ layout: case in a list terminated by comma
    ✓ layout: case in a list terminated by comprehension bar
    ✓ layout: case in an explicitly braced do terminated by brace
    ✓ layout: empty do statements with explicit braces
    ✓ layout: empty brace layout
    ✓ layout: end in tuple
    ✓ layout: do in an if block
    ✓ layout: do in an if-then block
    ✓ layout: nondecreasing indent for do in if-then
    ✓ layout: do not emit newline semicolon if the first token is "then" or "else"
    ✓ layout: infix in statement position ends layout
    ✓ layout: two lines starting with m without leading newline or module
    ✓ layout: do not end do layout with bang pattern
    ✓ layout: let/in after do
    ✓ layout: expr after newline in exp_in, with layout ended by "in" token
    ✓ layout: instance after where, triggers rule for "in" token
    ✓ layout: carriage return
    ✓ layout: error: unparenthesized multi-way if in list comprehension result
    ✓ layout: newline after record brace in pattern
    ✓ layout: signature with function arrow on new line with two chars of indent
    ✓ layout: same indent is permitted for multi-way if
    ✓ layout: close layout in guard at comma
    ✓ layout: obscure canary for pat prec bugs
    ✓ layout: bar operator in case layout in texp
    ✓ layout: unboxed texp
    ✓ layout: only end on bar if guard is not valid
    ✓ layout: closing brace before cpp else
    ✓ layout: brace layout in virtual layout ending at the same position
    ✓ layout: strict data field after newline
    ✓ layout: splice in do statement
    ✓ layout: modifier at start of line
    ✓ layout: composition dot after newline
    ✓ layout: comment before module without newline
    ✓ layout: pragma, module, import
    ✓ layout: newline, pragma, module, import
    ✓ layout: function starting with special token
    ✓ layout: case in let, single line
    ✓ layout: do in case in nested let, single line
    ✓ layout: "the" at end of file
    ✓ layout: obscure case where eof layout end happens prematurely without no_lookahead check
    ✓ layout: space at eof
    ✓ layout: braces on new line
    ✓ layout: allow any indent nested in brace layout
    ✓ layout: let guard in decl
    ✓ layout: do expr in guard
    ✓ layout: case in guard
    ✓ layout: multi-way if in guard
    ✓ layout: let guard in case
    ✓ layout: signature with arrow in let in texp
    ✓ layout: guard bar ends layout at the same indent
    ✓ layout: symop dot ends layout
    ✓ layout: symop hash ends layout
    ✓ layout: do in then branch in another do with else in indent column
    ✓ layout: explicit semicolon between topdecls
    ✓ layout: semicolon after last statement in do
    ✓ layout: do-let layout ended by indent of next statement with leading semicolon
    ✓ layout: random indent with leading semicolons in do
    ✓ layout: pragmas, cpp, then module
    ✓ layout: semicolon at beginning of file
    ✓ layout: semicolon before imports
    ✓ layout: brace layout after comment
    ✓ layout: brace layout after pragma
    ✓ layout: brace layout in first column
    ✓ layout: empty brace alternatives separated from case by comment
    ✓ layout: comment before multi-way if bar on newline
    ✓ layout: block comment at eof without newline
    ✓ layout: unicode whitespace
    ✓ layout: inline braces followed by layout semicolon
    ✓ layout: nonzero toplevel indent
    ✓ layout: comment after semicolon
    ✓ layout: comment and pragma after semicolon with following layout element
    ✓ layout: list pattern in let
    ✓ layout: instance after splice in expression splice
    ✓ layout: comment containing tab exceeding layout indent
  module:
    ✓ module: exports empty
    ✓ module: exports regular
    ✓ module: exports symbolic
    ✓ module: exports type
    ✓ module: exports pattern
    ✓ module: exports module
    ✓ module: exports qualified
    ✓ module: exports zero indent
    ✓ module: qualified
    ✓ module: export minus
    ✓ module: export dot
    ✓ module: no trailing comma
    ✓ module: namespace for type child
  newtype:
    ✓ newtype: basic
    ✓ newtype: context
    ✓ newtype: record
    ✓ newtype: tyvar kind
    ✓ newtype: deriving
    ✓ newtype: unlifted
    ✓ newtype: prefix operator
  number:
    ✓ number: decimal
    ✓ number: octal
    ✓ number: hex
    ✓ number: float
    ✓ number: binary
  pat:
    ✓ pat: basic
    ✓ pat: con simple
    ✓ pat: consym
    ✓ pat: as
    ✓ pat: wildcard
    ✓ pat: literal
    ✓ pat: record
    ✓ pat: zero indent record
    ✓ pat: strict
    ✓ pat: irrefutable
    ✓ pat: view pattern in argument patterns
    ✓ pat: view pattern in lambda
    ✓ pat: parenthesized record
    ✓ pat: guards
    ✓ pat: view pattern in record
    ✓ pat: unboxed tuple
    ✓ pat: unboxed unit
    ✓ pat: unboxed solo
    ✓ pat: unboxed sum, nullary tuple
    ✓ pat: signature
    ✓ pat: do binder signature
    ✓ pat: pattern binding signature
    ✓ pat: do binder view pattern
    ✓ pat: splice
    ✓ pat: quasiqoute
    ✓ pat: operator
    ✓ pat: negation
    ✓ pat: type binders
    ✓ pat: cond in viewpat
    ✓ pat: lambda in viewpat
    ✓ pat: complex viewpat
    ✓ pat: error: annotation in viewpat
    ✓ pat: multi viewpat
    ✓ pat: ticked infix
    ✓ pat: prefix tuple con
    ✓ pat: bang in case match
    ✓ pat: qualified infix
    ✓ pat: explicit type binder
  patsyn:
    ✓ patsyn: unidirectional simple
    ✓ patsyn: unidirectional strict
    ✓ patsyn: explicit bidirectional list
    ✓ patsyn: explicit bidirectional strict
    ✓ patsyn: explicit bidirectional record
    ✓ patsyn: explicit bidirectional guards
    ✓ patsyn: signature
    ✓ patsyn: unidirectional record
    ✓ patsyn: operator
    ✓ patsyn: ticked infix
  pragma:
    ✓ pragma: inline
    ✓ pragma: without module
    ✓ pragma: before module
    ✓ pragma: after module
    ✓ pragma: between imports
    ✓ pragma: before import inline
    ✓ pragma: instance overlap
    ✓ pragma: multiline
    ✓ pragma: no whitespace before strictness annotation
    ✓ pragma: before do statement
    ✓ pragma: instance method with cpp
    ✓ pragma: indented before decl without module
    ✓ pragma: indented after decl
    ✓ pragma: indented after module
    ✓ pragma: between decls
    ✓ pragma: followed by inline comment
    ✓ pragma: followed by block comment
    ✓ pragma: after block comment
  prec:
    ✓ prec: infix qualified varsym with leading dot(s)
    ✓ prec: infix qualified consym
    ✓ prec: varop decl with leading dot
    ✓ prec: varop exp with leading dot
    ✓ prec: varop import with leading dot
    ✓ prec: varop export with leading dot
    ✓ prec: infix varop with leading dot in list
    ✓ prec: tight infix varop with leading dot
    ✓ prec: arithmetic sequence
    ✓ prec: section with leading dot
    ✓ prec: composition basic
    ✓ prec: composition in parens
    ✓ prec: composition and qualified names
    ✓ prec: composition before parens
    ✓ prec: if block arguments with exp annotation
    ✓ prec: block argument: apply
    ✓ prec: greedy signature in pattern binder
    ✓ prec: signature with subsequent function vs. pattern binder
    ✓ prec: hash: signature lhs
    ✓ prec: hash: prefix expression
    ✓ prec: hash: right section
    ✓ prec: hash: left section
    ✓ prec: hash: unboxed expression
    ✓ prec: hash: infix
    ✓ prec: hash: prefix type
    ✓ prec: hash: unboxed type
    ✓ prec: hash: edge cases
    ✓ prec: annotation after lambda
    ✓ prec: negation in right infix operand
    ✓ prec: negation vs. infix with apply
    ✓ prec: negation in left operand of infix minus
    ✓ prec: left minus section with minus infix
    ✓ prec: eldritch horror section
    ✓ prec: qualified infix varsym with two module segments
    ✓ prec: qualified infix varsym with apply in left operand
    ✓ prec: apply in nested infix with all qualified names with two module segments
    ✓ prec: apply/infix/qualified in type
  signature:
    ✓ signature: forall
    ✓ signature: alternating forall/context/arrow/infix
    ✓ signature: partial
    ✓ signature: unicode herald
  special:
    ✓ special: GHC fixity decl for -> in GHC.Types
  string:
    ✓ string: special chars
    ✓ string: gap
    ✓ string: magic hash
  th:
    ✓ th: quasiquotes
    ✓ th: top level splice with parens
    ✓ th: inline splice variable
    ✓ th: inline splice parens
    ✓ th: inline typed splice
    ✓ th: inline splice in function application
    ✓ th: top level splice without parens
    ✓ th: comment in quote body
    ✓ th: error: comment in expression quote body ranging over closing bracket
    ✓ th: qualified quoter
    ✓ th: error: incomplete quote
    ✓ th: do block top level splice
    ✓ th: quoted expression
    ✓ th: quoted type
    ✓ th: quoted pattern
    ✓ th: quoted decls
    ✓ Close nested layouts at closing bracket in decl quote
    ✓ th: typed expression quotation
    ✓ th: quoter with prime
    ✓ th: expression quote as splice expression
    ✓ th: nested splice in type
    ✓ th: quasiquote escape
    ✓ th: top-level expression splice with negation
  type:
    ✓ type: basic
    ✓ type: two tycons
    ✓ type: promoted constructor
    ✓ type: list plain
    ✓ type: parens
    ✓ type: varsym
    ✓ type: consym
    ✓ type: list cons
    ✓ type: promoted list cons
    ✓ type: promoted list nil
    ✓ type: list literal
    ✓ type: promoted list literal
    ✓ type: qualified consym
    ✓ type: promoted consym
    ✓ type: qualified promoted consym
    ✓ type: qualified ticked
    ✓ type: promoted tuple
    ✓ type: promoted prefix tuple
    ✓ type: equality
    ✓ type: infix promoted consym after apply
    ✓ type: mixed infix
    ✓ type: multi-apply in infix
    ✓ type: symbol
    ✓ type: prefix notation symbol
    ✓ type: nullary context
    ✓ type: forall only
    ✓ type: forall context
    ✓ type: lhs parens
    ✓ type: role
    ✓ type: kind signature
    ✓ type: function with multiplicity modifier
    ✓ type: special linear arrows
    ✓ type: unboxed nullary tuple
    ✓ type: unboxed unary tuple
    ✓ type: unboxed tuple with newline after opening brace
    ✓ type: unboxed tuple with newline before closing brace
    ✓ type: unboxed sum
    ✓ type: prefix notation unboxed tuple
    ✓ type: prefix notation unboxed sum
    ✓ type: unicode arrows
    ✓ type: unicode star
    ✓ type: kind application
    ✓ type: kind signature in nested type
    ✓ type: inferred binder at column 0
    ✓ type: double signature
    ✓ type: HKT annotation
    ✓ type: splice
    ✓ type: quasiquote
    ✓ type: inferred type variable
    ✓ type: required type arguments
    ✓ type: forall without variables
  varsym:
    ✓ varsym: error: |
    ✓ varsym: error: lambda
    ✓ varsym: error: ..
    ✓ varsym: error: arrow
    ✓ varsym: error: carrow
    ✓ varsym: error: larrow
    ✓ varsym: error: @
    ✓ varsym: error: equals
    ✓ varsym: error: leading :
    ✓ varsym: comment with more than two dashes
    ✓ varsym: operator with large number of dashes
    ✓ varsym: implicit parameter
    ✓ varsym: dollar terminated by opening bracket
    ✓ varsym: unicode symbol
    ✓ varsym: single-char operator: bang
    ✓ varsym: single-char operator: hash
    ✓ varsym: single-char operator: dollar
    ✓ varsym: single-char operator: percent
    ✓ varsym: single-char operator: ampersand
    ✓ varsym: single-char operator: star
    ✓ varsym: single-char operator: asterisk
    ✓ varsym: single-char operator: plus
    ✓ varsym: single-char operator: dot
    ✓ varsym: single-char operator: slash
    ✓ varsym: single-char operator: left angle
    ✓ varsym: single-char operator: right angle
    ✓ varsym: single-char operator: question mark
    ✓ varsym: single-char operator: circumflex
    ✓ varsym: single-char operator: minus
    ✓ varsym: single-char operator: tilde
    ✓ varsym: single-char operator: colon
    ✓ varsym: operators with bar
    ✓ varsym: operators with dollar
>>> tree-sitter-haskell: Entering fakeroot...
+ install -D -m755 ./src/haskell.so -t /home/buildozer/aports/testing/tree-sitter-haskell/pkg/tree-sitter-haskell/usr/lib/tree-sitter/
+ ln -s tree-sitter/haskell.so /home/buildozer/aports/testing/tree-sitter-haskell/pkg/tree-sitter-haskell/usr/lib/libtree-sitter-haskell.so
+ '[' -d ./queries ]
+ install -D -m755 ./queries/highlights.scm ./queries/injections.scm ./queries/locals.scm -t /home/buildozer/aports/testing/tree-sitter-haskell/pkg/tree-sitter-haskell/usr/share/tree-sitter/queries/haskell/
>>> tree-sitter-haskell*: Running postcheck for tree-sitter-haskell
>>> tree-sitter-haskell*: Preparing package tree-sitter-haskell...
>>> tree-sitter-haskell*: Stripping binaries
>>> tree-sitter-haskell*: Scanning shared objects
>>> tree-sitter-haskell*: Tracing dependencies...
	so:libc.musl-aarch64.so.1
>>> tree-sitter-haskell*: Package size: 3.7 MB
>>> tree-sitter-haskell*: Compressing data...
>>> tree-sitter-haskell*: Create checksum...
>>> tree-sitter-haskell*: Create tree-sitter-haskell-0.23.0-r0.apk
>>> tree-sitter-haskell: Build complete at Fri, 06 Sep 2024 13:49:40 +0000 elapsed time 0h 0m 13s
>>> tree-sitter-haskell: Cleaning up srcdir
>>> tree-sitter-haskell: Cleaning up pkgdir
>>> tree-sitter-haskell: Uninstalling dependencies...
(1/6) Purging .makedepends-tree-sitter-haskell (20240906.134929)
(2/6) Purging tree-sitter-dev (0.22.2-r1)
(3/6) Purging jq (1.7.1-r0)
(4/6) Purging tree-sitter (0.22.2-r1)
(5/6) Purging tree-sitter-cli (0.22.5-r0)
(6/6) Purging oniguruma (6.9.9-r0)
Executing busybox-1.36.1-r31.trigger
OK: 440 MiB in 108 packages
>>> tree-sitter-haskell: Updating the testing/aarch64 repository index...
>>> tree-sitter-haskell: Signing the index...