PageRenderTime 70ms CodeModel.GetById 30ms RepoModel.GetById 0ms app.codeStats 1ms

/emacs.d/elpa/dumb-jump-20220524.2122/dumb-jump.el

https://github.com/mbezjak/dotfiles
Emacs Lisp | 1073 lines | 782 code | 204 blank | 87 comment | 20 complexity | f98fc3de8e5a8c9ad2bef2af51e61a58 MD5 | raw file
    

  1. ;;; dumb-jump.el --- Jump to definition for 50+ languages without configuration -*- lexical-binding: t; -*-
    2. 

  2. ;; Copyright (C) 2015-2021 jack angers
    3. 

  3. ;; Author: jack angers and contributors
    4. 

  4. ;; Url: https://github.com/jacktasia/dumb-jump
    5. 

  5. ;; Package-Version: 20220524.2122
    6. 

  6. ;; Package-Commit: 1dd583011f4025b1b8c75fd785691851b6c5dfa3
    7. 

  7. ;; Version: 0.5.4
    8. 

  8. ;; Package-Requires: ((emacs "24.3") (s "1.11.0") (dash "2.9.0") (popup "0.5.3"))
    9. 

  9. ;; Keywords: programming
    10. 

  10. 

  11. ;; Dumb Jump is free software; you can redistribute it and/or modify it
    12. 

  12. ;; under the terms of the GNU General Public License as published by
    13. 

  13. ;; the Free Software Foundation; either version 3, or (at your option)
    14. 

  14. ;; any later version.
    15. 

  15. ;;
    16. 

  16. ;; Dumb Jump is distributed in the hope that it will be useful, but WITHOUT
    17. 

  17. ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
    18. 

  18. ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
    19. 

  19. ;; License for more details.
    20. 

  20. ;;
    21. 

  21. ;; You should have received a copy of the GNU General Public License
    22. 

  22. ;; along with Dumb Jump.  If not, see http://www.gnu.org/licenses.
    23. 

  23. 

  24. ;;; Commentary:
    25. 

  25. 

  26. ;; Dumb Jump is an Emacs "jump to definition" package with support for 50+ programming languages that favors
    27. 

  27. ;; "just working" over speed or accuracy.  This means minimal -- and ideally zero -- configuration with absolutely
    28. 

  28. ;; no stored indexes (TAGS) or persistent background processes.
    29. 

  29. ;;
    30. 

  30. ;; Dumb Jump provides a xref-based interface for jumping to
    31. 

  31. ;; definitions. It is based on tools such as grep, the silver searcher
    32. 

  32. ;; (https://geoff.greer.fm/ag/), ripgrep
    33. 

  33. ;; (https://github.com/BurntSushi/ripgrep) or git-grep
    34. 

  34. ;; (https://git-scm.com/docs/git-grep).
    35. 

  35. ;;
    36. 

  36. ;; To enable Dumb Jump, add the following to your initialisation file:
    37. 

  37. ;;
    38. 

  38. ;;    (add-hook 'xref-backend-functions #'dumb-jump-xref-activate)
    39. 

  39. ;;
    40. 

  40. ;; Now pressing M-. on an identifier should open a buffer at the place
    41. 

  41. ;; where it is defined, or a list of candidates if uncertain. This
    42. 

  42. ;; list can be navigated using M-g M-n (next-error) and M-g M-p
    43. 

  43. ;; (previous-error).
    44. 

  44. 

  45. ;;; Code:
    46. 

  46. (unless (require 'xref nil :noerror)
    47. 

  47.   (require 'etags))
    48. 

  48. (require 's)
    49. 

  49. (require 'dash)
    50. 

  50. (require 'popup)
    51. 

  51. (require 'cl-generic nil :noerror)
    52. 

  52. (require 'cl-lib)
    53. 

    54. 

  54. (defgroup dumb-jump nil
    55. 

  55.   "Easily jump to project function and variable definitions"
    56. 

  56.   :group 'tools
    57. 

  57.   :group 'convenience)
    58. 

    59. 

  59. ;;;###autoload
    60. 

  60. (defvar dumb-jump-mode-map
    61. 

  61.   (let ((map (make-sparse-keymap)))
    62. 

  62.     (define-key map (kbd "C-M-g") 'dumb-jump-go)
    63. 

  63.     (define-key map (kbd "C-M-p") 'dumb-jump-back)
    64. 

  64.     (define-key map (kbd "C-M-q") 'dumb-jump-quick-look)
    65. 

  65.     map))
    66. 

  66. 

  67. (defcustom dumb-jump-window
    68. 

  68.   'current
    69. 

  69.   "Which window to use when jumping.  Valid options are 'current (default) or 'other."
    70. 

  70.   :group 'dumb-jump
    71. 

  71.   :type '(choice (const :tag "Current window" current)
    72. 

  72.                  (const :tag "Other window" other)))
    73. 

  73. 

  74. (defcustom dumb-jump-use-visible-window
    75. 

  75.   t
    76. 

  76.   "When true will jump in a visible window if that window already has the file open."
    77. 

  77.   :group 'dumb-jump
    78. 

  78.   :type 'boolean)
    79. 

    80. 

  80. (defcustom dumb-jump-selector
    81. 

  81.   'popup
    82. 

  82.   "Which selector to use when there is multiple choices.  `ivy` and `helm' are also supported."
    83. 

  83.   :group 'dumb-jump
    84. 

  84.   :type '(choice (const :tag "Popup" popup)
    85. 

  85.                  (const :tag "Helm" helm)
    86. 

  86.                  (const :tag "Ivy" ivy)
    87. 

  87.                  (const :tag "Completing Read" completing-read)))
    88. 

  88. 

  89. (defcustom dumb-jump-ivy-jump-to-selected-function
    90. 

  90.   #'dumb-jump-ivy-jump-to-selected
    91. 

  91.   "Prompts user for a choice using ivy then dumb-jump to that choice."
    92. 

  92.   :group 'dumb-jump
    93. 

  93.   :type 'function)
    94. 

    95. 

  95. (defcustom dumb-jump-prefer-searcher
    96. 

  96.   nil
    97. 

  97.   "The preferred searcher to use 'ag, 'rg, 'git-grep, 'gnu-grep,or 'grep.
    98. 

  98. If nil then the most optimal searcher will be chosen at runtime."
    99. 

  99.   :group 'dumb-jump
    100. 

  100.   :type '(choice (const :tag "Best Available" nil)
    101. 

  101.                  (const :tag "ag" ag)
    102. 

  102.                  (const :tag "rg" rg)
    103. 

  103.                  (const :tag "grep" gnu-grep)
    104. 

  104.                  (const :tag "git grep" git-grep)
    105. 

  105.                  (const :tag "git grep + ag" git-grep-plus-ag)))
    106. 

  106. 

  107. (defcustom dumb-jump-force-searcher
    108. 

  108.   nil
    109. 

  109.   "Forcibly use searcher: 'ag, 'rg, 'git-grep, 'gnu-grep, or 'grep.
    110. 

  110. Set to nil to not force anything and use `dumb-jump-prefer-searcher'
    111. 

  111. or most optimal searcher."
    112. 

  112.   :group 'dumb-jump
    113. 

  113.   :type '(choice (const :tag "Best Available" nil)
    114. 

  114.                  (const :tag "ag" ag)
    115. 

  115.                  (const :tag "rg" rg)
    116. 

  116.                  (const :tag "grep" gnu-grep)
    117. 

  117.                  (const :tag "git grep" git-grep)
    118. 

  118.                  (const :tag "git grep + ag" git-grep-plus-ag)))
    119. 

    120. 

  120. (defcustom dumb-jump-grep-prefix
    121. 

  121.   "LANG=C"
    122. 

  122.   "Prefix to grep command.  Seemingly makes it faster for pure text."
    123. 

  123.   :group 'dumb-jump
    124. 

  124.   :type 'string)
    125. 

    126. 

  126. (defcustom dumb-jump-grep-cmd
    127. 

  127.   "grep"
    128. 

  128.   "The path to grep.  By default assumes it is in path."
    129. 

  129.   :group 'dumb-jump
    130. 

  130.   :type 'string)
    131. 

    132. 

  132. (defcustom dumb-jump-ag-cmd
    133. 

  133.   "ag"
    134. 

  134.   "The the path to the silver searcher.  By default assumes it is in path.  If not found fallbacks to grep."
    135. 

  135.   :group 'dumb-jump
    136. 

  136.   :type 'string)
    137. 

    138. 

  138. (defcustom dumb-jump-rg-cmd
    139. 

  139.   "rg"
    140. 

  140.   "The the path to ripgrep.  By default assumes it is in path.  If not found fallbacks to grep."
    141. 

  141.   :group 'dumb-jump
    142. 

  142.   :type 'string)
    143. 

    144. 

  144. (defcustom dumb-jump-git-grep-cmd
    145. 

  145.   "git grep"
    146. 

  146.   "The the path to git grep.  By default assumes it is in path.  If not found fallbacks to grep."
    147. 

  147.   :group 'dumb-jump
    148. 

  148.   :type 'string)
    149. 

    150. 

  150. (defcustom dumb-jump-ag-word-boundary
    151. 

  151.   "(?![a-zA-Z0-9\\?\\*-])"
    152. 

  152.   "`\\b` thinks `-` is a word boundary.  When this matters use `\\j` instead and ag will use this value."
    153. 

  153.   :group 'dumb-jump
    154. 

  154.   :type 'string)
    155. 

    156. 

  156. (defcustom dumb-jump-rg-word-boundary
    157. 

  157.   "($|[^a-zA-Z0-9\\?\\*-])"
    158. 

  158.   "`\\b` thinks `-` is a word boundary.  When this matters use `\\j` instead and rg will use this value."
    159. 

  159.   :group 'dumb-jump
    160. 

  160.   :type 'string)
    161. 

    162. 

  162. (defcustom dumb-jump-git-grep-word-boundary
    163. 

  163.   "($|[^a-zA-Z0-9\\?\\*-])"
    164. 

  164.   "`\\b` thinks `-` is a word boundary.  When this matters use `\\j` instead and git grep will use this value."
    165. 

  165.   :group 'dumb-jump
    166. 

  166.   :type 'string)
    167. 

    168. 

  168. (defcustom dumb-jump-grep-word-boundary
    169. 

  169.   "($|[^a-zA-Z0-9\\?\\*-])"
    170. 

  170.   "`\\b` thinks `-` is a word boundary.  When this matters use `\\j` instead and grep will use this value."
    171. 

  171.   :group 'dumb-jump
    172. 

  172.   :type 'string)
    173. 

    174. 

  174. (defcustom dumb-jump-fallback-regex
    175. 

  175.   "\\bJJJ\\j"
    176. 

  176.   "When dumb-jump-fallback-search is t use this regex.  Defaults to boundary search of symbol under point."
    177. 

  177.   :group 'dumb-jump
    178. 

  178.   :type 'string)
    179. 

    180. 

  180. (defcustom dumb-jump-fallback-search
    181. 

  181.   t
    182. 

  182.   "If nothing is found with normal search fallback to searching the fallback regex."
    183. 

  183.   :group 'dumb-jump
    184. 

  184.   :type 'boolean)
    185. 

    186. 

  186. (defcustom dumb-jump-force-grep
    187. 

  187.   nil
    188. 

  188.   "When t will use grep even if ag is available."
    189. 

  189.   :group 'dumb-jump
    190. 

  190.   :type 'boolean)
    191. 

    192. 

  192. (defcustom dumb-jump-zgrep-cmd
    193. 

  193.   "zgrep"
    194. 

  194.   "The path to grep to use for gzipped files.  By default assumes it is in path."
    195. 

  195.   :group 'dumb-jump
    196. 

  196.   :type 'string)
    197. 

    198. 

  198. (defcustom dumb-jump-grep-args "-REn"
    199. 

  199.   "Grep command args [R]ecursive, [E]xtended regexes, and show line [n]umbers."
    200. 

  200.   :group 'dumb-jump
    201. 

  201.   :type 'string)
    202. 

    203. 

  203. (defcustom dumb-jump-gnu-grep-args "-rEn"
    204. 

  204.   "Grep command args [r]ecursive and [E]xtended regexes, and show line [n]umbers."
    205. 

  205.   :group 'dumb-jump
    206. 

  206.   :type 'string)
    207. 

    208. 

  208. (defcustom dumb-jump-max-find-time
    209. 

  209.   2
    210. 

  210.   "Number of seconds a grep/find command can take before being warned to use ag and config."
    211. 

  211.   :group 'dumb-jump
    212. 

  212.   :type 'integer)
    213. 

    214. 

  214. (defcustom dumb-jump-functions-only
    215. 

  215.   nil
    216. 

  216.   "Should we only jump to functions?"
    217. 

  217.   :group 'dumb-jump
    218. 

  218.   :type 'boolean)
    219. 

    220. 

  220. (defcustom dumb-jump-quiet
    221. 

  221.   nil
    222. 

  222.   "If non-nil Dumb Jump will not log anything to *Messages*."
    223. 

  223.   :group 'dumb-jump
    224. 

  224.   :type 'boolean)
    225. 

    226. 

  226. (defcustom dumb-jump-ignore-context
    227. 

  227.   nil
    228. 

  228.   "If non-nil Dumb Jump will ignore the context of point when jumping."
    229. 

  229.   :group 'dumb-jump
    230. 

  230.   :type 'boolean)
    231. 

    232. 

  232. (defcustom dumb-jump-git-grep-search-untracked
    233. 

  233.   t
    234. 

  234.   "If non-nil Dumb Jump will also search untracked files when using searcher git-grep."
    235. 

  235.   :group 'dumb-jump
    236. 

  236.   :type 'boolean)
    237. 

    238. 

  238. (defcustom dumb-jump-git-grep-search-args
    239. 

  239.   ""
    240. 

  240.   "Appends the passed arguments to the git-grep search function. Default: \"\""
    241. 

  241.   :group 'dumb-jump
    242. 

  242.   :type 'string)
    243. 

    244. 

  244. (defcustom dumb-jump-ag-search-args
    245. 

  245.   ""
    246. 

  246.   "Appends the passed arguments to the ag search function. Default: \"\""
    247. 

  247.   :group 'dumb-jump
    248. 

  248.   :type 'string)
    249. 

    250. 

  250. (defcustom dumb-jump-rg-search-args
    251. 

  251.   "--pcre2"
    252. 

  252.   "Appends the passed arguments to the rg search function. Default: \"--pcre2\""
    253. 

  253.   :group 'dumb-jump
    254. 

  254.   :type 'string)
    255. 

    256. 

    257. 

  257. (defcustom dumb-jump-find-rules
    258. 

  258.   '((:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "elisp"
    259. 

  259.            :regex "\\\((defun|cl-defun)\\s+JJJ\\j"
    260. 

  260.            ;; \\j usage see `dumb-jump-ag-word-boundary`
    261. 

  261.            :tests ("(defun test (blah)" "(defun test\n" "(cl-defun test (blah)" "(cl-defun test\n")
    262. 

  262.            :not ("(defun test-asdf (blah)" "(defun test-blah\n" "(cl-defun test-asdf (blah)"
    263. 

  263.                  "(cl-defun test-blah\n"  "(defun tester (blah)" "(defun test? (blah)" "(defun test- (blah)"))
    264. 

    265. 

  265.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "elisp"
    266. 

  266.            :regex "\\\(defvar\\b\\s*JJJ\\j"
    267. 

  267.            :tests ("(defvar test " "(defvar test\n")
    268. 

  268.            :not ("(defvar tester" "(defvar test?" "(defvar test-"))
    269. 

    270. 

  270.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "elisp"
    271. 

  271.            :regex "\\\(defcustom\\b\\s*JJJ\\j"
    272. 

  272.            :tests ("(defcustom test " "(defcustom test\n")
    273. 

  273.            :not ("(defcustom tester" "(defcustom test?" "(defcustom test-"))
    274. 

    275. 

  275.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "elisp"
    276. 

  276.            :regex "\\\(setq\\b\\s*JJJ\\j" :tests ("(setq test 123)")
    277. 

  277.            :not ("setq test-blah 123)" "(setq tester" "(setq test?" "(setq test-"))
    278. 

    279. 

  279.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "elisp"
    280. 

  280.            :regex "\\\(JJJ\\s+" :tests ("(let ((test 123)))") :not ("(let ((test-2 123)))"))
    281. 

    282. 

  282.     ;; variable in method signature
    283. 

  283.     (:type "variable" :supports ("ag" "rg" "git-grep") :language "elisp"
    284. 

  284.            :regex "\\((defun|cl-defun)\\s*.+\\\(?\\s*JJJ\\j\\s*\\\)?"
    285. 

  285.            :tests ("(defun blah (test)" "(defun blah (test blah)" "(defun (blah test)")
    286. 

  286.            :not ("(defun blah (test-1)" "(defun blah (test-2 blah)" "(defun (blah test-3)"))
    287. 

    288. 

  288.     ;; common lisp
    289. 

  289.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "commonlisp"
    290. 

  290.            :regex "\\\(defun\\s+JJJ\\j"
    291. 

  291.            ;; \\j usage see `dumb-jump-ag-word-boundary`
    292. 

  292.            :tests ("(defun test (blah)" "(defun test\n")
    293. 

  293.            :not ("(defun test-asdf (blah)" "(defun test-blah\n"
    294. 

  294.                  "(defun tester (blah)" "(defun test? (blah)" "(defun test- (blah)"))
    295. 

    296. 

  296.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "commonlisp"
    297. 

  297.            :regex "\\\(defparameter\\b\\s*JJJ\\j"
    298. 

  298.            :tests ("(defparameter test " "(defparameter test\n")
    299. 

  299.            :not ("(defparameter tester" "(defparameter test?" "(defparameter test-"))
    300. 

    301. 

  301.     ;; racket
    302. 

  302.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "racket"
    303. 

  303.            :regex "\\\(define\\s+\\(\\s*JJJ\\j"
    304. 

  304.            :tests ("(define (test blah)" "(define (test\n")
    305. 

  305.            :not ("(define test blah" "(define (test-asdf blah)" "(define test (lambda (blah"))
    306. 

    307. 

  307.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "racket"
    308. 

  308.            :regex "\\\(define\\s+JJJ\\s*\\\(\\s*lambda"
    309. 

  309.            :tests ("(define test (lambda (blah" "(define test (lambda\n")
    310. 

  310.            :not ("(define test blah" "(define test-asdf (lambda (blah)" "(define (test)" "(define (test blah) (lambda (foo"))
    311. 

    312. 

  312.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "racket"
    313. 

  313.            :regex "\\\(let\\s+JJJ\\s*(\\\(|\\\[)*"
    314. 

  314.            :tests ("(let test ((blah foo) (bar bas))" "(let test\n" "(let test [(foo")
    315. 

  315.            :not ("(let ((test blah"))
    316. 

    317. 

  317.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "racket"
    318. 

  318.            :regex "\\\(define\\s+JJJ\\j"
    319. 

  319.            :tests ("(define test " "(define test\n")
    320. 

  320.            :not ("(define (test"))
    321. 

    322. 

  322.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "racket"
    323. 

  323.            :regex "(\\\(|\\\[)\\s*JJJ\\s+"
    324. 

  324.            :tests ("(let ((test 'foo" "(let [(test 'foo" "(let [(test 'foo" "(let [[test 'foo" "(let ((blah 'foo) (test 'bar)")
    325. 

  325.            :not ("{test foo"))
    326. 

    327. 

  327.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "racket"
    328. 

  328.            :regex "\\\(lambda\\s+\\\(?[^\(\)]*\\s*JJJ\\j\\s*\\\)?"
    329. 

  329.            :tests ("(lambda (test)" "(lambda (foo test)" "(lambda test (foo)")
    330. 

  330.            :not ("(lambda () test"))
    331. 

    332. 

  332.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "racket"
    333. 

  333.            :regex "\\\(define\\s+\\\([^\(\)]+\\s*JJJ\\j\\s*\\\)?"
    334. 

  334.            :tests ("(define (foo test)" "(define (foo test bar)")
    335. 

  335.            :not ("(define foo test" "(define (test foo" "(define (test)"))
    336. 

    337. 

  337.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "racket"
    338. 

  338.            :regex "\\(struct\\s+JJJ\\j"
    339. 

  339.            :tests ("(struct test (a b)"))
    340. 

    341. 

  341.     ;; scheme
    342. 

  342.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "scheme"
    343. 

  343.            :regex "\\\(define\\s+\\(\\s*JJJ\\j"
    344. 

  344.            :tests ("(define (test blah)" "(define (test\n")
    345. 

  345.            :not ("(define test blah" "(define (test-asdf blah)" "(define test (lambda (blah"))
    346. 

    347. 

  347.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "scheme"
    348. 

  348.            :regex "\\\(define\\s+JJJ\\s*\\\(\\s*lambda"
    349. 

  349.            :tests ("(define test (lambda (blah" "(define test (lambda\n")
    350. 

  350.            :not ("(define test blah" "(define test-asdf (lambda (blah)" "(define (test)" "(define (test blah) (lambda (foo"))
    351. 

    352. 

  352.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "scheme"
    353. 

  353.            :regex "\\\(let\\s+JJJ\\s*(\\\(|\\\[)*"
    354. 

  354.            :tests ("(let test ((blah foo) (bar bas))" "(let test\n" "(let test [(foo")
    355. 

  355.            :not ("(let ((test blah"))
    356. 

    357. 

  357.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "scheme"
    358. 

  358.            :regex "\\\(define\\s+JJJ\\j"
    359. 

  359.            :tests ("(define test " "(define test\n")
    360. 

  360.            :not ("(define (test"))
    361. 

    362. 

  362.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "scheme"
    363. 

  363.            :regex "(\\\(|\\\[)\\s*JJJ\\s+"
    364. 

  364.            :tests ("(let ((test 'foo" "(let [(test 'foo" "(let [(test 'foo" "(let [[test 'foo" "(let ((blah 'foo) (test 'bar)")
    365. 

  365.            :not ("{test foo"))
    366. 

    367. 

  367.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "scheme"
    368. 

  368.            :regex "\\\(lambda\\s+\\\(?[^\(\)]*\\s*JJJ\\j\\s*\\\)?"
    369. 

  369.            :tests ("(lambda (test)" "(lambda (foo test)" "(lambda test (foo)")
    370. 

  370.            :not ("(lambda () test"))
    371. 

    372. 

  372.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "scheme"
    373. 

  373.            :regex "\\\(define\\s+\\\([^\(\)]+\\s*JJJ\\j\\s*\\\)?"
    374. 

  374.            :tests ("(define (foo test)" "(define (foo test bar)")
    375. 

  375.            :not ("(define foo test" "(define (test foo" "(define (test)"))
    376. 

    377. 

  377.     ;; c++
    378. 

  378.     (:type "function" :supports ("ag" "rg" "git-grep") :language "c++"
    379. 

  379.            :regex "\\bJJJ(\\s|\\))*\\((\\w|[,&*.<>:]|\\s)*(\\))\\s*(const|->|\\{|$)|typedef\\s+(\\w|[(*]|\\s)+JJJ(\\)|\\s)*\\("
    380. 

  380.            :tests ("int test(){" "my_struct (*test)(int a, int b){" "auto MyClass::test ( Builder::Builder& reference, ) -> decltype( builder.func() ) {" "int test( int *random_argument) const {" "test::test() {" "typedef int (*test)(int);")
    381. 

  381.            :not ("return test();)" "int test(a, b);" "if( test() ) {" "else test();"))
    382. 

    383. 

  383.     ;; (:type "variable" :supports ("grep") :language "c++"
    384. 

  384.     ;;        :regex "(\\b\\w+|[,>])([*&]|\\s)+JJJ\\s*(\\[([0-9]|\\s)*\\])*\\s*([=,){;]|:\\s*[0-9])|#define\\s+JJJ\\b"
    385. 

  385.     ;;        :tests ("int test=2;" "char *test;" "int x = 1, test = 2" "int test[20];" "#define test" "unsigned int test:2;"))
    386. 

    387. 

  387.     (:type "variable" :supports ("ag" "rg") :language "c++"
    388. 

  388.            :regex "\\b(?!(class\\b|struct\\b|return\\b|else\\b|delete\\b))(\\w+|[,>])([*&]|\\s)+JJJ\\s*(\\[(\\d|\\s)*\\])*\\s*([=,(){;]|:\\s*\\d)|#define\\s+JJJ\\b"
    389. 

  389.            :tests ("int test=2;" "char *test;" "int x = 1, test = 2" "int test[20];" "#define test" "typedef int test;" "unsigned int test:2")
    390. 

  390.            :not ("return test;" "#define NOT test" "else test=2;"))
    391. 

    392. 

  392.     (:type "type" :supports ("ag" "rg" "git-grep") :language "c++"
    393. 

  393.            :regex "\\b(class|struct|enum|union)\\b\\s*JJJ\\b\\s*(final\\s*)?(:((\\s*\\w+\\s*::)*\\s*\\w*\\s*<?(\\s*\\w+\\s*::)*\\w+>?\\s*,*)+)?((\\{|$))|}\\s*JJJ\\b\\s*;"
    394. 

  394.            :tests ("typedef struct test {" "enum test {" "} test;" "union test {" "class test final: public Parent1, private Parent2{" "class test : public std::vector<int> {")
    395. 

  395.            :not("union test var;" "struct test function() {"))
    396. 

    397. 

  397.     ;; clojure
    398. 

  398.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    399. 

  399.            :regex "\\(def\\s+JJJ\\j"
    400. 

  400.            :tests ("(def test (foo)"))
    401. 

    402. 

  402.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    403. 

  403.            :regex "\\(defn-?\\s+JJJ\\j"
    404. 

  404.            :tests ("(defn test [foo]" "(defn- test [foo]")
    405. 

  405.            :not ("(defn test? [foo]" "(defn- test? [foo]"))
    406. 

    407. 

  407.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    408. 

  408.            :regex "\\(defmacro\\s+JJJ\\j"
    409. 

  409.            :tests ("(defmacro test [foo]"))
    410. 

    411. 

  411.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    412. 

  412.            :regex "\\(deftask\\s+JJJ\\j"
    413. 

  413.            :tests ("(deftask test [foo]"))
    414. 

    415. 

  415.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    416. 

  416.            :regex "\\(deftype\\s+JJJ\\j"
    417. 

  417.            :tests ("(deftype test [foo]"))
    418. 

    419. 

  419.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    420. 

  420.            :regex "\\(defmulti\\s+JJJ\\j"
    421. 

  421.            :tests ("(defmulti test fn"))
    422. 

    423. 

  423.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    424. 

  424.            :regex "\\(defmethod\\s+JJJ\\j"
    425. 

  425.            :tests ("(defmethod test type"))
    426. 

    427. 

  427.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    428. 

  428.            :regex "\\(definterface\\s+JJJ\\j"
    429. 

  429.            :tests ("(definterface test (foo)"))
    430. 

    431. 

  431.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    432. 

  432.            :regex "\\(defprotocol\\s+JJJ\\j"
    433. 

  433.            :tests ("(defprotocol test (foo)"))
    434. 

    435. 

  435.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "clojure"
    436. 

  436.            :regex "\\(defrecord\\s+JJJ\\j"
    437. 

  437.            :tests ("(defrecord test [foo]"))
    438. 

    439. 

  439.     ;; coffeescript
    440. 

  440.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "coffeescript"
    441. 

  441.            :regex "^\\s*JJJ\\s*[=:].*[-=]>"
    442. 

  442.            :tests ("test = ()  =>" "test= =>" "test = ->" "test=()->"
    443. 

  443.                    "test : ()  =>" "test: =>" "test : ->" "test:()->")
    444. 

  444.            :not ("# test = =>" "test = 1"))
    445. 

    446. 

  446.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "coffeescript"
    447. 

  447.            :regex "^\\s*JJJ\\s*[:=][^:=-][^>]+$"
    448. 

  448.            :tests ("test = $" "test : [" "test = {" "test = a")
    449. 

  449.            :not ("test::a" "test: =>" "test == 1" "# test = 1"))
    450. 

    451. 

  451.     (:type "class" :supports ("ag" "grep" "rg" "git-grep") :language "coffeescript"
    452. 

  452.            :regex "^\\s*\\bclass\\s+JJJ"
    453. 

  453.            :tests ("class test" "class test extends")
    454. 

  454.            :not ("# class"))
    455. 

    456. 

  456.     ;; obj-c
    457. 

  457.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "objc"
    458. 

  458.            :regex "\\\)\\s*JJJ(:|\\b|\\s)"
    459. 

  459.            :tests ("- (void)test" "- (void)test:(UIAlertView *)alertView")
    460. 

  460.            :not ("- (void)testnot" "- (void)testnot:(UIAlertView *)alertView"))
    461. 

    462. 

  462.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "objc"
    463. 

  463.            :regex "\\b\\*?JJJ\\s*=[^=\\n]+"
    464. 

  464.            :tests ("NSString *test = @\"asdf\"")
    465. 

  465.            :not ("NSString *testnot = @\"asdf\"" "NSString *nottest = @\"asdf\""))
    466. 

    467. 

  467.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "objc"
    468. 

  468.            :regex "(@interface|@protocol|@implementation)\\b\\s*JJJ\\b\\s*"
    469. 

  469.            :tests ("@interface test: UIWindow")
    470. 

  470.            :not ("@interface testnon: UIWindow"))
    471. 

    472. 

    473. 

  473.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "objc"
    474. 

  474.            :regex "typedef\\b\\s+(NS_OPTIONS|NS_ENUM)\\b\\([^,]+?,\\s*JJJ\\b\\s*"
    475. 

  475.            :tests ("typedef NS_ENUM(NSUInteger, test)")
    476. 

  476.            :not ("typedef NS_ENUMD(NSUInteger, test)"))
    477. 

    478. 

  478.     ;; swift
    479. 

  479.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "swift"
    480. 

  480.            :regex "(let|var)\\s*JJJ\\s*(=|:)[^=:\\n]+"
    481. 

  481.            :tests ("let test = 1234" "var test = 1234" "private lazy var test: UITapGestureRecognizer")
    482. 

  482.            :not ("if test == 1234:"))
    483. 

    484. 

  484.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "swift"
    485. 

  485.            :regex "func\\s+JJJ\\b\\s*(<[^>]*>)?\\s*\\("
    486. 

  486.            :tests ("func test(asdf)" "func test()" "func test<Value: Protocol>()")
    487. 

  487.            :not ("func testnot(asdf)" "func testnot()"))
    488. 

    489. 

  489.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "swift"
    490. 

  490.            :regex "(class|struct|protocol|enum)\\s+JJJ\\b\\s*?"
    491. 

  491.            :tests ("struct test" "struct test: Codable" "struct test<Value: Codable>"
    492. 

  492.                    "class test:" "class test: UIWindow" "class test<Value: Codable>")
    493. 

  493.            :not ("class testnot:" "class testnot(object):" "struct testnot(object)"))
    494. 

    495. 

  495.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "swift"
    496. 

  496.            :regex "(typealias)\\s+JJJ\\b\\s*?="
    497. 

  497.            :tests ("typealias test =")
    498. 

  498.            :not ("typealias testnot"))
    499. 

    500. 

  500.     ;; c#
    501. 

  501.     (:type "function" :supports ("ag" "rg") :language "csharp"
    502. 

  502.            :regex "^\\s*(?:[\\w\\[\\]]+\\s+){1,3}JJJ\\s*\\\("
    503. 

  503.            :tests ("int test()" "int test(param)" "static int test()" "static int test(param)"
    504. 

  504.                    "public static MyType test()" "private virtual SomeType test(param)" "static int test()")
    505. 

  505.            :not ("test()" "testnot()" "blah = new test()"))
    506. 

    507. 

  507.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "csharp"
    508. 

  508.            :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" :tests ("int test = 1234") :not ("if test == 1234:" "int nottest = 44"))
    509. 

    510. 

  510.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "csharp"
    511. 

  511.            :regex "(class|interface)\\s*JJJ\\b"
    512. 

  512.            :tests ("class test:" "public class test : IReadableChannel, I")
    513. 

  513.            :not ("class testnot:" "public class testnot : IReadableChannel, I"))
    514. 

    515. 

  515.     ;; java (literally the same regexes as c#, but different tests)
    516. 

  516.     (:type "function" :supports ("ag" "rg") :language "java"
    517. 

  517.            :regex "^\\s*(?:[\\w\\[\\]]+\\s+){1,3}JJJ\\s*\\\("
    518. 

  518.            :tests ("int test()" "int test(param)" "static int test()" "static int test(param)"
    519. 

  519.                    "public static MyType test()" "private virtual SomeType test(param)" "static int test()"
    520. 

  520.                    "private foo[] test()")
    521. 

  521.            :not ("test()" "testnot()" "blah = new test()" "foo bar = test()"))
    522. 

    523. 

  523.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "java"
    524. 

  524.            :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" :tests ("int test = 1234") :not ("if test == 1234:" "int nottest = 44"))
    525. 

    526. 

  526.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "java"
    527. 

  527.            :regex "(class|interface)\\s*JJJ\\b"
    528. 

  528.            :tests ("class test:" "public class test implements Something")
    529. 

  529.            :not ("class testnot:" "public class testnot implements Something"))
    530. 

    531. 

  531.     ;; vala (again just like c#, exactly the same..)
    532. 

  532.     (:type "function" :supports ("ag" "rg") :language "vala"
    533. 

  533.            :regex "^\\s*(?:[\\w\\[\\]]+\\s+){1,3}JJJ\\s*\\\("
    534. 

  534.            :tests ("int test()" "int test(param)" "static int test()" "static int test(param)"
    535. 

  535.                    "public static MyType test()" "private virtual SomeType test(param)" "static int test()")
    536. 

  536.            :not ("test()" "testnot()" "blah = new test()"))
    537. 

    538. 

  538.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "vala"
    539. 

  539.            :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" :tests ("int test = 1234") :not ("if test == 1234:" "int nottest = 44"))
    540. 

    541. 

  541.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "vala"
    542. 

  542.            :regex "(class|interface)\\s*JJJ\\b"
    543. 

  543.            :tests ("class test:" "public class test : IReadableChannel, I")
    544. 

  544.            :not ("class testnot:" "public class testnot : IReadableChannel, I"))
    545. 

    546. 

  546.     ;; coq
    547. 

  547.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    548. 

  548.            :regex "\\s*Variable\\s+JJJ\\b"
    549. 

  549.            :tests ("Variable test")
    550. 

  550.            :not ("Variable testx"))
    551. 

    552. 

  552.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    553. 

  553.            :regex "\\s*Inductive\\s+JJJ\\b"
    554. 

  554.            :tests ("Inductive test")
    555. 

  555.            :not ("Inductive testx"))
    556. 

    557. 

  557.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    558. 

  558.            :regex "\\s*Lemma\\s+JJJ\\b"
    559. 

  559.            :tests ("Lemma test")
    560. 

  560.            :not ("Lemma testx"))
    561. 

    562. 

  562.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    563. 

  563.            :regex "\\s*Definition\\s+JJJ\\b"
    564. 

  564.            :tests ("Definition test")
    565. 

  565.            :not ("Definition testx"))
    566. 

    567. 

  567.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    568. 

  568.            :regex "\\s*Hypothesis\\s+JJJ\\b"
    569. 

  569.            :tests ("Hypothesis test")
    570. 

  570.            :not ("Hypothesis testx"))
    571. 

    572. 

  572.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    573. 

  573.            :regex "\\s*Theorm\\s+JJJ\\b"
    574. 

  574.            :tests ("Theorm test")
    575. 

  575.            :not ("Theorm testx"))
    576. 

    577. 

  577.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    578. 

  578.            :regex "\\s*Fixpoint\\s+JJJ\\b"
    579. 

  579.            :tests ("Fixpoint test")
    580. 

  580.            :not ("Fixpoint testx"))
    581. 

    582. 

  582.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    583. 

  583.            :regex "\\s*Module\\s+JJJ\\b"
    584. 

  584.            :tests ("Module test")
    585. 

  585.            :not ("Module testx"))
    586. 

    587. 

  587.     (:type "function" :supports ("ag" "rg" "git-grep") :language "coq"
    588. 

  588.            :regex "\\s*CoInductive\\s+JJJ\\b"
    589. 

  589.            :tests ("CoInductive test")
    590. 

  590.            :not ("CoInductive testx"))
    591. 

    592. 

  592.     ;; python
    593. 

  593.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "python"
    594. 

  594.            :regex "\\s*\\bJJJ\\s*=[^=\\n]+"
    595. 

  595.            :tests ("test = 1234")
    596. 

  596.            :not ("if test == 1234:" "_test = 1234"))
    597. 

    598. 

  598.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "python"
    599. 

  599.            :regex "def\\s*JJJ\\b\\s*\\\("
    600. 

  600.            :tests ("\tdef test(asdf)" "def test()")
    601. 

  601.            :not ("\tdef testnot(asdf)" "def testnot()"))
    602. 

    603. 

  603.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "python"
    604. 

  604.            :regex "class\\s*JJJ\\b\\s*\\\(?"
    605. 

  605.            :tests ("class test(object):" "class test:")
    606. 

  606.            :not ("class testnot:" "class testnot(object):"))
    607. 

    608. 

  608.     ;; matlab
    609. 

  609.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "matlab"
    610. 

  610.            :regex "^\\s*\\bJJJ\\s*=[^=\\n]+"
    611. 

  611.            :tests ("test = 1234")
    612. 

  612.            :not ("for test = 1:2:" "_test = 1234"))
    613. 

    614. 

  614.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "matlab"
    615. 

  615.            :regex "^\\s*function\\s*[^=]+\\s*=\\s*JJJ\\b"
    616. 

  616.            :tests ("\tfunction y = test(asdf)" "function x = test()" "function [x, losses] = test(A, y, lambda, method, qtile)")
    617. 

  617.            :not ("\tfunction testnot(asdf)" "function testnot()"))
    618. 

    619. 

  619.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "matlab"
    620. 

  620.            :regex "^\\s*classdef\\s*JJJ\\b\\s*"
    621. 

  621.            :tests ("classdef test")
    622. 

  622.            :not ("classdef testnot"))
    623. 

    624. 

  624.     ;; nim
    625. 

  625.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "nim"
    626. 

  626.            :regex "(const|let|var)\\s*JJJ\\*?\\s*(=|:)[^=:\\n]+"
    627. 

  627.            :tests ("let test = 1234" "var test = 1234" "var test: Stat" "const test = 1234" "const test* = 1234")
    628. 

  628.            :not ("if test == 1234:"))
    629. 

    630. 

  630.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "nim"
    631. 

  631.            :regex "(proc|func|macro|template)\\s*`?JJJ`?\\b\\*?\\s*\\\("
    632. 

  632.            :tests ("\tproc test(asdf)" "proc test()" "func test()" "macro test()" "template test()" "proc test*()")
    633. 

  633.            :not ("\tproc testnot(asdf)" "proc testnot()"))
    634. 

    635. 

  635.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "nim"
    636. 

  636.            :regex "type\\s*JJJ\\b\\*?\\s*(\\{[^}]+\\})?\\s*=\\s*\\w+"
    637. 

  637.            :tests ("type test = object" "type test {.pure.} = enum" "type test* = ref object")
    638. 

  638.            :not ("type testnot = object"))
    639. 

    640. 

  640.     ;; nix
    641. 

  641.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "nix"
    642. 

  642.            :regex "\\b\\s*JJJ\\s*=[^=;]+"
    643. 

  643.            :tests ("test = 1234;" "test = 123;" "test=123")
    644. 

  644.            :not ("testNot = 1234;" "Nottest = 1234;" "AtestNot = 1234;"))
    645. 

    646. 

  646.     ;; ruby
    647. 

  647.     (:type "variable" :supports ("ag" "rg" "git-grep") :language "ruby"
    648. 

  648.            :regex "^\\s*((\\w+[.])*\\w+,\\s*)*JJJ(,\\s*(\\w+[.])*\\w+)*\\s*=([^=>~]|$)"
    649. 

  649.            :tests ("test = 1234" "self.foo, test, bar = args")
    650. 

  650.            :not ("if test == 1234" "foo_test = 1234"))
    651. 

    652. 

  652.     (:type "function" :supports ("ag" "rg" "git-grep") :language "ruby"
    653. 

  653.            :regex "(^|[^\\w.])((private|public|protected)\\s+)?def\\s+(\\w+(::|[.]))*JJJ($|[^\\w|:])"
    654. 

  654.            :tests ("def test(foo)" "def test()" "def test foo" "def test; end"
    655. 

  655.                    "def self.test()" "def MODULE::test()" "private def test")
    656. 

  656.            :not ("def test_foo"))
    657. 

    658. 

  658.     (:type "function" :supports ("ag" "rg" "git-grep") :language "ruby"
    659. 

  659.            :regex "(^|\\W)define(_singleton|_instance)?_method(\\s|[(])\\s*:JJJ($|[^\\w|:])"
    660. 

  660.            :tests ("define_method(:test, &body)"
    661. 

  661.                    "mod.define_instance_method(:test) { body }"))
    662. 

    663. 

  663.     (:type "type" :supports ("ag" "rg" "git-grep") :language "ruby"
    664. 

  664.            :regex "(^|[^\\w.])class\\s+(\\w*::)*JJJ($|[^\\w|:])"
    665. 

  665.            :tests ("class test" "class Foo::test"))
    666. 

    667. 

  667.     (:type "type" :supports ("ag" "rg" "git-grep") :language "ruby"
    668. 

  668.            :regex "(^|[^\\w.])module\\s+(\\w*::)*JJJ($|[^\\w|:])"
    669. 

  669.            :tests ("module test" "module Foo::test"))
    670. 

    671. 

  671.     (:type "function" :supports ("ag" "rg" "git-grep") :language "ruby"
    672. 

  672.            :regex "(^|\\W)alias(_method)?\\W+JJJ(\\W|$)"
    673. 

  673.            :tests ("alias test some_method"
    674. 

  674.                    "alias_method :test, :some_method"
    675. 

  675.                    "alias_method 'test' 'some_method'"
    676. 

  676.                    "some_class.send(:alias_method, :test, :some_method)")
    677. 

  677.            :not ("alias some_method test"
    678. 

  678.                  "alias_method :some_method, :test"
    679. 

  679.                  "alias test_foo test"))
    680. 

    681. 

  681.     ;; Groovy
    682. 

  682.     (:type "variable" :supports ("ag" "rg" "git-grep") :language "groovy"
    683. 

  683.            :regex "^\\s*((\\w+[.])*\\w+,\\s*)*JJJ(,\\s*(\\w+[.])*\\w+)*\\s*=([^=>~]|$)"
    684. 

  684.            :tests ("test = 1234" "self.foo, test, bar = args")
    685. 

  685.            :not ("if test == 1234" "foo_test = 1234"))
    686. 

    687. 

  687.     (:type "function" :supports ("ag" "rg" "git-grep") :language "groovy"
    688. 

  688.            :regex "(^|[^\\w.])((private|public)\\s+)?def\\s+(\\w+(::|[.]))*JJJ($|[^\\w|:])"
    689. 

  689.            :tests ("def test(foo)" "def test()" "def test foo" "def test; end"
    690. 

  690.                    "def self.test()" "def MODULE::test()" "private def test")
    691. 

  691.            :not ("def test_foo"))
    692. 

    693. 

  693.     (:type "type" :supports ("ag" "rg" "git-grep") :language "groovy"
    694. 

  694.            :regex "(^|[^\\w.])class\\s+(\\w*::)*JJJ($|[^\\w|:])"
    695. 

  695.            :tests ("class test" "class Foo::test"))
    696. 

    697. 

  697.     ;; crystal
    698. 

  698.     (:type "variable" :supports ("ag" "rg" "git-grep") :language "crystal"
    699. 

  699.            :regex "^\\s*((\\w+[.])*\\w+,\\s*)*JJJ(,\\s*(\\w+[.])*\\w+)*\\s*=([^=>~]|$)"
    700. 

  700.            :tests ("test = 1234" "self.foo, test, bar = args")
    701. 

  701.            :not ("if test == 1234" "foo_test = 1234"))
    702. 

    703. 

  703.     (:type "function" :supports ("ag" "rg" "git-grep") :language "crystal"
    704. 

  704.            :regex "(^|[^\\w.])((private|public|protected)\\s+)?def\\s+(\\w+(::|[.]))*JJJ($|[^\\w|:])"
    705. 

  705.            :tests ("def test(foo)" "def test()" "def test foo" "def test; end"
    706. 

  706.                    "def self.test()" "def MODULE::test()" "private def test")
    707. 

  707.            :not ("def test_foo"))
    708. 

    709. 

  709.     (:type "type" :supports ("ag" "rg" "git-grep") :language "crystal"
    710. 

  710.            :regex "(^|[^\\w.])class\\s+(\\w*::)*JJJ($|[^\\w|:])"
    711. 

  711.            :tests ("class test" "class Foo::test"))
    712. 

    713. 

  713.     (:type "type" :supports ("ag" "rg" "git-grep") :language "crystal"
    714. 

  714.            :regex "(^|[^\\w.])module\\s+(\\w*::)*JJJ($|[^\\w|:])"
    715. 

  715.            :tests ("module test" "module Foo::test"))
    716. 

    717. 

  717.     (:type "type" :supports ("ag" "rg" "git-grep") :language "crystal"
    718. 

  718.            :regex "(^|[^\\w.])struct\\s+(\\w*::)*JJJ($|[^\\w|:])"
    719. 

  719.            :tests ("struct test" "struct Foo::test"))
    720. 

    721. 

  721.     (:type "type" :supports ("ag" "rg" "git-grep") :language "crystal"
    722. 

  722.            :regex "(^|[^\\w.])alias\\s+(\\w*::)*JJJ($|[^\\w|:])"
    723. 

  723.            :tests ("alias test" "alias Foo::test"))
    724. 

    725. 

  725.     ;; scad
    726. 

  726.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "scad"
    727. 

  727.            :regex "\\s*\\bJJJ\\s*=[^=\\n]+" :tests ("test = 1234") :not ("if test == 1234 {"))
    728. 

    729. 

  729.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "scad"
    730. 

  730.            :regex "function\\s*JJJ\\s*\\\("
    731. 

  731.            :tests ("function test()" "function test ()"))
    732. 

    733. 

  733.     (:type "module" :supports ("ag" "grep" "rg" "git-grep") :language "scad"
    734. 

  734.            :regex "module\\s*JJJ\\s*\\\("
    735. 

  735.            :tests ("module test()" "module test ()"))
    736. 

    737. 

  737.     ;; scala
    738. 

  738.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "scala"
    739. 

  739.            :regex "\\bval\\s*JJJ\\s*=[^=\\n]+" :tests ("val test = 1234") :not ("case test => 1234"))
    740. 

    741. 

  741.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "scala"
    742. 

  742.            :regex "\\bvar\\s*JJJ\\s*=[^=\\n]+" :tests ("var test = 1234") :not ("case test => 1234"))
    743. 

    744. 

  744.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "scala"
    745. 

  745.            :regex "\\btype\\s*JJJ\\s*=[^=\\n]+" :tests ("type test = 1234") :not ("case test => 1234"))
    746. 

    747. 

  747.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "scala"
    748. 

  748.            :regex "\\bdef\\s*JJJ\\s*\\\("
    749. 

  749.            :tests ("def test(asdf)" "def test()"))
    750. 

    751. 

  751.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "scala"
    752. 

  752.            :regex "class\\s*JJJ\\s*\\\(?"
    753. 

  753.            :tests ("class test(object)"))
    754. 

    755. 

  755.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "scala"
    756. 

  756.            :regex "trait\\s*JJJ\\s*\\\(?"
    757. 

  757.            :tests ("trait test(object)"))
    758. 

    759. 

  759.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "scala"
    760. 

  760.            :regex "object\\s*JJJ\\s*\\\(?"
    761. 

  761.            :tests ("object test(object)"))
    762. 

    763. 

  763.     ;; solidity
    764. 

  764.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "solidity"
    765. 

  765.            :regex  "function\\s*JJJ\\s*\\\("
    766. 

  766.            :tests ("function test() internal" "function test (uint x, address y)" "function test() external"))
    767. 

    768. 

  768.     (:type "modifier" :supports ("ag" "grep" "rg" "git-grep") :language "solidity"
    769. 

  769.            :regex  "modifier\\s*JJJ\\s*\\\("
    770. 

  770.            :tests ("modifier test()" "modifier test ()"))
    771. 

    772. 

  772.     (:type "event" :supports ("ag" "grep" "rg" "git-grep") :language "solidity"
    773. 

  773.            :regex  "event\\s*JJJ\\s*\\\("
    774. 

  774.            :tests ("event test();" "event test (uint indexed x)" "event test(uint x, address y)"))
    775. 

    776. 

  776.     (:type "error" :supports ("ag" "grep" "rg" "git-grep") :language "solidity"
    777. 

  777.            :regex  "error\\s*JJJ\\s*\\\("
    778. 

  778.            :tests ("error test();" "error test (uint x)" "error test(uint x, address y)"))
    779. 

    780. 

  780.     ;; R
    781. 

  781.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "r"
    782. 

  782.            :regex "\\bJJJ\\s*=[^=><]" :tests ("test = 1234") :not ("if (test == 1234)"))
    783. 

    784. 

  784.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "r"
    785. 

  785.            :regex "\\bJJJ\\s*<-\\s*function\\b"
    786. 

  786.            :tests ("test <- function" "test <- function(")
    787. 

  787.            :not   ("test <- functionX"))
    788. 

    789. 

  789.     ;; perl
    790. 

  790.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "perl"
    791. 

  791.            :regex "sub\\s*JJJ\\s*(\\{|\\()"
    792. 

  792.            :tests ("sub test{" "sub test {" "sub test(" "sub test ("))
    793. 

    794. 

  794.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "perl"
    795. 

  795.            :regex "JJJ\\s*=\\s*"
    796. 

  796.            :tests ("$test = 1234"))
    797. 

    798. 

  798.     ;; Tcl
    799. 

  799.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "tcl"
    800. 

  800.            :regex "proc\\s+JJJ\\s*\\{"
    801. 

  801.            :tests ("proc test{" "proc test {"))
    802. 

    803. 

  803.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "tcl"
    804. 

  804.            :regex "set\\s+JJJ"
    805. 

  805.            :tests ("set test 1234"))
    806. 

    807. 

  807.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "tcl"
    808. 

  808.            :regex "(variable|global)\\s+JJJ"
    809. 

  809.            :tests ("variable test" "global test"))
    810. 

    811. 

  811.     ;; shell
    812. 

  812.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "shell"
    813. 

  813.            :regex "function\\s*JJJ\\s*"
    814. 

  814.            :tests ("function test{" "function test {" "function test () {")
    815. 

  815.            :not   ("function nottest {"))
    816. 

    817. 

  817.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "shell"
    818. 

  818.            :regex "JJJ\\\(\\\)\\s*\\{"
    819. 

  819.            :tests ("test() {")
    820. 

  820.            :not ("testx() {"))
    821. 

    822. 

  822.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "shell"
    823. 

  823.            :regex "\\bJJJ\\s*=\\s*"
    824. 

  824.            :tests ("test = 1234") :not ("blahtest = 1234"))
    825. 

    826. 

  826.     ;; php
    827. 

  827.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "php"
    828. 

  828.            :regex "function\\s*JJJ\\s*\\\("
    829. 

  829.            :tests ("function test()" "function test ()"))
    830. 

    831. 

  831.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "php"
    832. 

  832.            :regex "\\*\\s@method\\s+[^ \t]+\\s+JJJ\\("
    833. 

  833.            :tests ("/** @method string|false test($a)" " * @method bool test()"))
    834. 

    835. 

  835.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "php"
    836. 

  836.            :regex "(\\s|->|\\$|::)JJJ\\s*=\\s*"
    837. 

  837.            :tests ("$test = 1234" "$foo->test = 1234"))
    838. 

    839. 

  839.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "php"
    840. 

  840.            :regex "\\*\\s@property(-read|-write)?\\s+([^ \t]+\\s+)&?\\$JJJ(\\s+|$)"
    841. 

  841.            :tests ("/** @property string $test" "/** @property string $test description for $test property"  " * @property-read bool|bool $test" " * @property-write \\ArrayObject<string,resource[]> $test"))
    842. 

  842.     (:type "trait" :supports ("ag" "grep" "rg" "git-grep") :language "php"
    843. 

  843.            :regex "trait\\s*JJJ\\s*\\\{"
    844. 

  844.            :tests ("trait test{" "trait test {"))
    845. 

    846. 

  846.     (:type "interface" :supports ("ag" "grep" "rg" "git-grep") :language "php"
    847. 

  847.            :regex "interface\\s*JJJ\\s*\\\{"
    848. 

  848.            :tests ("interface test{" "interface test {"))
    849. 

    850. 

  850.     (:type "class" :supports ("ag" "grep" "rg" "git-grep") :language "php"
    851. 

  851.            :regex "class\\s*JJJ\\s*(extends|implements|\\\{)"
    852. 

  852.            :tests ("class test{" "class test {" "class test extends foo" "class test implements foo"))
    853. 

    854. 

  854.     ;; dart
    855. 

  855.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "dart"
    856. 

  856.            :regex "\\bJJJ\\s*\\([^()]*\\)\\s*[{]"
    857. 

  857.            :tests ("test(foo) {" "test (foo){" "test(foo){"))
    858. 

    859. 

  859.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "dart"
    860. 

  860.            :regex "class\\s*JJJ\\s*[\\\(\\\{]"
    861. 

  861.            :tests ("class test(object) {" "class test{"))
    862. 

    863. 

  863.     ;; faust
    864. 

  864.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "faust"
    865. 

  865.            :regex "\\bJJJ\(\\\(.+\\\)\)*\\s*="
    866. 

  866.            :tests ("test = osc + 0.5;" "test(freq) = osc(freq) + 0.5;"))
    867. 

    868. 

  868.     ;; fennel
    869. 

  869.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "fennel"
    870. 

  870.            :regex "\\((local|var)\\s+JJJ\\j"
    871. 

  871.            :tests ("(local test (foo)"
    872. 

  872.                    "(var test (foo)"))
    873. 

    874. 

  874.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "fennel"
    875. 

  875.            :regex "\\(fn\\s+JJJ\\j"
    876. 

  876.            :tests ("(fn test [foo]")
    877. 

  877.            :not ("(fn test? [foo]"))
    878. 

    879. 

  879.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "fennel"
    880. 

  880.            :regex "\\(macro\\s+JJJ\\j"
    881. 

  881.            :tests ("(macro test [foo]"))
    882. 

    883. 

  883.     ;; fortran
    884. 

  884.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "fortran"
    885. 

  885.            :regex "\\s*\\bJJJ\\s*=[^=\\n]+"
    886. 

  886.            :tests ("test = 1234")
    887. 

  887.            :not ("if (test == 1234)"))
    888. 

    889. 

  889.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "fortran"
    890. 

  890.            :regex "\\b(function|subroutine|FUNCTION|SUBROUTINE)\\s+JJJ\\b\\s*\\\("
    891. 

  891.            :tests ("function test (foo)" "integer function test(foo)"
    892. 

  892.                    "subroutine test (foo, bar)" "FUNCTION test (foo)"
    893. 

  893.                    "INTEGER FUNCTION test(foo)" "SUBROUTINE test (foo, bar)")
    894. 

  894.            :not ("end function test" "end subroutine test" "END FUNCTION test"
    895. 

  895.                  "END SUBROUTINE test"))
    896. 

    897. 

  897.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "fortran"
    898. 

  898.            :regex "^\\s*(interface|INTERFACE)\\s+JJJ\\b"
    899. 

  899.            :tests ("interface test" "INTERFACE test")
    900. 

  900.            :not ("interface test2" "end interface test" "INTERFACE test2"
    901. 

  901.                  "END INTERFACE test"))
    902. 

    903. 

  903.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "fortran"
    904. 

  904.            :regex "^\\s*(module|MODULE)\\s+JJJ\\s*"
    905. 

  905.            :tests ("module test" "MODULE test")
    906. 

  906.            :not ("end module test" "END MODULE test"))
    907. 

    908. 

  908.     ;; go
    909. 

  909.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "go"
    910. 

  910.            :regex "\\s*\\bJJJ\\s*=[^=\\n]+" :tests ("test = 1234") :not ("if test == 1234 {"))
    911. 

    912. 

  912.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "go"
    913. 

  913.            :regex "\\s*\\bJJJ\\s*:=\\s*" :tests ("test := 1234"))
    914. 

    915. 

  915.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "go"
    916. 

  916.            :regex "func\\s+\\\([^\\\)]*\\\)\\s+JJJ\\s*\\\("
    917. 

  917.            :tests ("func (s *blah) test(filename string) string {"))
    918. 

    919. 

  919.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "go"
    920. 

  920.            :regex "func\\s+JJJ\\s*\\\("
    921. 

  921.            :tests ("func test(url string) (string, error)"))
    922. 

    923. 

  923.     (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "go"
    924. 

  924.            :regex "type\\s+JJJ\\s+struct\\s+\\\{"
    925. 

  925.            :tests ("type test struct {"))
    926. 

    927. 

  927.     ;; javascript extended
    928. 

  928.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "javascript"
    929. 

  929.            :regex "(service|factory)\\\(['\"]JJJ['\"]" :tags ("angular")
    930. 

  930.            :tests ("module.factory('test', [\"$rootScope\", function($rootScope) {"))
    931. 

    932. 

  932.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "javascript"
    933. 

  933.            :regex "\\bJJJ\\s*[=:]\\s*\\\([^\\\)]*\\\)\\s+=>" :tags ("es6")
    934. 

  934.            :tests ("const test = (foo) => " "test: (foo) => {" "  test: (foo) => {"))
    935. 

    936. 

  936.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "javascript"
    937. 

  937.            :regex "\\bJJJ\\s*\\([^()]*\\)\\s*[{]" :tags ("es6")
    938. 

  938.            :tests ("test(foo) {" "test (foo){" "test(foo){")
    939. 

  939.            :not ("test = blah.then(function(){"))
    940. 

    941. 

  941.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "javascript" :tags ("es6")
    942. 

  942.            :regex "class\\s*JJJ\\s*[\\\(\\\{]"
    943. 

  943.            :tests ("class test(object) {" "class test{"))
    944. 

    945. 

  945.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "javascript" :tags ("es6")
    946. 

  946.            :regex "class\\s*JJJ\\s+extends"
    947. 

  947.            :tests ("class test extends Component{"))
    948. 

    949. 

  949.     ;; javascript
    950. 

  950.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "javascript"
    951. 

  951.            :regex "\\s*\\bJJJ\\s*=[^=\\n]+" :tests ("test = 1234" "const test = props =>") :not ("if (test === 1234)"))
    952. 

    953. 

  953.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "javascript"
    954. 

  954.            :regex "\\bfunction\\b[^\\(]*\\\(\\s*[^\\)]*\\bJJJ\\b\\s*,?\\s*\\\)?"
    955. 

  955.            :tests ("function (test)" "function (test, blah)" "function somefunc(test, blah) {" "function(blah, test)")
    956. 

  956.            :not ("function (testLen)" "function (test1, blah)" "function somefunc(testFirst, blah) {" "function(blah, testLast)"
    957. 

  957.                  "function (Lentest)" "function (blahtest, blah)" "function somefunc(Firsttest, blah) {" "function(blah, Lasttest)"))
    958. 

    959. 

  959.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "javascript"
    960. 

  960.            :regex "function\\s*JJJ\\s*\\\("
    961. 

  961.            :tests ("function test()" "function test ()"))
    962. 

    963. 

  963.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "javascript"
    964. 

  964.            :regex "\\bJJJ\\s*:\\s*function\\s*\\\("
    965. 

  965.            :tests ("test: function()"))
    966. 

    967. 

  967.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "javascript"
    968. 

  968.            :regex "\\bJJJ\\s*=\\s*function\\s*\\\("
    969. 

  969.            :tests ("test = function()"))
    970. 

    971. 

  971.     ;; hcl terraform
    972. 

  972.     (:type "block" :supports ("ag" "grep" "rg" "git-grep") :language "hcl"
    973. 

  973.            :regex "(variable|output|module)\\s*\"JJJ\"\\s*\\\{"
    974. 

  974.            :tests ("variable \"test\" {"
    975. 

  975.                    "output \"test\" {"
    976. 

  976.                    "module \"test\" {"))
    977. 

    978. 

  978.     (:type "block" :supports ("ag" "grep" "rg" "git-grep") :language "hcl"
    979. 

  979.            :regex "(data|resource)\\s*\"\\w+\"\\s*\"JJJ\"\\s*\\\{"
    980. 

  980.            :tests ("data \"openstack_images_image_v2\" \"test\" {"
    981. 

  981.                    "resource \"google_compute_instance\" \"test\" {"))
    982. 

    983. 

  983.     ;; typescript
    984. 

  984.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    985. 

  985.            :regex "(service|factory)\\\(['\"]JJJ['\"]" :tags ("angular")
    986. 

  986.            :tests ("module.factory('test', [\"$rootScope\", function($rootScope) {"))
    987. 

    988. 

  988.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    989. 

  989.            :regex "\\bJJJ\\s*[=:]\\s*\\\([^\\\)]*\\\)\\s+=>"
    990. 

  990.            :tests ("const test = (foo) => " "test: (foo) => {" "  test: (foo) => {"))
    991. 

    992. 

  992.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    993. 

  993.            :regex "\\bJJJ\\s*\\([^()]*\\)\\s*[{]"
    994. 

  994.            :tests ("test(foo) {" "test (foo){" "test(foo){")
    995. 

  995.            :not ("test = blah.then(function(){"))
    996. 

    997. 

  997.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    998. 

  998.            :regex "class\\s*JJJ\\s*[\\\(\\\{]"
    999. 

  999.            :tests ("class test{"))
    1000. 

    1001. 

  1001.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    1002. 

  1002.            :regex "class\\s*JJJ\\s+extends"
    1003. 

  1003.            :tests ("class test extends Component{"))
    1004. 

    1005. 

  1005.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    1006. 

  1006.            :regex "function\\s*JJJ\\s*\\\("
    1007. 

  1007.            :tests ("function test()" "function test ()"))
    1008. 

    1009. 

  1009.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    1010. 

  1010.            :regex "\\bJJJ\\s*:\\s*function\\s*\\\("
    1011. 

  1011.            :tests ("test: function()"))
    1012. 

    1013. 

  1013.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    1014. 

  1014.            :regex "\\bJJJ\\s*=\\s*function\\s*\\\("
    1015. 

  1015.            :tests ("test = function()"))
    1016. 

    1017. 

  1017.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    1018. 

  1018.            :regex "\\s*\\bJJJ\\s*=[^=\\n]+" :tests ("test = 1234" "const test = props =>") :not ("if (test === 1234)"))
    1019. 

    1020. 

  1020.     (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
    1021. 

  1021.            :regex "\\bfunction\\b[^\\(]*\\\(\\s*[^\\)]*\\bJJJ\\b\\s*,?\\s*\\\)?"
    1022. 

  1022.            :tests ("function (test)" "function (test, blah)" "function somefunc(test, blah) {" "function(blah, test)")
    1023. 

  1023.            :not ("function (testLen)" "function (test1, blah)" "function somefunc(testFirst, blah) {" "function(blah, testLast)"
    1024. 

  1024.                  "function (Lentest)" "function (blahtest, blah)" "function somefunc(Firsttest, blah) {" "function(blah, Lasttest)"))
    1025. 

    1026. 

  1026.     ;; julia
    1027. 

  1027.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "julia"
    1028. 

  1028.            :regex "(@noinline|@inline)?\\s*function\\s*JJJ(\\{[^\\}]*\\})?\\("
    1029. 

  1029.            :tests ("function test()" "@inline function test()"
    1030. 

  1030.                    "function test{T}(h)"))
    1031. 

    1032. 

  1032.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "julia"
    1033. 

  1033.            :regex "(@noinline|@inline)?JJJ(\\{[^\\}]*\\})?\\([^\\)]*\\)\s*="
    1034. 

  1034.            :tests ("test(a)=1" "test(a,b)=1*8"
    1035. 

  1035.                    "@noinline test()=1" "test{T}(x)=x"))
    1036. 

    1037. 

  1037.     (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "julia"
    1038. 

  1038.            :regex "macro\\s*JJJ\\("
    1039. 

  1039.            :tests ("macro test(a)=1" " macro test(a,b)=1*8"))
    1040. 

    1041. 

  1041.     (:type "variable" :supports ("ag" "rg") :language "julia"
    1042. 

  1042.            :regex "const\\s+JJJ\\b"
    1043. 

  1043.            :tests ("const test = "))
    1044. 

    1045. 

  1045.     (:type "type" :supports ("ag" "rg") :language "julia"
    1046. 

  1046.            :regex "(mutable)?\\s*struct\\s*JJJ"
    1047. 

  1047.            :tests ("struct test"))
    1048. 

    1049. 

  1049.     (:type "type" :supports ("ag" "rg") :language "julia"
    1050. 

  1050.            :regex "(type|immutable|abstract)\\s*JJJ"
    1051. 

  1051.            :tests ("type test" "immutable test" "abstract test <:Testable" ))
    1052. 

    1053. 

  1053.     ;; haskell
    1054. 

  1054.     (:type "module" :supports ("ag") :language "haskell"
    1055. 

  1055.            :regex "^module\\s+JJJ\\s+"
    1056. 

  1056.            :tests ("module Test (exportA, exportB) where"))
    1057. 

    1058. 

  1058.                                         ; TODO Doesn't support any '=' in arguments. E.g. 'foo A{a = b,..} = bar'.
    1059. 

  1059.     (:type "top level function" :supports ("ag") :language "haskell"
    1060. 

  1060.            :regex "^\\bJJJ(?!(\\s+::))\\s+((.|\\s)*?)=\\s+"
    1061. 

  1061.            :tests ("test n = n * 2"
    1062. 

  1062.                    "test X{..} (Y a b c) \n bcd \n =\n x * y"
    1063. 

  1063.                    "test ab cd e@Datatype {..} (Another thing, inTheRow) = \n undefined"
    1064. 

  1064.                    "test = runRealBasedMode @ext @ctx identity identity"
    1065. 

  1065.                    "test unwrap wrap nr@Naoeu {..} (Action action, specSpecs) = \n    undefined")
    1066. 

  1066.            :not ("nottest n = n * 2"
    1067. 

  1067.                  "let testnot x y = x * y" "test $ y z" "let test a o = mda"
    1068. 

  1068.                  "test :: Sometype -> AnotherType aoeu kek = undefined"))
    1069. 

    1070. 

  1070.     (:type "type-like" :supports ("ag") :language "haskell"
    1071. 

  1071.            :regex "^\\s*((data(\\s+family)?)|(newtype)|(type(\\s+family)?))\\s+JJJ\\s+"
    1072. 

  1072.            :tests ("newtype Test a = Something { b :: Kek }"
    1073. 

  1073.                    "data Test a b = Somecase a | Otherca
    1074.