chore: remove format-queries script

 The source of truth for formatting (according to make formatquery and
 CI) is now ts_query_ls, so remove the no longer required script to
 prevent divergence and bitrotting.

2 files changed, 1 insertions, 468 deletions

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1d05a42cd..c4ec8e192 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -105,7 +105,7 @@ you can mark the language as optional (by putting it between parenthesis).
 
 #### Formatting
 
-All queries are expected to follow a standard format, with every node on a single line and indented by two spaces for each level of nesting. You can automatically format the bundled queries by running the provided formatter `./scripts/format-queries.lua` on a single file (ending in `.scm`) or directory to format.
+All queries are expected to follow a standard format, with every node on a single line and indented by two spaces for each level of nesting. You can automatically format the bundled queries by running `make formatquery`.
 
 Should you need to preserve a specific format for a node, you can exempt it (and all contained nodes) by placing before it
 ```query
diff --git a/scripts/format-queries.lua b/scripts/format-queries.lua
deleted file mode 100755
index bc2cf70ce..000000000
--- a/scripts/format-queries.lua
+++ /dev/null
@@ -1,467 +0,0 @@
-#!/usr/bin/env -S nvim -l
-
-local ts = vim.treesitter
-local get_node_text = ts.get_node_text
-
----@type string[]
-local files
-
-local arg = _G.arg[1] or '.'
-if arg:match('.*%.scm$') then
-  files = { arg }
-else
-  files = vim.fn.split(vim.fn.glob(arg .. '/**/*.scm'))
-end
-
-ts.query.add_predicate('kind-eq?', function(match, _, _, pred)
-  local nodes = match[pred[2]]
-  local types = { unpack(pred, 3) }
-
-  if not nodes or #nodes == 0 then
-    return true
-  end
-
-  for _, node in pairs(nodes) do
-    if not vim.tbl_contains(types, node:type()) then
-      return false
-    end
-  end
-  return true
-end, {
-  force = true,
-  all = true,
-})
-
-ts.query.add_predicate('is-start-of-line?', function(match, _, _, pred)
-  local nodes = match[pred[2]]
-  if not nodes or #nodes == 0 then
-    return true
-  end
-  for _, node in pairs(nodes) do
-    local start_row, start_col = node:start()
-    if vim.fn.indent(start_row + 1) ~= start_col then
-      return false
-    end
-  end
-  return true
-end, {
-  force = true,
-  all = true,
-})
-
---- Control the indent here. Change to \t if uses tab instead
-local indent_str = '  '
-local indent_width_plus_one = 3
-local textwidth = 100
-
--- Query to control the formatter
-local format_queries = [[
-;;query
-;; Ignore next node with `; format-ignore`
-(
-  (comment) @_pattern
-  .
-  (_) @format.ignore
-  (#lua-match? @_pattern "^;+%s*format%-ignore"))
-
-;; {{{
-;; Add newlines to top level nodes
-;; {{{
-;; Preserve inline comments
-(program
-  . (_)
-  (comment) @format.prepend-newline
-  (#is-start-of-line? @format.prepend-newline))
-(program
-  . (_)
-  (comment) @_comment
-  .
-  (comment) @format.prepend-newline
-  (#not-is-start-of-line? @_comment)
-  (#is-start-of-line? @format.prepend-newline))
-; Extra newline for modelines
-(program
-  (comment) @_modeline
-  .
-  (_) @format.prepend-newline
-  (#is-start-of-line? @_modeline)
-  (#contains? @_modeline "^;+%s*inherits:"))
-(program
-  (comment) @_modeline
-  .
-  (_) @format.prepend-newline
-  (#is-start-of-line? @_modeline)
-  (#contains? @_modeline "^;+%s*extends%s*$"))
-;; }}}
-;; Making sure all top-level patterns are separated
-(program
-  (_) @format.append-newline)
-(program
-  (_) @format.cancel-append .)
-(program
-  . (_)
-  [
-    (list)
-    (grouping)
-    (named_node)
-    (anonymous_node)
-    (missing_node)
-    (field_definition)
-  ] @format.prepend-newline)
-
-(program
-  (comment) @_comment
-  .
-  [
-    (list)
-    (grouping)
-    (named_node)
-    (anonymous_node)
-    (missing_node)
-    (field_definition)
-    (comment)
-  ] @format.cancel-prepend
-  (#is-start-of-line? @_comment)
-  (#not-lua-match? @_comment "^;+%s*inherits:")
-  (#not-lua-match? @_comment "^;+%s*extends%s*$"))
-;; }}}
-
-;; delims
-[
-  ":"
-  "."
-] @format.append-space
-(predicate
-  "." @format.cancel-append @format.replace
-  (#gsub! @format.replace "%." "#"))
-(
-  "." @format.prepend-space @format.cancel-append
-  .
-  ")")
-
-;; List handler
-;; Only starts indent if 2 or more elements
-(list
-  "[" @format.indent.begin
-  "]" @format.indent.dedent)
-;; Otherwise, remove brackets
-(list
-  "[" @format.remove @format.cancel-append
-  .
-  (_) @format.cancel-append
-  .
-  "]" @format.remove)
-;; [ ... ] @capture1 @capture2
-;; Append newlines for nodes inside the list
-(list
-  (_) @format.append-newline
-  (#not-kind-eq? @format.append-newline "capture" "quantifier"))
-
-;; (_), "_" and _ handler
-;; Start indents if it's one of these patterns
-(named_node
-  [
-    "_"
-    name: (identifier)
-  ] @format.indent.begin
-  .
-  [
-    (list)              ; (foo [...])
-    (grouping)          ; (foo ((foo)))
-    (negated_field)     ; (foo !field)
-    (field_definition)  ; (foo field: (...))
-    (named_node)        ; (foo (bar))
-    (predicate)         ; (named_node (#set!))
-    (anonymous_node)
-    (missing_node)
-    "."
-  ])
-;; Honoring comment's position within a node
-(named_node
-  [
-    "_"
-    name: (identifier)
-  ] @format.indent.begin
-  .
-  (comment) @_comment
-  (#is-start-of-line? @_comment))
-(named_node
-  [
-    "_"
-    name: (identifier)
-  ] @format.indent.begin @format.cancel-append
-  .
-  "."? @format.prepend-newline
-  .
-  (comment) @format.prepend-space
-  (#not-is-start-of-line? @format.prepend-space))
-
-;; Add newlines for other nodes, in case the top node is indented
-(named_node
-  [
-    (list)
-    (grouping)
-    (negated_field)
-    (field_definition)
-    (named_node)
-    (predicate)
-    (anonymous_node)
-    (missing_node)
-    "."
-  ] @format.append-newline)
-
-;; Collapse closing parentheses
-(named_node
-  [
-    "_"
-    name: (identifier)
-    (_)
-  ] @format.cancel-append
-  .
-  ")"
-  (#not-kind-eq? @format.cancel-append "comment"))
-
-;; All captures should be separated with a space
-(capture) @format.prepend-space
-
-; ( (_) ) handler
-(grouping
-  "("
-  .
-  [
-    (named_node)                  ; ((foo))
-    (list)                        ; ([foo] (...))
-    (anonymous_node)              ; ("foo")
-    (missing_node)
-    (grouping . (_))
-  ] @format.indent.begin
-  .
-  (_))
-(grouping
-  "("
-  .
-  (grouping) @format.indent.begin
-  (predicate))
-(grouping
-  "("
-  [
-    (anonymous_node)
-    (missing_node)
-    (named_node)
-    (list)
-    (predicate)
-    (grouping . (_))
-    (field_definition)
-    "."
-  ] @format.append-newline
-  (_) .)
-;; Collapsing closing parens
-(grouping
-  (_) @format.cancel-append . ")"
-  (#not-kind-eq? @format.cancel-append "comment"))
-(grouping
-  (capture) @format.prepend-space)
-(missing_node
-  name: (_) @format.prepend-space)
-;; Remove unnecessary parens
-(grouping
-  "(" @format.remove
-  .
-  (_)
-  .
-  ")" @format.remove .)
-(grouping
-  "(" @format.remove
-  .
-  [
-    (grouping)
-    (anonymous_node
-      name: (string) .)
-    (missing_node
-      name: (_) .)
-    (named_node
-      [
-        "_"
-        name: (identifier)
-      ] .)
-  ]
-  .
-  ")" @format.remove
-  .
-  (capture))
-
-; Separate this query to avoid capture duplication
-(predicate
-  "(" @format.indent.begin @format.cancel-append)
-(predicate
-  (parameters
-    (comment) @format.prepend-newline
-    .
-    (_) @format.cancel-prepend)
-  (#is-start-of-line? @format.prepend-newline))
-(predicate
-  (parameters
-    (_) @format.prepend-space)
-  (#set! conditional-newline))
-(predicate
-  (parameters
-    .
-    (capture)
-    . (_) @format.prepend-space)
-  (#set! lookahead-newline)
-  (#set! conditional-newline))
-
-;; Comment related handlers
-(comment) @format.append-newline
-;; comment styling. Feel free to change in the future
-((comment) @format.replace
-  (#gsub! @format.replace "^;+(%s*.-)%s*$" ";%1"))
-;; Preserve end of line comments
-(
-  [
-    "."
-    ":"
-    (list)
-    (grouping)
-    (named_node)
-    (anonymous_node)
-    (missing_node)
-    (negated_field)
-  ] @format.cancel-append
-  .
-  (quantifier)?
-  .
-  "."? @format.prepend-newline ; Make sure anchor are not eol but start of newline
-  .
-  (comment) @format.prepend-space
-  (#not-is-start-of-line? @format.prepend-space))
-]]
-
----@param lines string[]
----@param lines_to_append string[]
-local function append_lines(lines, lines_to_append)
-  for i = 1, #lines_to_append, 1 do
-    lines[#lines] = lines[#lines] .. lines_to_append[i]
-    if i ~= #lines_to_append then
-      lines[#lines + 1] = ''
-    end
-  end
-end
-
----@param bufnr integer
----@param node TSNode
----@param lines string[]
----@param q table<string, table[]>
----@param level integer
-local function iter(bufnr, node, lines, q, level)
-  --- Sometimes 2 queries apply append twice. This is to prevent the case from happening
-  local apply_newline = false
-  for child, _ in node:iter_children() do
-    local id = child:id()
-    if apply_newline then
-      apply_newline = false
-      lines[#lines + 1] = string.rep(indent_str, level)
-    end
-    if q['format.ignore'][id] then
-      local text =
-        vim.split(get_node_text(child, bufnr):gsub('\r\n?', '\n'), '\n', { trimempty = true })
-      append_lines(lines, text)
-    elseif not q['format.remove'][id] then
-      if not q['format.cancel-prepend'][id] then
-        if q['format.prepend-newline'][id] then
-          lines[#lines + 1] = string.rep(indent_str, level)
-        elseif q['format.prepend-space'][id] then
-          if not q['format.prepend-space'][id]['conditional-newline'] then
-            lines[#lines] = lines[#lines] .. ' '
-          elseif child:byte_length() + 1 + #lines[#lines] > textwidth then
-            lines[#lines + 1] = string.rep(indent_str, level)
-          else
-            -- Do a rough guess of the actual byte length. If it's larger than `columns` then add a newline first
-            -- column - byte_end + byte_start
-            local _, _, byte_start = child:start()
-            local _, _, byte_end = node:end_()
-            if
-              q['format.prepend-space'][id]['lookahead-newline']
-              and (byte_end - byte_start) + #lines[#lines] > textwidth
-            then
-              lines[#lines + 1] = string.rep(indent_str, level)
-            else
-              lines[#lines] = lines[#lines] .. ' '
-            end
-          end
-        end
-      end
-      if q['format.replace'][id] then
-        append_lines(lines, vim.split(q['format.replace'][id].text, '\n', { trimempty = true }))
-      elseif
-        child:named_child_count() == 0
-        -- Workaround to preserve string content
-        or child:type() == 'string'
-      then
-        append_lines(
-          lines,
-          vim.split(
-            string.gsub(get_node_text(child, bufnr), '\r\n?', '\n'),
-            '\n+',
-            { trimempty = true }
-          )
-        )
-      else
-        iter(bufnr, child, lines, q, level)
-      end
-      if q['format.indent.begin'][id] then
-        level = level + 1
-        apply_newline = true
-      elseif q['format.indent.dedent'][id] then
-        lines[#lines] = string.sub(lines[#lines], indent_width_plus_one)
-      end
-    end
-    if q['format.cancel-append'][id] then
-      apply_newline = false
-    elseif q['format.append-newline'][id] then
-      apply_newline = true
-    elseif q['format.append-space'][id] then
-      lines[#lines] = lines[#lines] .. ' '
-    end
-  end
-end
-
----@param bufnr integer
----@param queries string
-local function format(bufnr, queries)
-  local lines = { '' }
-  ---@type table<string,table<string,table>>
-  local map = {
-    ['format.ignore'] = {}, -- Ignore the node and its children
-    ['format.indent.begin'] = {}, -- +1 shiftwidth for all nodes after this
-    ['format.indent.dedent'] = {}, -- -1 shiftwidth for this line only
-    ['format.prepend-space'] = {}, -- Prepend a space before inserting the node
-    ['format.prepend-newline'] = {}, -- Prepend a \n before inserting the node
-    ['format.append-space'] = {}, -- Append a space after inserting the node
-    ['format.append-newline'] = {}, -- Append a newline after inserting the node
-    ['format.cancel-append'] = {}, -- Cancel any `@format.append-*` applied to the node
-    ['format.cancel-prepend'] = {}, -- Cancel any `@format.prepend-*` applied to the node
-    ['format.replace'] = {}, -- Dedicated capture used to store results of `(#gsub!)`
-    ['format.remove'] = {}, -- Do not add the syntax node to the result, i.e. brackets [], parens ()
-  }
-  local root = ts.get_parser(bufnr, 'query'):parse(true)[1]:root()
-  local query = ts.query.parse('query', queries)
-  for id, node, metadata in query:iter_captures(root, bufnr, nil, nil, { match_limit = 1024 }) do
-    if query.captures[id]:sub(1, 1) ~= '_' then
-      map[query.captures[id]][node:id()] = metadata and (metadata[id] and metadata[id] or metadata)
-        or {}
-    end
-  end
-
-  iter(bufnr, root, lines, map, 0)
-  vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
-end
-
-for _, file in ipairs(files) do
-  local buf = vim.fn.bufadd(file)
-  vim.fn.bufload(file)
-  vim.api.nvim_set_current_buf(buf)
-  format(buf, format_queries)
-end
-
-vim.cmd('silent wa!')