/
pechorin
/
any-jump.vim
GigaCode
beta
ОбзорЦентр заботыВойти

any-jump.vim

Форк
0
Ветки: 6Коммиты: 249Теги: 5
any-jump.vim
/generator
/
lang_map_generated.vim 
2244 строки · 81.6 Кб
1
" NOTES:
2
" - all language regexps ported from https://github.com/jacktasia/dumb-jump/blob/master/dumb-jump.el
3


4
let s:definitions = {}
5


6
" map any-language to concrete internal s:definitions[language]
7
let s:filetypes_proxy = {
8
  \"javascriptreact": "javascript",
9
  \"c": "cpp",
10
  \}
11


12
fu! s:add_definition(lang, definition) abort
13
  if !has_key(s:definitions, a:lang)
14
    let s:definitions[a:lang] = []
15
  endif
16


17
  call add(s:definitions[a:lang], a:definition)
18
endfu
19


20
fu! lang_map#find_definitions(language) abort
21
  if !lang_map#lang_exists(a:language)
22
    return
23
  endif
24


25
  return s:definitions[a:language]
26
endfu
27


28
fu! lang_map#definitions() abort
29
  return s:definitions
30
endfu
31


32
fu! lang_map#lang_exists(language) abort
33
  return has_key(s:definitions, a:language)
34
endfu
35


36
fu! lang_map#get_language_from_filetype(ft) abort
37
  if has_key(s:filetypes_proxy, a:ft)
38
    let maybe_lan = s:filetypes_proxy[a:ft]
39
  else
40
    let maybe_lan = a:ft
41
  endif
42


43
  if lang_map#lang_exists(maybe_lan)
44
    return maybe_lan
45
  else
46
    return 0
47
  endif
48
endfu
49


50
call s:add_definition('elisp', {
51
	\"type": 'function',
52
	\"pcre2_regexp": '\((defun|cl-defun)\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
53
	\"emacs_regexp": '\((defun|cl-defun)\s+JJJ\j',
54
	\"supports": ["ag", "grep", "rg", "git-grep"],
55
	\"spec_success": ["(defun test (blah)","(defun test\n","(cl-defun test (blah)","(cl-defun test\n"],
56
	\"spec_failed": ["(defun test-asdf (blah)","(defun test-blah\n","(cl-defun test-asdf (blah)","(cl-defun test-blah\n","(defun tester (blah)","(defun test? (blah)","(defun test- (blah)"],
57
	\})
58


59
call s:add_definition('elisp', {
60
	\"type": 'function',
61
	\"pcre2_regexp": '\(defmacro\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
62
	\"emacs_regexp": '\(defmacro\s+JJJ\j',
63
	\"supports": ["ag", "grep", "rg", "git-grep"],
64
	\"spec_success": ["(defmacro test (blah)","(defmacro test\n"],
65
	\"spec_failed": ["(defmacro test-asdf (blah)","(defmacro test-blah\n","(defmacro tester (blah)","(defmacro test? (blah)","(defmacro test- (blah)"],
66
	\})
67


68
call s:add_definition('elisp', {
69
	\"type": 'variable',
70
	\"pcre2_regexp": '\(defvar\b\s*KEYWORD($|[^a-zA-Z0-9\?\*-])',
71
	\"emacs_regexp": '\(defvar\b\s*JJJ\j',
72
	\"supports": ["ag", "grep", "rg", "git-grep"],
73
	\"spec_success": ["(defvar test ","(defvar test\n"],
74
	\"spec_failed": ["(defvar tester","(defvar test?","(defvar test-"],
75
	\})
76


77
call s:add_definition('elisp', {
78
	\"type": 'variable',
79
	\"pcre2_regexp": '\(defcustom\b\s*KEYWORD($|[^a-zA-Z0-9\?\*-])',
80
	\"emacs_regexp": '\(defcustom\b\s*JJJ\j',
81
	\"supports": ["ag", "grep", "rg", "git-grep"],
82
	\"spec_success": ["(defcustom test ","(defcustom test\n"],
83
	\"spec_failed": ["(defcustom tester","(defcustom test?","(defcustom test-"],
84
	\})
85


86
call s:add_definition('elisp', {
87
	\"type": 'variable',
88
	\"pcre2_regexp": '\(setq\b\s*KEYWORD($|[^a-zA-Z0-9\?\*-])',
89
	\"emacs_regexp": '\(setq\b\s*JJJ\j',
90
	\"supports": ["ag", "grep", "rg", "git-grep"],
91
	\"spec_success": ["(setq test 123)"],
92
	\"spec_failed": ["setq test-blah 123)","(setq tester","(setq test?","(setq test-"],
93
	\})
94


95
call s:add_definition('elisp', {
96
	\"type": 'variable',
97
	\"pcre2_regexp": '\(KEYWORD\s+',
98
	\"emacs_regexp": '\(JJJ\s+',
99
	\"supports": ["ag", "grep", "rg", "git-grep"],
100
	\"spec_success": ["(let ((test 123)))"],
101
	\"spec_failed": ["(let ((test-2 123)))"],
102
	\})
103


104
call s:add_definition('elisp', {
105
	\"type": 'variable',
106
	\"pcre2_regexp": '\((defun|cl-defun)\s*.+\(?\s*KEYWORD($|[^a-zA-Z0-9\?\*-])\s*\)?',
107
	\"emacs_regexp": '\((defun|cl-defun)\s*.+\(?\s*JJJ\j\s*\)?',
108
	\"supports": ["ag", "rg", "git-grep"],
109
	\"spec_success": ["(defun blah (test)","(defun blah (test blah)","(defun (blah test)"],
110
	\"spec_failed": ["(defun blah (test-1)","(defun blah (test-2 blah)","(defun (blah test-3)"],
111
	\})
112


113
call s:add_definition('commonlisp', {
114
	\"type": 'function',
115
	\"pcre2_regexp": '\(defun\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
116
	\"emacs_regexp": '\(defun\s+JJJ\j',
117
	\"supports": ["ag", "grep", "rg", "git-grep"],
118
	\"spec_success": ["(defun test (blah)","(defun test\n"],
119
	\"spec_failed": ["(defun test-asdf (blah)","(defun test-blah\n","(defun tester (blah)","(defun test? (blah)","(defun test- (blah)"],
120
	\})
121


122
call s:add_definition('commonlisp', {
123
	\"type": 'variable',
124
	\"pcre2_regexp": '\(defparameter\b\s*KEYWORD($|[^a-zA-Z0-9\?\*-])',
125
	\"emacs_regexp": '\(defparameter\b\s*JJJ\j',
126
	\"supports": ["ag", "grep", "rg", "git-grep"],
127
	\"spec_success": ["(defparameter test ","(defparameter test\n"],
128
	\"spec_failed": ["(defparameter tester","(defparameter test?","(defparameter test-"],
129
	\})
130


131
call s:add_definition('racket', {
132
	\"type": 'function',
133
	\"pcre2_regexp": '\(define\s+\(\s*KEYWORD($|[^a-zA-Z0-9\?\*-])',
134
	\"emacs_regexp": '\(define\s+\(\s*JJJ\j',
135
	\"supports": ["ag", "grep", "rg", "git-grep"],
136
	\"spec_success": ["(define (test blah)","(define (test\n"],
137
	\"spec_failed": ["(define test blah","(define (test-asdf blah)","(define test (lambda (blah"],
138
	\})
139


140
call s:add_definition('racket', {
141
	\"type": 'function',
142
	\"pcre2_regexp": '\(define\s+KEYWORD\s*\(\s*lambda',
143
	\"emacs_regexp": '\(define\s+JJJ\s*\(\s*lambda',
144
	\"supports": ["ag", "grep", "rg", "git-grep"],
145
	\"spec_success": ["(define test (lambda (blah","(define test (lambda\n"],
146
	\"spec_failed": ["(define test blah","(define test-asdf (lambda (blah)","(define (test)","(define (test blah) (lambda (foo"],
147
	\})
148


149
call s:add_definition('racket', {
150
	\"type": 'function',
151
	\"pcre2_regexp": '\(let\s+KEYWORD\s*(\(|\[)*',
152
	\"emacs_regexp": '\(let\s+JJJ\s*(\(|\[)*',
153
	\"supports": ["ag", "grep", "rg", "git-grep"],
154
	\"spec_success": ["(let test ((blah foo) (bar bas))","(let test\n","(let test [(foo"],
155
	\"spec_failed": ["(let ((test blah"],
156
	\})
157


158
call s:add_definition('racket', {
159
	\"type": 'variable',
160
	\"pcre2_regexp": '\(define\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
161
	\"emacs_regexp": '\(define\s+JJJ\j',
162
	\"supports": ["ag", "grep", "rg", "git-grep"],
163
	\"spec_success": ["(define test ","(define test\n"],
164
	\"spec_failed": ["(define (test"],
165
	\})
166


167
call s:add_definition('racket', {
168
	\"type": 'variable',
169
	\"pcre2_regexp": '(\(|\[)\s*KEYWORD\s+',
170
	\"emacs_regexp": '(\(|\[)\s*JJJ\s+',
171
	\"supports": ["ag", "grep", "rg", "git-grep"],
172
	\"spec_success": ["(let ((test 'foo","(let [(test 'foo","(let [(test 'foo","(let [[test 'foo","(let ((blah 'foo) (test 'bar)"],
173
	\"spec_failed": ["{test foo"],
174
	\})
175


176
call s:add_definition('racket', {
177
	\"type": 'variable',
178
	\"pcre2_regexp": '\(lambda\s+\(?[^()]*\s*KEYWORD($|[^a-zA-Z0-9\?\*-])\s*\)?',
179
	\"emacs_regexp": '\(lambda\s+\(?[^()]*\s*JJJ\j\s*\)?',
180
	\"supports": ["ag", "grep", "rg", "git-grep"],
181
	\"spec_success": ["(lambda (test)","(lambda (foo test)","(lambda test (foo)"],
182
	\"spec_failed": ["(lambda () test"],
183
	\})
184


185
call s:add_definition('racket', {
186
	\"type": 'variable',
187
	\"pcre2_regexp": '\(define\s+\([^()]+\s*KEYWORD($|[^a-zA-Z0-9\?\*-])\s*\)?',
188
	\"emacs_regexp": '\(define\s+\([^()]+\s*JJJ\j\s*\)?',
189
	\"supports": ["ag", "grep", "rg", "git-grep"],
190
	\"spec_success": ["(define (foo test)","(define (foo test bar)"],
191
	\"spec_failed": ["(define foo test","(define (test foo","(define (test)"],
192
	\})
193


194
call s:add_definition('racket', {
195
	\"type": 'type',
196
	\"pcre2_regexp": '\(struct\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
197
	\"emacs_regexp": '\(struct\s+JJJ\j',
198
	\"supports": ["ag", "grep", "rg", "git-grep"],
199
	\"spec_success": ["(struct test (a b)"],
200
	\"spec_failed": [],
201
	\})
202


203
call s:add_definition('scheme', {
204
	\"type": 'function',
205
	\"pcre2_regexp": '\(define\s+\(\s*KEYWORD($|[^a-zA-Z0-9\?\*-])',
206
	\"emacs_regexp": '\(define\s+\(\s*JJJ\j',
207
	\"supports": ["ag", "grep", "rg", "git-grep"],
208
	\"spec_success": ["(define (test blah)","(define (test\n"],
209
	\"spec_failed": ["(define test blah","(define (test-asdf blah)","(define test (lambda (blah"],
210
	\})
211


212
call s:add_definition('scheme', {
213
	\"type": 'function',
214
	\"pcre2_regexp": '\(define\s+KEYWORD\s*\(\s*lambda',
215
	\"emacs_regexp": '\(define\s+JJJ\s*\(\s*lambda',
216
	\"supports": ["ag", "grep", "rg", "git-grep"],
217
	\"spec_success": ["(define test (lambda (blah","(define test (lambda\n"],
218
	\"spec_failed": ["(define test blah","(define test-asdf (lambda (blah)","(define (test)","(define (test blah) (lambda (foo"],
219
	\})
220


221
call s:add_definition('scheme', {
222
	\"type": 'function',
223
	\"pcre2_regexp": '\(let\s+KEYWORD\s*(\(|\[)*',
224
	\"emacs_regexp": '\(let\s+JJJ\s*(\(|\[)*',
225
	\"supports": ["ag", "grep", "rg", "git-grep"],
226
	\"spec_success": ["(let test ((blah foo) (bar bas))","(let test\n","(let test [(foo"],
227
	\"spec_failed": ["(let ((test blah"],
228
	\})
229


230
call s:add_definition('scheme', {
231
	\"type": 'variable',
232
	\"pcre2_regexp": '\(define\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
233
	\"emacs_regexp": '\(define\s+JJJ\j',
234
	\"supports": ["ag", "grep", "rg", "git-grep"],
235
	\"spec_success": ["(define test ","(define test\n"],
236
	\"spec_failed": ["(define (test"],
237
	\})
238


239
call s:add_definition('scheme', {
240
	\"type": 'variable',
241
	\"pcre2_regexp": '(\(|\[)\s*KEYWORD\s+',
242
	\"emacs_regexp": '(\(|\[)\s*JJJ\s+',
243
	\"supports": ["ag", "grep", "rg", "git-grep"],
244
	\"spec_success": ["(let ((test 'foo","(let [(test 'foo","(let [(test 'foo","(let [[test 'foo","(let ((blah 'foo) (test 'bar)"],
245
	\"spec_failed": ["{test foo"],
246
	\})
247


248
call s:add_definition('scheme', {
249
	\"type": 'variable',
250
	\"pcre2_regexp": '\(lambda\s+\(?[^()]*\s*KEYWORD($|[^a-zA-Z0-9\?\*-])\s*\)?',
251
	\"emacs_regexp": '\(lambda\s+\(?[^()]*\s*JJJ\j\s*\)?',
252
	\"supports": ["ag", "grep", "rg", "git-grep"],
253
	\"spec_success": ["(lambda (test)","(lambda (foo test)","(lambda test (foo)"],
254
	\"spec_failed": ["(lambda () test"],
255
	\})
256


257
call s:add_definition('scheme', {
258
	\"type": 'variable',
259
	\"pcre2_regexp": '\(define\s+\([^()]+\s*KEYWORD($|[^a-zA-Z0-9\?\*-])\s*\)?',
260
	\"emacs_regexp": '\(define\s+\([^()]+\s*JJJ\j\s*\)?',
261
	\"supports": ["ag", "grep", "rg", "git-grep"],
262
	\"spec_success": ["(define (foo test)","(define (foo test bar)"],
263
	\"spec_failed": ["(define foo test","(define (test foo","(define (test)"],
264
	\})
265


266
call s:add_definition('cpp', {
267
	\"type": 'function',
268
	\"pcre2_regexp": '\bKEYWORD(\s|\))*\((\w|[,&*.<>:]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+KEYWORD(\)|\s)*\(',
269
	\"emacs_regexp": '\bJJJ(\s|\))*\((\w|[,&*.<>:]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+JJJ(\)|\s)*\(',
270
	\"supports": ["ag", "rg", "git-grep"],
271
	\"spec_success": ["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);"],
272
	\"spec_failed": ["return test();)","int test(a, b);","if( test() ) {","else test();"],
273
	\})
274


275
call s:add_definition('cpp', {
276
	\"type": 'variable',
277
	\"pcre2_regexp": '(\b\w+|[,>])([*&]|\s)+KEYWORD\s*(\[([0-9]|\s)*\])*\s*([=,){;]|:\s*[0-9])|#define\s+KEYWORD\b',
278
	\"emacs_regexp": '(\b\w+|[,>])([*&]|\s)+JJJ\s*(\[([0-9]|\s)*\])*\s*([=,){;]|:\s*[0-9])|#define\s+JJJ\b',
279
	\"supports": ["grep"],
280
	\"spec_success": ["int test=2;","char *test;","int x = 1, test = 2","int test[20];","#define test","unsigned int test:2;"],
281
	\"spec_failed": [],
282
	\})
283


284
call s:add_definition('cpp', {
285
	\"type": 'variable',
286
	\"pcre2_regexp": '\b(?!(class\b|struct\b|return\b|else\b|delete\b))(\w+|[,>])([*&]|\s)+KEYWORD\s*(\[(\d|\s)*\])*\s*([=,(){;]|:\s*\d)|#define\s+KEYWORD\b',
287
	\"emacs_regexp": '\b(?!(class\b|struct\b|return\b|else\b|delete\b))(\w+|[,>])([*&]|\s)+JJJ\s*(\[(\d|\s)*\])*\s*([=,(){;]|:\s*\d)|#define\s+JJJ\b',
288
	\"supports": ["ag", "rg"],
289
	\"spec_success": ["int test=2;","char *test;","int x = 1, test = 2","int test[20];","#define test","typedef int test;","unsigned int test:2"],
290
	\"spec_failed": ["return test;","#define NOT test","else test=2;"],
291
	\})
292


293
call s:add_definition('cpp', {
294
	\"type": 'type',
295
	\"pcre2_regexp": '\b(class|struct|enum|union)\b\s*KEYWORD\b\s*(final\s*)?(:((\s*\w+\s*::)*\s*\w*\s*<?(\s*\w+\s*::)*\w+>?\s*,*)+)?((\{|$))|}\s*KEYWORD\b\s*;',
296
	\"emacs_regexp": '\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*;',
297
	\"supports": ["ag", "rg", "git-grep"],
298
	\"spec_success": ["typedef struct test {","enum test {","} test;","union test {","class test final: public Parent1, private Parent2{","class test : public std::vector<int> {"],
299
	\"spec_failed": ["union test var;","struct test function() {"],
300
	\})
301


302
call s:add_definition('clojure', {
303
	\"type": 'variable',
304
	\"pcre2_regexp": '\(def\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
305
	\"emacs_regexp": '\(def\s+JJJ\j',
306
	\"supports": ["ag", "grep", "rg", "git-grep"],
307
	\"spec_success": ["(def test (foo)"],
308
	\"spec_failed": [],
309
	\})
310


311
call s:add_definition('clojure', {
312
	\"type": 'function',
313
	\"pcre2_regexp": '\(defn-?\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
314
	\"emacs_regexp": '\(defn-?\s+JJJ\j',
315
	\"supports": ["ag", "grep", "rg", "git-grep"],
316
	\"spec_success": ["(defn test [foo]","(defn- test [foo]"],
317
	\"spec_failed": ["(defn test? [foo]","(defn- test? [foo]"],
318
	\})
319


320
call s:add_definition('clojure', {
321
	\"type": 'function',
322
	\"pcre2_regexp": '\(defmacro\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
323
	\"emacs_regexp": '\(defmacro\s+JJJ\j',
324
	\"supports": ["ag", "grep", "rg", "git-grep"],
325
	\"spec_success": ["(defmacro test [foo]"],
326
	\"spec_failed": [],
327
	\})
328


329
call s:add_definition('clojure', {
330
	\"type": 'function',
331
	\"pcre2_regexp": '\(deftask\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
332
	\"emacs_regexp": '\(deftask\s+JJJ\j',
333
	\"supports": ["ag", "grep", "rg", "git-grep"],
334
	\"spec_success": ["(deftask test [foo]"],
335
	\"spec_failed": [],
336
	\})
337


338
call s:add_definition('clojure', {
339
	\"type": 'type',
340
	\"pcre2_regexp": '\(deftype\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
341
	\"emacs_regexp": '\(deftype\s+JJJ\j',
342
	\"supports": ["ag", "grep", "rg", "git-grep"],
343
	\"spec_success": ["(deftype test [foo]"],
344
	\"spec_failed": [],
345
	\})
346


347
call s:add_definition('clojure', {
348
	\"type": 'type',
349
	\"pcre2_regexp": '\(defmulti\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
350
	\"emacs_regexp": '\(defmulti\s+JJJ\j',
351
	\"supports": ["ag", "grep", "rg", "git-grep"],
352
	\"spec_success": ["(defmulti test fn"],
353
	\"spec_failed": [],
354
	\})
355


356
call s:add_definition('clojure', {
357
	\"type": 'type',
358
	\"pcre2_regexp": '\(defmethod\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
359
	\"emacs_regexp": '\(defmethod\s+JJJ\j',
360
	\"supports": ["ag", "grep", "rg", "git-grep"],
361
	\"spec_success": ["(defmethod test type"],
362
	\"spec_failed": [],
363
	\})
364


365
call s:add_definition('clojure', {
366
	\"type": 'type',
367
	\"pcre2_regexp": '\(definterface\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
368
	\"emacs_regexp": '\(definterface\s+JJJ\j',
369
	\"supports": ["ag", "grep", "rg", "git-grep"],
370
	\"spec_success": ["(definterface test (foo)"],
371
	\"spec_failed": [],
372
	\})
373


374
call s:add_definition('clojure', {
375
	\"type": 'type',
376
	\"pcre2_regexp": '\(defprotocol\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
377
	\"emacs_regexp": '\(defprotocol\s+JJJ\j',
378
	\"supports": ["ag", "grep", "rg", "git-grep"],
379
	\"spec_success": ["(defprotocol test (foo)"],
380
	\"spec_failed": [],
381
	\})
382


383
call s:add_definition('clojure', {
384
	\"type": 'type',
385
	\"pcre2_regexp": '\(defrecord\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
386
	\"emacs_regexp": '\(defrecord\s+JJJ\j',
387
	\"supports": ["ag", "grep", "rg", "git-grep"],
388
	\"spec_success": ["(defrecord test [foo]"],
389
	\"spec_failed": [],
390
	\})
391


392
call s:add_definition('coffeescript', {
393
	\"type": 'function',
394
	\"pcre2_regexp": '^\s*KEYWORD\s*[=:].*[-=]>',
395
	\"emacs_regexp": '^\s*JJJ\s*[=:].*[-=]>',
396
	\"supports": ["ag", "grep", "rg", "git-grep"],
397
	\"spec_success": ["test = ()  =>","test= =>","test = ->","test=()->","test : ()  =>","test: =>","test : ->","test:()->"],
398
	\"spec_failed": ["# test = =>","test = 1"],
399
	\})
400


401
call s:add_definition('coffeescript', {
402
	\"type": 'variable',
403
	\"pcre2_regexp": '^\s*KEYWORD\s*[:=][^:=-][^>]+$',
404
	\"emacs_regexp": '^\s*JJJ\s*[:=][^:=-][^>]+$',
405
	\"supports": ["ag", "grep", "rg", "git-grep"],
406
	\"spec_success": ["test = $","test : [","test = {","test = a"],
407
	\"spec_failed": ["test::a","test: =>","test == 1","# test = 1"],
408
	\})
409


410
call s:add_definition('coffeescript', {
411
	\"type": 'class',
412
	\"pcre2_regexp": '^\s*\bclass\s+KEYWORD',
413
	\"emacs_regexp": '^\s*\bclass\s+JJJ',
414
	\"supports": ["ag", "grep", "rg", "git-grep"],
415
	\"spec_success": ["class test","class test extends"],
416
	\"spec_failed": ["# class"],
417
	\})
418


419
call s:add_definition('objc', {
420
	\"type": 'function',
421
	\"pcre2_regexp": '\)\s*KEYWORD(:|\b|\s)',
422
	\"emacs_regexp": '\)\s*JJJ(:|\b|\s)',
423
	\"supports": ["ag", "grep", "rg", "git-grep"],
424
	\"spec_success": ["- (void)test","- (void)test:(UIAlertView *)alertView"],
425
	\"spec_failed": ["- (void)testnot","- (void)testnot:(UIAlertView *)alertView"],
426
	\})
427


428
call s:add_definition('objc', {
429
	\"type": 'variable',
430
	\"pcre2_regexp": '\b\*?KEYWORD\s*=[^=\n]+',
431
	\"emacs_regexp": '\b\*?JJJ\s*=[^=\n]+',
432
	\"supports": ["ag", "grep", "rg", "git-grep"],
433
	\"spec_success": ["NSString *test = @\"asdf\""],
434
	\"spec_failed": ["NSString *testnot = @\"asdf\"","NSString *nottest = @\"asdf\""],
435
	\})
436


437
call s:add_definition('objc', {
438
	\"type": 'type',
439
	\"pcre2_regexp": '(@interface|@protocol|@implementation)\b\s*KEYWORD\b\s*',
440
	\"emacs_regexp": '(@interface|@protocol|@implementation)\b\s*JJJ\b\s*',
441
	\"supports": ["ag", "grep", "rg", "git-grep"],
442
	\"spec_success": ["@interface test: UIWindow"],
443
	\"spec_failed": ["@interface testnon: UIWindow"],
444
	\})
445


446
call s:add_definition('objc', {
447
	\"type": 'type',
448
	\"pcre2_regexp": 'typedef\b\s+(NS_OPTIONS|NS_ENUM)\b\([^,]+?,\s*KEYWORD\b\s*',
449
	\"emacs_regexp": 'typedef\b\s+(NS_OPTIONS|NS_ENUM)\b\([^,]+?,\s*JJJ\b\s*',
450
	\"supports": ["ag", "grep", "rg", "git-grep"],
451
	\"spec_success": ["typedef NS_ENUM(NSUInteger, test)"],
452
	\"spec_failed": ["typedef NS_ENUMD(NSUInteger, test)"],
453
	\})
454


455
call s:add_definition('swift', {
456
	\"type": 'variable',
457
	\"pcre2_regexp": '(let|var)\s*KEYWORD\s*(=|:)[^=:\n]+',
458
	\"emacs_regexp": '(let|var)\s*JJJ\s*(=|:)[^=:\n]+',
459
	\"supports": ["ag", "grep", "rg", "git-grep"],
460
	\"spec_success": ["let test = 1234","var test = 1234","private lazy var test: UITapGestureRecognizer"],
461
	\"spec_failed": ["if test == 1234:"],
462
	\})
463


464
call s:add_definition('swift', {
465
	\"type": 'function',
466
	\"pcre2_regexp": 'func\s+KEYWORD\b\s*(<[^>]*>)?\s*\(',
467
	\"emacs_regexp": 'func\s+JJJ\b\s*(<[^>]*>)?\s*\(',
468
	\"supports": ["ag", "grep", "rg", "git-grep"],
469
	\"spec_success": ["func test(asdf)","func test()","func test<Value: Protocol>()"],
470
	\"spec_failed": ["func testnot(asdf)","func testnot()"],
471
	\})
472


473
call s:add_definition('swift', {
474
	\"type": 'type',
475
	\"pcre2_regexp": '(class|struct|protocol|enum)\s+KEYWORD\b\s*?',
476
	\"emacs_regexp": '(class|struct|protocol|enum)\s+JJJ\b\s*?',
477
	\"supports": ["ag", "grep", "rg", "git-grep"],
478
	\"spec_success": ["struct test","struct test: Codable","struct test<Value: Codable>","class test:","class test: UIWindow","class test<Value: Codable>"],
479
	\"spec_failed": ["class testnot:","class testnot(object):","struct testnot(object)"],
480
	\})
481


482
call s:add_definition('swift', {
483
	\"type": 'type',
484
	\"pcre2_regexp": '(typealias)\s+KEYWORD\b\s*?=',
485
	\"emacs_regexp": '(typealias)\s+JJJ\b\s*?=',
486
	\"supports": ["ag", "grep", "rg", "git-grep"],
487
	\"spec_success": ["typealias test ="],
488
	\"spec_failed": ["typealias testnot"],
489
	\})
490


491
call s:add_definition('csharp', {
492
	\"type": 'function',
493
	\"pcre2_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}KEYWORD\s*\(',
494
	\"emacs_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}JJJ\s*\(',
495
	\"supports": ["ag", "rg"],
496
	\"spec_success": ["int test()","int test(param)","static int test()","static int test(param)","public static MyType test()","private virtual SomeType test(param)","static int test()"],
497
	\"spec_failed": ["test()","testnot()","blah = new test()"],
498
	\})
499


500
call s:add_definition('csharp', {
501
	\"type": 'variable',
502
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n)]+',
503
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n)]+',
504
	\"supports": ["ag", "grep", "rg", "git-grep"],
505
	\"spec_success": ["int test = 1234"],
506
	\"spec_failed": ["if test == 1234:","int nottest = 44"],
507
	\})
508


509
call s:add_definition('csharp', {
510
	\"type": 'type',
511
	\"pcre2_regexp": '(class|interface)\s*KEYWORD\b',
512
	\"emacs_regexp": '(class|interface)\s*JJJ\b',
513
	\"supports": ["ag", "grep", "rg", "git-grep"],
514
	\"spec_success": ["class test:","public class test : IReadableChannel, I"],
515
	\"spec_failed": ["class testnot:","public class testnot : IReadableChannel, I"],
516
	\})
517


518
call s:add_definition('java', {
519
	\"type": 'function',
520
	\"pcre2_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}KEYWORD\s*\(',
521
	\"emacs_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}JJJ\s*\(',
522
	\"supports": ["ag", "rg"],
523
	\"spec_success": ["int test()","int test(param)","static int test()","static int test(param)","public static MyType test()","private virtual SomeType test(param)","static int test()","private foo[] test()"],
524
	\"spec_failed": ["test()","testnot()","blah = new test()","foo bar = test()"],
525
	\})
526


527
call s:add_definition('java', {
528
	\"type": 'variable',
529
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n)]+',
530
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n)]+',
531
	\"supports": ["ag", "grep", "rg", "git-grep"],
532
	\"spec_success": ["int test = 1234"],
533
	\"spec_failed": ["if test == 1234:","int nottest = 44"],
534
	\})
535


536
call s:add_definition('java', {
537
	\"type": 'type',
538
	\"pcre2_regexp": '(class|interface)\s*KEYWORD\b',
539
	\"emacs_regexp": '(class|interface)\s*JJJ\b',
540
	\"supports": ["ag", "grep", "rg", "git-grep"],
541
	\"spec_success": ["class test:","public class test implements Something"],
542
	\"spec_failed": ["class testnot:","public class testnot implements Something"],
543
	\})
544


545
call s:add_definition('vala', {
546
	\"type": 'function',
547
	\"pcre2_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}KEYWORD\s*\(',
548
	\"emacs_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}JJJ\s*\(',
549
	\"supports": ["ag", "rg"],
550
	\"spec_success": ["int test()","int test(param)","static int test()","static int test(param)","public static MyType test()","private virtual SomeType test(param)","static int test()"],
551
	\"spec_failed": ["test()","testnot()","blah = new test()"],
552
	\})
553


554
call s:add_definition('vala', {
555
	\"type": 'variable',
556
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n)]+',
557
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n)]+',
558
	\"supports": ["ag", "grep", "rg", "git-grep"],
559
	\"spec_success": ["int test = 1234"],
560
	\"spec_failed": ["if test == 1234:","int nottest = 44"],
561
	\})
562


563
call s:add_definition('vala', {
564
	\"type": 'type',
565
	\"pcre2_regexp": '(class|interface)\s*KEYWORD\b',
566
	\"emacs_regexp": '(class|interface)\s*JJJ\b',
567
	\"supports": ["ag", "grep", "rg", "git-grep"],
568
	\"spec_success": ["class test:","public class test : IReadableChannel, I"],
569
	\"spec_failed": ["class testnot:","public class testnot : IReadableChannel, I"],
570
	\})
571


572
call s:add_definition('coq', {
573
	\"type": 'function',
574
	\"pcre2_regexp": '\s*Variable\s+KEYWORD\b',
575
	\"emacs_regexp": '\s*Variable\s+JJJ\b',
576
	\"supports": ["ag", "rg", "git-grep"],
577
	\"spec_success": ["Variable test"],
578
	\"spec_failed": ["Variable testx"],
579
	\})
580


581
call s:add_definition('coq', {
582
	\"type": 'function',
583
	\"pcre2_regexp": '\s*Inductive\s+KEYWORD\b',
584
	\"emacs_regexp": '\s*Inductive\s+JJJ\b',
585
	\"supports": ["ag", "rg", "git-grep"],
586
	\"spec_success": ["Inductive test"],
587
	\"spec_failed": ["Inductive testx"],
588
	\})
589


590
call s:add_definition('coq', {
591
	\"type": 'function',
592
	\"pcre2_regexp": '\s*Lemma\s+KEYWORD\b',
593
	\"emacs_regexp": '\s*Lemma\s+JJJ\b',
594
	\"supports": ["ag", "rg", "git-grep"],
595
	\"spec_success": ["Lemma test"],
596
	\"spec_failed": ["Lemma testx"],
597
	\})
598


599
call s:add_definition('coq', {
600
	\"type": 'function',
601
	\"pcre2_regexp": '\s*Definition\s+KEYWORD\b',
602
	\"emacs_regexp": '\s*Definition\s+JJJ\b',
603
	\"supports": ["ag", "rg", "git-grep"],
604
	\"spec_success": ["Definition test"],
605
	\"spec_failed": ["Definition testx"],
606
	\})
607


608
call s:add_definition('coq', {
609
	\"type": 'function',
610
	\"pcre2_regexp": '\s*Hypothesis\s+KEYWORD\b',
611
	\"emacs_regexp": '\s*Hypothesis\s+JJJ\b',
612
	\"supports": ["ag", "rg", "git-grep"],
613
	\"spec_success": ["Hypothesis test"],
614
	\"spec_failed": ["Hypothesis testx"],
615
	\})
616


617
call s:add_definition('coq', {
618
	\"type": 'function',
619
	\"pcre2_regexp": '\s*Theorm\s+KEYWORD\b',
620
	\"emacs_regexp": '\s*Theorm\s+JJJ\b',
621
	\"supports": ["ag", "rg", "git-grep"],
622
	\"spec_success": ["Theorm test"],
623
	\"spec_failed": ["Theorm testx"],
624
	\})
625


626
call s:add_definition('coq', {
627
	\"type": 'function',
628
	\"pcre2_regexp": '\s*Fixpoint\s+KEYWORD\b',
629
	\"emacs_regexp": '\s*Fixpoint\s+JJJ\b',
630
	\"supports": ["ag", "rg", "git-grep"],
631
	\"spec_success": ["Fixpoint test"],
632
	\"spec_failed": ["Fixpoint testx"],
633
	\})
634


635
call s:add_definition('coq', {
636
	\"type": 'function',
637
	\"pcre2_regexp": '\s*Module\s+KEYWORD\b',
638
	\"emacs_regexp": '\s*Module\s+JJJ\b',
639
	\"supports": ["ag", "rg", "git-grep"],
640
	\"spec_success": ["Module test"],
641
	\"spec_failed": ["Module testx"],
642
	\})
643


644
call s:add_definition('coq', {
645
	\"type": 'function',
646
	\"pcre2_regexp": '\s*CoInductive\s+KEYWORD\b',
647
	\"emacs_regexp": '\s*CoInductive\s+JJJ\b',
648
	\"supports": ["ag", "rg", "git-grep"],
649
	\"spec_success": ["CoInductive test"],
650
	\"spec_failed": ["CoInductive testx"],
651
	\})
652


653
call s:add_definition('python', {
654
	\"type": 'variable',
655
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+',
656
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n]+',
657
	\"supports": ["ag", "grep", "rg", "git-grep"],
658
	\"spec_success": ["test = 1234"],
659
	\"spec_failed": ["if test == 1234:","_test = 1234"],
660
	\})
661


662
call s:add_definition('python', {
663
	\"type": 'function',
664
	\"pcre2_regexp": 'def\s*KEYWORD\b\s*\(',
665
	\"emacs_regexp": 'def\s*JJJ\b\s*\(',
666
	\"supports": ["ag", "grep", "rg", "git-grep"],
667
	\"spec_success": ["\tdef test(asdf)","def test()"],
668
	\"spec_failed": ["\tdef testnot(asdf)","def testnot()"],
669
	\})
670


671
call s:add_definition('python', {
672
	\"type": 'type',
673
	\"pcre2_regexp": 'class\s*KEYWORD\b\s*\(?',
674
	\"emacs_regexp": 'class\s*JJJ\b\s*\(?',
675
	\"supports": ["ag", "grep", "rg", "git-grep"],
676
	\"spec_success": ["class test(object):","class test:"],
677
	\"spec_failed": ["class testnot:","class testnot(object):"],
678
	\})
679


680
call s:add_definition('matlab', {
681
	\"type": 'variable',
682
	\"pcre2_regexp": '^\s*\bKEYWORD\s*=[^=\n]+',
683
	\"emacs_regexp": '^\s*\bJJJ\s*=[^=\n]+',
684
	\"supports": ["ag", "grep", "rg", "git-grep"],
685
	\"spec_success": ["test = 1234"],
686
	\"spec_failed": ["for test = 1:2:","_test = 1234"],
687
	\})
688


689
call s:add_definition('matlab', {
690
	\"type": 'function',
691
	\"pcre2_regexp": '^\s*function\s*[^=]+\s*=\s*KEYWORD\b',
692
	\"emacs_regexp": '^\s*function\s*[^=]+\s*=\s*JJJ\b',
693
	\"supports": ["ag", "grep", "rg", "git-grep"],
694
	\"spec_success": ["\tfunction y = test(asdf)","function x = test()","function [x, losses] = test(A, y, lambda, method, qtile)"],
695
	\"spec_failed": ["\tfunction testnot(asdf)","function testnot()"],
696
	\})
697


698
call s:add_definition('matlab', {
699
	\"type": 'type',
700
	\"pcre2_regexp": '^\s*classdef\s*KEYWORD\b\s*',
701
	\"emacs_regexp": '^\s*classdef\s*JJJ\b\s*',
702
	\"supports": ["ag", "grep", "rg", "git-grep"],
703
	\"spec_success": ["classdef test"],
704
	\"spec_failed": ["classdef testnot"],
705
	\})
706


707
call s:add_definition('nim', {
708
	\"type": 'variable',
709
	\"pcre2_regexp": '(const|let|var)\s*KEYWORD\*?\s*(=|:)[^=:\n]+',
710
	\"emacs_regexp": '(const|let|var)\s*JJJ\*?\s*(=|:)[^=:\n]+',
711
	\"supports": ["ag", "grep", "rg", "git-grep"],
712
	\"spec_success": ["let test = 1234","var test = 1234","var test: Stat","const test = 1234","const test* = 1234"],
713
	\"spec_failed": ["if test == 1234:"],
714
	\})
715


716
call s:add_definition('nim', {
717
	\"type": 'function',
718
	\"pcre2_regexp": '(proc|func|macro|template)\s*\`?KEYWORD\`?\b\*?\s*\(',
719
	\"emacs_regexp": '(proc|func|macro|template)\s*\`?JJJ\`?\b\*?\s*\(',
720
	\"supports": ["ag", "grep", "rg", "git-grep"],
721
	\"spec_success": ["\tproc test(asdf)","proc test()","func test()","macro test()","template test()","proc test*()"],
722
	\"spec_failed": ["\tproc testnot(asdf)","proc testnot()"],
723
	\})
724


725
call s:add_definition('nim', {
726
	\"type": 'type',
727
	\"pcre2_regexp": 'type\s*KEYWORD\b\*?\s*(\{[^}]+\})?\s*=\s*\w+',
728
	\"emacs_regexp": 'type\s*JJJ\b\*?\s*(\{[^}]+\})?\s*=\s*\w+',
729
	\"supports": ["ag", "grep", "rg", "git-grep"],
730
	\"spec_success": ["type test = object","type test {.pure.} = enum","type test* = ref object"],
731
	\"spec_failed": ["type testnot = object"],
732
	\})
733


734
call s:add_definition('nix', {
735
	\"type": 'variable',
736
	\"pcre2_regexp": '\b\s*KEYWORD\s*=[^=;]+',
737
	\"emacs_regexp": '\b\s*JJJ\s*=[^=;]+',
738
	\"supports": ["ag", "grep", "rg", "git-grep"],
739
	\"spec_success": ["test = 1234;","test = 123;","test=123"],
740
	\"spec_failed": ["testNot = 1234;","Nottest = 1234;","AtestNot = 1234;"],
741
	\})
742


743
call s:add_definition('ruby', {
744
	\"type": 'variable',
745
	\"pcre2_regexp": '^\s*((\w+[.])*\w+,\s*)*KEYWORD(,\s*(\w+[.])*\w+)*\s*=([^=>~]|$)',
746
	\"emacs_regexp": '^\s*((\w+[.])*\w+,\s*)*JJJ(,\s*(\w+[.])*\w+)*\s*=([^=>~]|$)',
747
	\"supports": ["ag", "rg", "git-grep"],
748
	\"spec_success": ["test = 1234","self.foo, test, bar = args"],
749
	\"spec_failed": ["if test == 1234","foo_test = 1234"],
750
	\})
751


752
call s:add_definition('ruby', {
753
	\"type": 'function',
754
	\"pcre2_regexp": '(^|[^\w.])((private|public|protected)\s+)?def\s+(\w+(::|[.]))*KEYWORD($|[^\w|:])',
755
	\"emacs_regexp": '(^|[^\w.])((private|public|protected)\s+)?def\s+(\w+(::|[.]))*JJJ($|[^\w|:])',
756
	\"supports": ["ag", "rg", "git-grep"],
757
	\"spec_success": ["def test(foo)","def test()","def test foo","def test; end","def self.test()","def MODULE::test()","private def test"],
758
	\"spec_failed": ["def test_foo"],
759
	\})
760


761
call s:add_definition('ruby', {
762
	\"type": 'function',
763
	\"pcre2_regexp": '(^|\W)define(_singleton|_instance)?_method(\s|[(])\s*:KEYWORD($|[^\w|:])',
764
	\"emacs_regexp": '(^|\W)define(_singleton|_instance)?_method(\s|[(])\s*:JJJ($|[^\w|:])',
765
	\"supports": ["ag", "rg", "git-grep"],
766
	\"spec_success": ["define_method(:test, &body)","mod.define_instance_method(:test) { body }"],
767
	\"spec_failed": [],
768
	\})
769


770
call s:add_definition('ruby', {
771
	\"type": 'type',
772
	\"pcre2_regexp": '(^|[^\w.])class\s+(\w*::)*KEYWORD($|[^\w|:])',
773
	\"emacs_regexp": '(^|[^\w.])class\s+(\w*::)*JJJ($|[^\w|:])',
774
	\"supports": ["ag", "rg", "git-grep"],
775
	\"spec_success": ["class test","class Foo::test"],
776
	\"spec_failed": [],
777
	\})
778


779
call s:add_definition('ruby', {
780
	\"type": 'type',
781
	\"pcre2_regexp": '(^|[^\w.])module\s+(\w*::)*KEYWORD($|[^\w|:])',
782
	\"emacs_regexp": '(^|[^\w.])module\s+(\w*::)*JJJ($|[^\w|:])',
783
	\"supports": ["ag", "rg", "git-grep"],
784
	\"spec_success": ["module test","module Foo::test"],
785
	\"spec_failed": [],
786
	\})
787


788
call s:add_definition('ruby', {
789
	\"type": 'function',
790
	\"pcre2_regexp": '(^|\W)alias(_method)?\W+KEYWORD(\W|$)',
791
	\"emacs_regexp": '(^|\W)alias(_method)?\W+JJJ(\W|$)',
792
	\"supports": ["ag", "rg", "git-grep"],
793
	\"spec_success": ["alias test some_method","alias_method :test, :some_method","alias_method 'test' 'some_method'","some_class.send(:alias_method, :test, :some_method)"],
794
	\"spec_failed": ["alias some_method test","alias_method :some_method, :test","alias test_foo test"],
795
	\})
796


797
call s:add_definition('groovy', {
798
	\"type": 'variable',
799
	\"pcre2_regexp": '^\s*((\w+[.])*\w+,\s*)*KEYWORD(,\s*(\w+[.])*\w+)*\s*=([^=>~]|$)',
800
	\"emacs_regexp": '^\s*((\w+[.])*\w+,\s*)*JJJ(,\s*(\w+[.])*\w+)*\s*=([^=>~]|$)',
801
	\"supports": ["ag", "rg", "git-grep"],
802
	\"spec_success": ["test = 1234","self.foo, test, bar = args"],
803
	\"spec_failed": ["if test == 1234","foo_test = 1234"],
804
	\})
805


806
call s:add_definition('groovy', {
807
	\"type": 'function',
808
	\"pcre2_regexp": '(^|[^\w.])((private|public)\s+)?def\s+(\w+(::|[.]))*KEYWORD($|[^\w|:])',
809
	\"emacs_regexp": '(^|[^\w.])((private|public)\s+)?def\s+(\w+(::|[.]))*JJJ($|[^\w|:])',
810
	\"supports": ["ag", "rg", "git-grep"],
811
	\"spec_success": ["def test(foo)","def test()","def test foo","def test; end","def self.test()","def MODULE::test()","private def test"],
812
	\"spec_failed": ["def test_foo"],
813
	\})
814


815
call s:add_definition('groovy', {
816
	\"type": 'type',
817
	\"pcre2_regexp": '(^|[^\w.])class\s+(\w*::)*KEYWORD($|[^\w|:])',
818
	\"emacs_regexp": '(^|[^\w.])class\s+(\w*::)*JJJ($|[^\w|:])',
819
	\"supports": ["ag", "rg", "git-grep"],
820
	\"spec_success": ["class test","class Foo::test"],
821
	\"spec_failed": [],
822
	\})
823


824
call s:add_definition('crystal', {
825
	\"type": 'variable',
826
	\"pcre2_regexp": '^\s*((\w+[.])*\w+,\s*)*KEYWORD(,\s*(\w+[.])*\w+)*\s*=([^=>~]|$)',
827
	\"emacs_regexp": '^\s*((\w+[.])*\w+,\s*)*JJJ(,\s*(\w+[.])*\w+)*\s*=([^=>~]|$)',
828
	\"supports": ["ag", "rg", "git-grep"],
829
	\"spec_success": ["test = 1234","self.foo, test, bar = args"],
830
	\"spec_failed": ["if test == 1234","foo_test = 1234"],
831
	\})
832


833
call s:add_definition('crystal', {
834
	\"type": 'function',
835
	\"pcre2_regexp": '(^|[^\w.])((private|public|protected)\s+)?def\s+(\w+(::|[.]))*KEYWORD($|[^\w|:])',
836
	\"emacs_regexp": '(^|[^\w.])((private|public|protected)\s+)?def\s+(\w+(::|[.]))*JJJ($|[^\w|:])',
837
	\"supports": ["ag", "rg", "git-grep"],
838
	\"spec_success": ["def test(foo)","def test()","def test foo","def test; end","def self.test()","def MODULE::test()","private def test"],
839
	\"spec_failed": ["def test_foo"],
840
	\})
841


842
call s:add_definition('crystal', {
843
	\"type": 'type',
844
	\"pcre2_regexp": '(^|[^\w.])class\s+(\w*::)*KEYWORD($|[^\w|:])',
845
	\"emacs_regexp": '(^|[^\w.])class\s+(\w*::)*JJJ($|[^\w|:])',
846
	\"supports": ["ag", "rg", "git-grep"],
847
	\"spec_success": ["class test","class Foo::test"],
848
	\"spec_failed": [],
849
	\})
850


851
call s:add_definition('crystal', {
852
	\"type": 'type',
853
	\"pcre2_regexp": '(^|[^\w.])module\s+(\w*::)*KEYWORD($|[^\w|:])',
854
	\"emacs_regexp": '(^|[^\w.])module\s+(\w*::)*JJJ($|[^\w|:])',
855
	\"supports": ["ag", "rg", "git-grep"],
856
	\"spec_success": ["module test","module Foo::test"],
857
	\"spec_failed": [],
858
	\})
859


860
call s:add_definition('crystal', {
861
	\"type": 'type',
862
	\"pcre2_regexp": '(^|[^\w.])struct\s+(\w*::)*KEYWORD($|[^\w|:])',
863
	\"emacs_regexp": '(^|[^\w.])struct\s+(\w*::)*JJJ($|[^\w|:])',
864
	\"supports": ["ag", "rg", "git-grep"],
865
	\"spec_success": ["struct test","struct Foo::test"],
866
	\"spec_failed": [],
867
	\})
868


869
call s:add_definition('crystal', {
870
	\"type": 'type',
871
	\"pcre2_regexp": '(^|[^\w.])alias\s+(\w*::)*KEYWORD($|[^\w|:])',
872
	\"emacs_regexp": '(^|[^\w.])alias\s+(\w*::)*JJJ($|[^\w|:])',
873
	\"supports": ["ag", "rg", "git-grep"],
874
	\"spec_success": ["alias test","alias Foo::test"],
875
	\"spec_failed": [],
876
	\})
877


878
call s:add_definition('scad', {
879
	\"type": 'variable',
880
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+',
881
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n]+',
882
	\"supports": ["ag", "grep", "rg", "git-grep"],
883
	\"spec_success": ["test = 1234"],
884
	\"spec_failed": ["if test == 1234 {"],
885
	\})
886


887
call s:add_definition('scad', {
888
	\"type": 'function',
889
	\"pcre2_regexp": 'function\s*KEYWORD\s*\(',
890
	\"emacs_regexp": 'function\s*JJJ\s*\(',
891
	\"supports": ["ag", "grep", "rg", "git-grep"],
892
	\"spec_success": ["function test()","function test ()"],
893
	\"spec_failed": [],
894
	\})
895


896
call s:add_definition('scad', {
897
	\"type": 'module',
898
	\"pcre2_regexp": 'module\s*KEYWORD\s*\(',
899
	\"emacs_regexp": 'module\s*JJJ\s*\(',
900
	\"supports": ["ag", "grep", "rg", "git-grep"],
901
	\"spec_success": ["module test()","module test ()"],
902
	\"spec_failed": [],
903
	\})
904


905
call s:add_definition('scala', {
906
	\"type": 'variable',
907
	\"pcre2_regexp": '\bval\s*KEYWORD\s*=[^=\n]+',
908
	\"emacs_regexp": '\bval\s*JJJ\s*=[^=\n]+',
909
	\"supports": ["ag", "grep", "rg", "git-grep"],
910
	\"spec_success": ["val test = 1234"],
911
	\"spec_failed": ["case test => 1234"],
912
	\})
913


914
call s:add_definition('scala', {
915
	\"type": 'variable',
916
	\"pcre2_regexp": '\bvar\s*KEYWORD\s*=[^=\n]+',
917
	\"emacs_regexp": '\bvar\s*JJJ\s*=[^=\n]+',
918
	\"supports": ["ag", "grep", "rg", "git-grep"],
919
	\"spec_success": ["var test = 1234"],
920
	\"spec_failed": ["case test => 1234"],
921
	\})
922


923
call s:add_definition('scala', {
924
	\"type": 'variable',
925
	\"pcre2_regexp": '\btype\s*KEYWORD\s*=[^=\n]+',
926
	\"emacs_regexp": '\btype\s*JJJ\s*=[^=\n]+',
927
	\"supports": ["ag", "grep", "rg", "git-grep"],
928
	\"spec_success": ["type test = 1234"],
929
	\"spec_failed": ["case test => 1234"],
930
	\})
931


932
call s:add_definition('scala', {
933
	\"type": 'function',
934
	\"pcre2_regexp": '\bdef\s*KEYWORD\s*\(',
935
	\"emacs_regexp": '\bdef\s*JJJ\s*\(',
936
	\"supports": ["ag", "grep", "rg", "git-grep"],
937
	\"spec_success": ["def test(asdf)","def test()"],
938
	\"spec_failed": [],
939
	\})
940


941
call s:add_definition('scala', {
942
	\"type": 'type',
943
	\"pcre2_regexp": 'class\s*KEYWORD\s*\(?',
944
	\"emacs_regexp": 'class\s*JJJ\s*\(?',
945
	\"supports": ["ag", "grep", "rg", "git-grep"],
946
	\"spec_success": ["class test(object)"],
947
	\"spec_failed": [],
948
	\})
949


950
call s:add_definition('scala', {
951
	\"type": 'type',
952
	\"pcre2_regexp": 'trait\s*KEYWORD\s*\(?',
953
	\"emacs_regexp": 'trait\s*JJJ\s*\(?',
954
	\"supports": ["ag", "grep", "rg", "git-grep"],
955
	\"spec_success": ["trait test(object)"],
956
	\"spec_failed": [],
957
	\})
958


959
call s:add_definition('scala', {
960
	\"type": 'type',
961
	\"pcre2_regexp": 'object\s*KEYWORD\s*\(?',
962
	\"emacs_regexp": 'object\s*JJJ\s*\(?',
963
	\"supports": ["ag", "grep", "rg", "git-grep"],
964
	\"spec_success": ["object test(object)"],
965
	\"spec_failed": [],
966
	\})
967


968
call s:add_definition('solidity', {
969
	\"type": 'function',
970
	\"pcre2_regexp": 'function\s*KEYWORD\s*\(',
971
	\"emacs_regexp": 'function\s*JJJ\s*\(',
972
	\"supports": ["ag", "grep", "rg", "git-grep"],
973
	\"spec_success": ["function test() internal","function test (uint x, address y)","function test() external"],
974
	\"spec_failed": [],
975
	\})
976


977
call s:add_definition('solidity', {
978
	\"type": 'modifier',
979
	\"pcre2_regexp": 'modifier\s*KEYWORD\s*\(',
980
	\"emacs_regexp": 'modifier\s*JJJ\s*\(',
981
	\"supports": ["ag", "grep", "rg", "git-grep"],
982
	\"spec_success": ["modifier test()","modifier test ()"],
983
	\"spec_failed": [],
984
	\})
985


986
call s:add_definition('solidity', {
987
	\"type": 'event',
988
	\"pcre2_regexp": 'event\s*KEYWORD\s*\(',
989
	\"emacs_regexp": 'event\s*JJJ\s*\(',
990
	\"supports": ["ag", "grep", "rg", "git-grep"],
991
	\"spec_success": ["event test();","event test (uint indexed x)","event test(uint x, address y)"],
992
	\"spec_failed": [],
993
	\})
994


995
call s:add_definition('solidity', {
996
	\"type": 'error',
997
	\"pcre2_regexp": 'error\s*KEYWORD\s*\(',
998
	\"emacs_regexp": 'error\s*JJJ\s*\(',
999
	\"supports": ["ag", "grep", "rg", "git-grep"],
1000
	\"spec_success": ["error test();","error test (uint x)","error test(uint x, address y)"],
1001
	\"spec_failed": [],
1002
	\})
1003


1004
call s:add_definition('r', {
1005
	\"type": 'variable',
1006
	\"pcre2_regexp": '\bKEYWORD\s*=[^=><]',
1007
	\"emacs_regexp": '\bJJJ\s*=[^=><]',
1008
	\"supports": ["ag", "grep", "rg", "git-grep"],
1009
	\"spec_success": ["test = 1234"],
1010
	\"spec_failed": ["if (test == 1234)"],
1011
	\})
1012


1013
call s:add_definition('r', {
1014
	\"type": 'function',
1015
	\"pcre2_regexp": '\bKEYWORD\s*<-\s*function\b',
1016
	\"emacs_regexp": '\bJJJ\s*<-\s*function\b',
1017
	\"supports": ["ag", "grep", "rg", "git-grep"],
1018
	\"spec_success": ["test <- function","test <- function("],
1019
	\"spec_failed": ["test <- functionX"],
1020
	\})
1021


1022
call s:add_definition('perl', {
1023
	\"type": 'function',
1024
	\"pcre2_regexp": 'sub\s*KEYWORD\s*(\{|\()',
1025
	\"emacs_regexp": 'sub\s*JJJ\s*(\{|\()',
1026
	\"supports": ["ag", "grep", "rg", "git-grep"],
1027
	\"spec_success": ["sub test{","sub test {","sub test(","sub test ("],
1028
	\"spec_failed": [],
1029
	\})
1030


1031
call s:add_definition('perl', {
1032
	\"type": 'variable',
1033
	\"pcre2_regexp": 'KEYWORD\s*=\s*',
1034
	\"emacs_regexp": 'JJJ\s*=\s*',
1035
	\"supports": ["ag", "grep", "rg", "git-grep"],
1036
	\"spec_success": ["$test = 1234"],
1037
	\"spec_failed": [],
1038
	\})
1039


1040
call s:add_definition('tcl', {
1041
	\"type": 'function',
1042
	\"pcre2_regexp": 'proc\s+KEYWORD\s*\{',
1043
	\"emacs_regexp": 'proc\s+JJJ\s*\{',
1044
	\"supports": ["ag", "grep", "rg", "git-grep"],
1045
	\"spec_success": ["proc test{","proc test {"],
1046
	\"spec_failed": [],
1047
	\})
1048


1049
call s:add_definition('tcl', {
1050
	\"type": 'variable',
1051
	\"pcre2_regexp": 'set\s+KEYWORD',
1052
	\"emacs_regexp": 'set\s+JJJ',
1053
	\"supports": ["ag", "grep", "rg", "git-grep"],
1054
	\"spec_success": ["set test 1234"],
1055
	\"spec_failed": [],
1056
	\})
1057


1058
call s:add_definition('tcl', {
1059
	\"type": 'variable',
1060
	\"pcre2_regexp": '(variable|global)\s+KEYWORD',
1061
	\"emacs_regexp": '(variable|global)\s+JJJ',
1062
	\"supports": ["ag", "grep", "rg", "git-grep"],
1063
	\"spec_success": ["variable test","global test"],
1064
	\"spec_failed": [],
1065
	\})
1066


1067
call s:add_definition('shell', {
1068
	\"type": 'function',
1069
	\"pcre2_regexp": 'function\s*KEYWORD\s*',
1070
	\"emacs_regexp": 'function\s*JJJ\s*',
1071
	\"supports": ["ag", "grep", "rg", "git-grep"],
1072
	\"spec_success": ["function test{","function test {","function test () {"],
1073
	\"spec_failed": ["function nottest {"],
1074
	\})
1075


1076
call s:add_definition('shell', {
1077
	\"type": 'function',
1078
	\"pcre2_regexp": 'KEYWORD\(\)\s*\{',
1079
	\"emacs_regexp": 'JJJ\(\)\s*\{',
1080
	\"supports": ["ag", "grep", "rg", "git-grep"],
1081
	\"spec_success": ["test() {"],
1082
	\"spec_failed": ["testx() {"],
1083
	\})
1084


1085
call s:add_definition('shell', {
1086
	\"type": 'variable',
1087
	\"pcre2_regexp": '\bKEYWORD\s*=\s*',
1088
	\"emacs_regexp": '\bJJJ\s*=\s*',
1089
	\"supports": ["ag", "grep", "rg", "git-grep"],
1090
	\"spec_success": ["test = 1234"],
1091
	\"spec_failed": ["blahtest = 1234"],
1092
	\})
1093


1094
call s:add_definition('php', {
1095
	\"type": 'function',
1096
	\"pcre2_regexp": 'function\s*KEYWORD\s*\(',
1097
	\"emacs_regexp": 'function\s*JJJ\s*\(',
1098
	\"supports": ["ag", "grep", "rg", "git-grep"],
1099
	\"spec_success": ["function test()","function test ()"],
1100
	\"spec_failed": [],
1101
	\})
1102


1103
call s:add_definition('php', {
1104
	\"type": 'function',
1105
	\"pcre2_regexp": '\*\s@method\s+[^ 	]+\s+KEYWORD\(',
1106
	\"emacs_regexp": '\*\s@method\s+[^ 	]+\s+JJJ\(',
1107
	\"supports": ["ag", "grep", "rg", "git-grep"],
1108
	\"spec_success": ["/** @method string|false test($a)"," * @method bool test()"],
1109
	\"spec_failed": [],
1110
	\})
1111


1112
call s:add_definition('php', {
1113
	\"type": 'variable',
1114
	\"pcre2_regexp": '(\s|->|\$|::)KEYWORD\s*=\s*',
1115
	\"emacs_regexp": '(\s|->|\$|::)JJJ\s*=\s*',
1116
	\"supports": ["ag", "grep", "rg", "git-grep"],
1117
	\"spec_success": ["$test = 1234","$foo->test = 1234"],
1118
	\"spec_failed": [],
1119
	\})
1120


1121
call s:add_definition('php', {
1122
	\"type": 'variable',
1123
	\"pcre2_regexp": '\*\s@property(-read|-write)?\s+([^ 	]+\s+)&?\$KEYWORD(\s+|$)',
1124
	\"emacs_regexp": '\*\s@property(-read|-write)?\s+([^ 	]+\s+)&?\$JJJ(\s+|$)',
1125
	\"supports": ["ag", "grep", "rg", "git-grep"],
1126
	\"spec_success": ["/** @property string $test","/** @property string $test description for $test property"," * @property-read bool|bool $test"," * @property-write \\ArrayObject<string,resource[]> $test"],
1127
	\"spec_failed": [],
1128
	\})
1129


1130
call s:add_definition('php', {
1131
	\"type": 'trait',
1132
	\"pcre2_regexp": 'trait\s*KEYWORD\s*\{',
1133
	\"emacs_regexp": 'trait\s*JJJ\s*\{',
1134
	\"supports": ["ag", "grep", "rg", "git-grep"],
1135
	\"spec_success": ["trait test{","trait test {"],
1136
	\"spec_failed": [],
1137
	\})
1138


1139
call s:add_definition('php', {
1140
	\"type": 'interface',
1141
	\"pcre2_regexp": 'interface\s*KEYWORD\s*\{',
1142
	\"emacs_regexp": 'interface\s*JJJ\s*\{',
1143
	\"supports": ["ag", "grep", "rg", "git-grep"],
1144
	\"spec_success": ["interface test{","interface test {"],
1145
	\"spec_failed": [],
1146
	\})
1147


1148
call s:add_definition('php', {
1149
	\"type": 'class',
1150
	\"pcre2_regexp": 'class\s*KEYWORD\s*(extends|implements|\{)',
1151
	\"emacs_regexp": 'class\s*JJJ\s*(extends|implements|\{)',
1152
	\"supports": ["ag", "grep", "rg", "git-grep"],
1153
	\"spec_success": ["class test{","class test {","class test extends foo","class test implements foo"],
1154
	\"spec_failed": [],
1155
	\})
1156


1157
call s:add_definition('dart', {
1158
	\"type": 'function',
1159
	\"pcre2_regexp": '\bKEYWORD\s*\([^()]*\)\s*[{]',
1160
	\"emacs_regexp": '\bJJJ\s*\([^()]*\)\s*[{]',
1161
	\"supports": ["ag", "grep", "rg", "git-grep"],
1162
	\"spec_success": ["test(foo) {","test (foo){","test(foo){"],
1163
	\"spec_failed": [],
1164
	\})
1165


1166
call s:add_definition('dart', {
1167
	\"type": 'function',
1168
	\"pcre2_regexp": 'class\s*KEYWORD\s*[\(\{]',
1169
	\"emacs_regexp": 'class\s*JJJ\s*[\(\{]',
1170
	\"supports": ["ag", "grep", "rg", "git-grep"],
1171
	\"spec_success": ["class test(object) {","class test{"],
1172
	\"spec_failed": [],
1173
	\})
1174


1175
call s:add_definition('faust', {
1176
	\"type": 'function',
1177
	\"pcre2_regexp": '\bKEYWORD(\(.+\))*\s*=',
1178
	\"emacs_regexp": '\bJJJ(\(.+\))*\s*=',
1179
	\"supports": ["ag", "grep", "rg", "git-grep"],
1180
	\"spec_success": ["test = osc + 0.5;","test(freq) = osc(freq) + 0.5;"],
1181
	\"spec_failed": [],
1182
	\})
1183


1184
call s:add_definition('fennel', {
1185
	\"type": 'variable',
1186
	\"pcre2_regexp": '\((local|var)\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
1187
	\"emacs_regexp": '\((local|var)\s+JJJ\j',
1188
	\"supports": ["ag", "grep", "rg", "git-grep"],
1189
	\"spec_success": ["(local test (foo)","(var test (foo)"],
1190
	\"spec_failed": [],
1191
	\})
1192


1193
call s:add_definition('fennel', {
1194
	\"type": 'function',
1195
	\"pcre2_regexp": '\(fn\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
1196
	\"emacs_regexp": '\(fn\s+JJJ\j',
1197
	\"supports": ["ag", "grep", "rg", "git-grep"],
1198
	\"spec_success": ["(fn test [foo]"],
1199
	\"spec_failed": ["(fn test? [foo]"],
1200
	\})
1201


1202
call s:add_definition('fennel', {
1203
	\"type": 'function',
1204
	\"pcre2_regexp": '\(macro\s+KEYWORD($|[^a-zA-Z0-9\?\*-])',
1205
	\"emacs_regexp": '\(macro\s+JJJ\j',
1206
	\"supports": ["ag", "grep", "rg", "git-grep"],
1207
	\"spec_success": ["(macro test [foo]"],
1208
	\"spec_failed": [],
1209
	\})
1210


1211
call s:add_definition('fortran', {
1212
	\"type": 'variable',
1213
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+',
1214
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n]+',
1215
	\"supports": ["ag", "grep", "rg", "git-grep"],
1216
	\"spec_success": ["test = 1234"],
1217
	\"spec_failed": ["if (test == 1234)"],
1218
	\})
1219


1220
call s:add_definition('fortran', {
1221
	\"type": 'function',
1222
	\"pcre2_regexp": '\b(function|subroutine|FUNCTION|SUBROUTINE)\s+KEYWORD\b\s*\(',
1223
	\"emacs_regexp": '\b(function|subroutine|FUNCTION|SUBROUTINE)\s+JJJ\b\s*\(',
1224
	\"supports": ["ag", "grep", "rg", "git-grep"],
1225
	\"spec_success": ["function test (foo)","integer function test(foo)","subroutine test (foo, bar)","FUNCTION test (foo)","INTEGER FUNCTION test(foo)","SUBROUTINE test (foo, bar)"],
1226
	\"spec_failed": ["end function test","end subroutine test","END FUNCTION test","END SUBROUTINE test"],
1227
	\})
1228


1229
call s:add_definition('fortran', {
1230
	\"type": 'function',
1231
	\"pcre2_regexp": '^\s*(interface|INTERFACE)\s+KEYWORD\b',
1232
	\"emacs_regexp": '^\s*(interface|INTERFACE)\s+JJJ\b',
1233
	\"supports": ["ag", "grep", "rg", "git-grep"],
1234
	\"spec_success": ["interface test","INTERFACE test"],
1235
	\"spec_failed": ["interface test2","end interface test","INTERFACE test2","END INTERFACE test"],
1236
	\})
1237


1238
call s:add_definition('fortran', {
1239
	\"type": 'type',
1240
	\"pcre2_regexp": '^\s*(module|MODULE)\s+KEYWORD\s*',
1241
	\"emacs_regexp": '^\s*(module|MODULE)\s+JJJ\s*',
1242
	\"supports": ["ag", "grep", "rg", "git-grep"],
1243
	\"spec_success": ["module test","MODULE test"],
1244
	\"spec_failed": ["end module test","END MODULE test"],
1245
	\})
1246


1247
call s:add_definition('go', {
1248
	\"type": 'variable',
1249
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+',
1250
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n]+',
1251
	\"supports": ["ag", "grep", "rg", "git-grep"],
1252
	\"spec_success": ["test = 1234"],
1253
	\"spec_failed": ["if test == 1234 {"],
1254
	\})
1255


1256
call s:add_definition('go', {
1257
	\"type": 'variable',
1258
	\"pcre2_regexp": '\s*\bKEYWORD\s*:=\s*',
1259
	\"emacs_regexp": '\s*\bJJJ\s*:=\s*',
1260
	\"supports": ["ag", "grep", "rg", "git-grep"],
1261
	\"spec_success": ["test := 1234"],
1262
	\"spec_failed": [],
1263
	\})
1264


1265
call s:add_definition('go', {
1266
	\"type": 'function',
1267
	\"pcre2_regexp": 'func\s+\([^\)]*\)\s+KEYWORD\s*\(',
1268
	\"emacs_regexp": 'func\s+\([^\)]*\)\s+JJJ\s*\(',
1269
	\"supports": ["ag", "grep", "rg", "git-grep"],
1270
	\"spec_success": ["func (s *blah) test(filename string) string {"],
1271
	\"spec_failed": [],
1272
	\})
1273


1274
call s:add_definition('go', {
1275
	\"type": 'function',
1276
	\"pcre2_regexp": 'func\s+KEYWORD\s*\(',
1277
	\"emacs_regexp": 'func\s+JJJ\s*\(',
1278
	\"supports": ["ag", "grep", "rg", "git-grep"],
1279
	\"spec_success": ["func test(url string) (string, error)"],
1280
	\"spec_failed": [],
1281
	\})
1282


1283
call s:add_definition('go', {
1284
	\"type": 'type',
1285
	\"pcre2_regexp": 'type\s+KEYWORD\s+struct\s+\{',
1286
	\"emacs_regexp": 'type\s+JJJ\s+struct\s+\{',
1287
	\"supports": ["ag", "grep", "rg", "git-grep"],
1288
	\"spec_success": ["type test struct {"],
1289
	\"spec_failed": [],
1290
	\})
1291


1292
call s:add_definition('javascript', {
1293
	\"type": 'function',
1294
	\"pcre2_regexp": '(service|factory)\([''\"]KEYWORD[''\"]',
1295
	\"emacs_regexp": '(service|factory)\([''\"]JJJ[''\"]',
1296
	\"supports": ["ag", "grep", "rg", "git-grep"],
1297
	\"spec_success": ["module.factory('test', [\"$rootScope\", function($rootScope) {"],
1298
	\"spec_failed": [],
1299
	\})
1300


1301
call s:add_definition('javascript', {
1302
	\"type": 'function',
1303
	\"pcre2_regexp": '\bKEYWORD\s*[=:]\s*\([^\)]*\)\s+=>',
1304
	\"emacs_regexp": '\bJJJ\s*[=:]\s*\([^\)]*\)\s+=>',
1305
	\"supports": ["ag", "grep", "rg", "git-grep"],
1306
	\"spec_success": ["const test = (foo) => ","test: (foo) => {","  test: (foo) => {"],
1307
	\"spec_failed": [],
1308
	\})
1309


1310
call s:add_definition('javascript', {
1311
	\"type": 'function',
1312
	\"pcre2_regexp": '\bKEYWORD\s*\([^()]*\)\s*[{]',
1313
	\"emacs_regexp": '\bJJJ\s*\([^()]*\)\s*[{]',
1314
	\"supports": ["ag", "grep", "rg", "git-grep"],
1315
	\"spec_success": ["test(foo) {","test (foo){","test(foo){"],
1316
	\"spec_failed": ["test = blah.then(function(){"],
1317
	\})
1318


1319
call s:add_definition('javascript', {
1320
	\"type": 'function',
1321
	\"pcre2_regexp": 'class\s*KEYWORD\s*[\(\{]',
1322
	\"emacs_regexp": 'class\s*JJJ\s*[\(\{]',
1323
	\"supports": ["ag", "grep", "rg", "git-grep"],
1324
	\"spec_success": ["class test(object) {","class test{"],
1325
	\"spec_failed": [],
1326
	\})
1327


1328
call s:add_definition('javascript', {
1329
	\"type": 'function',
1330
	\"pcre2_regexp": 'class\s*KEYWORD\s+extends',
1331
	\"emacs_regexp": 'class\s*JJJ\s+extends',
1332
	\"supports": ["ag", "grep", "rg", "git-grep"],
1333
	\"spec_success": ["class test extends Component{"],
1334
	\"spec_failed": [],
1335
	\})
1336


1337
call s:add_definition('javascript', {
1338
	\"type": 'variable',
1339
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+',
1340
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n]+',
1341
	\"supports": ["ag", "grep", "rg", "git-grep"],
1342
	\"spec_success": ["test = 1234","const test = props =>"],
1343
	\"spec_failed": ["if (test === 1234)"],
1344
	\})
1345


1346
call s:add_definition('javascript', {
1347
	\"type": 'variable',
1348
	\"pcre2_regexp": '\bfunction\b[^\(]*\(\s*[^\)]*\bKEYWORD\b\s*,?\s*\)?',
1349
	\"emacs_regexp": '\bfunction\b[^\(]*\(\s*[^\)]*\bJJJ\b\s*,?\s*\)?',
1350
	\"supports": ["ag", "grep", "rg", "git-grep"],
1351
	\"spec_success": ["function (test)","function (test, blah)","function somefunc(test, blah) {","function(blah, test)"],
1352
	\"spec_failed": ["function (testLen)","function (test1, blah)","function somefunc(testFirst, blah) {","function(blah, testLast)","function (Lentest)","function (blahtest, blah)","function somefunc(Firsttest, blah) {","function(blah, Lasttest)"],
1353
	\})
1354


1355
call s:add_definition('javascript', {
1356
	\"type": 'function',
1357
	\"pcre2_regexp": 'function\s*KEYWORD\s*\(',
1358
	\"emacs_regexp": 'function\s*JJJ\s*\(',
1359
	\"supports": ["ag", "grep", "rg", "git-grep"],
1360
	\"spec_success": ["function test()","function test ()"],
1361
	\"spec_failed": [],
1362
	\})
1363


1364
call s:add_definition('javascript', {
1365
	\"type": 'function',
1366
	\"pcre2_regexp": '\bKEYWORD\s*:\s*function\s*\(',
1367
	\"emacs_regexp": '\bJJJ\s*:\s*function\s*\(',
1368
	\"supports": ["ag", "grep", "rg", "git-grep"],
1369
	\"spec_success": ["test: function()"],
1370
	\"spec_failed": [],
1371
	\})
1372


1373
call s:add_definition('javascript', {
1374
	\"type": 'function',
1375
	\"pcre2_regexp": '\bKEYWORD\s*=\s*function\s*\(',
1376
	\"emacs_regexp": '\bJJJ\s*=\s*function\s*\(',
1377
	\"supports": ["ag", "grep", "rg", "git-grep"],
1378
	\"spec_success": ["test = function()"],
1379
	\"spec_failed": [],
1380
	\})
1381


1382
call s:add_definition('hcl', {
1383
	\"type": 'block',
1384
	\"pcre2_regexp": '(variable|output|module)\s*\"KEYWORD\"\s*\{',
1385
	\"emacs_regexp": '(variable|output|module)\s*\"JJJ\"\s*\{',
1386
	\"supports": ["ag", "grep", "rg", "git-grep"],
1387
	\"spec_success": ["variable \"test\" {","output \"test\" {","module \"test\" {"],
1388
	\"spec_failed": [],
1389
	\})
1390


1391
call s:add_definition('hcl', {
1392
	\"type": 'block',
1393
	\"pcre2_regexp": '(data|resource)\s*\"\w+\"\s*\"KEYWORD\"\s*\{',
1394
	\"emacs_regexp": '(data|resource)\s*\"\w+\"\s*\"JJJ\"\s*\{',
1395
	\"supports": ["ag", "grep", "rg", "git-grep"],
1396
	\"spec_success": ["data \"openstack_images_image_v2\" \"test\" {","resource \"google_compute_instance\" \"test\" {"],
1397
	\"spec_failed": [],
1398
	\})
1399


1400
call s:add_definition('typescript', {
1401
	\"type": 'function',
1402
	\"pcre2_regexp": '(service|factory)\([''\"]KEYWORD[''\"]',
1403
	\"emacs_regexp": '(service|factory)\([''\"]JJJ[''\"]',
1404
	\"supports": ["ag", "grep", "rg", "git-grep"],
1405
	\"spec_success": ["module.factory('test', [\"$rootScope\", function($rootScope) {"],
1406
	\"spec_failed": [],
1407
	\})
1408


1409
call s:add_definition('typescript', {
1410
	\"type": 'function',
1411
	\"pcre2_regexp": '\bKEYWORD\s*[=:]\s*\([^\)]*\)\s+=>',
1412
	\"emacs_regexp": '\bJJJ\s*[=:]\s*\([^\)]*\)\s+=>',
1413
	\"supports": ["ag", "grep", "rg", "git-grep"],
1414
	\"spec_success": ["const test = (foo) => ","test: (foo) => {","  test: (foo) => {"],
1415
	\"spec_failed": [],
1416
	\})
1417


1418
call s:add_definition('typescript', {
1419
	\"type": 'function',
1420
	\"pcre2_regexp": '\bKEYWORD\s*\([^()]*\)\s*[{]',
1421
	\"emacs_regexp": '\bJJJ\s*\([^()]*\)\s*[{]',
1422
	\"supports": ["ag", "grep", "rg", "git-grep"],
1423
	\"spec_success": ["test(foo) {","test (foo){","test(foo){"],
1424
	\"spec_failed": ["test = blah.then(function(){"],
1425
	\})
1426


1427
call s:add_definition('typescript', {
1428
	\"type": 'function',
1429
	\"pcre2_regexp": 'class\s*KEYWORD\s*[\(\{]',
1430
	\"emacs_regexp": 'class\s*JJJ\s*[\(\{]',
1431
	\"supports": ["ag", "grep", "rg", "git-grep"],
1432
	\"spec_success": ["class test{"],
1433
	\"spec_failed": [],
1434
	\})
1435


1436
call s:add_definition('typescript', {
1437
	\"type": 'function',
1438
	\"pcre2_regexp": 'class\s*KEYWORD\s+extends',
1439
	\"emacs_regexp": 'class\s*JJJ\s+extends',
1440
	\"supports": ["ag", "grep", "rg", "git-grep"],
1441
	\"spec_success": ["class test extends Component{"],
1442
	\"spec_failed": [],
1443
	\})
1444


1445
call s:add_definition('typescript', {
1446
	\"type": 'function',
1447
	\"pcre2_regexp": 'function\s*KEYWORD\s*\(',
1448
	\"emacs_regexp": 'function\s*JJJ\s*\(',
1449
	\"supports": ["ag", "grep", "rg", "git-grep"],
1450
	\"spec_success": ["function test()","function test ()"],
1451
	\"spec_failed": [],
1452
	\})
1453


1454
call s:add_definition('typescript', {
1455
	\"type": 'function',
1456
	\"pcre2_regexp": '\bKEYWORD\s*:\s*function\s*\(',
1457
	\"emacs_regexp": '\bJJJ\s*:\s*function\s*\(',
1458
	\"supports": ["ag", "grep", "rg", "git-grep"],
1459
	\"spec_success": ["test: function()"],
1460
	\"spec_failed": [],
1461
	\})
1462


1463
call s:add_definition('typescript', {
1464
	\"type": 'function',
1465
	\"pcre2_regexp": '\bKEYWORD\s*=\s*function\s*\(',
1466
	\"emacs_regexp": '\bJJJ\s*=\s*function\s*\(',
1467
	\"supports": ["ag", "grep", "rg", "git-grep"],
1468
	\"spec_success": ["test = function()"],
1469
	\"spec_failed": [],
1470
	\})
1471


1472
call s:add_definition('typescript', {
1473
	\"type": 'variable',
1474
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+',
1475
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n]+',
1476
	\"supports": ["ag", "grep", "rg", "git-grep"],
1477
	\"spec_success": ["test = 1234","const test = props =>"],
1478
	\"spec_failed": ["if (test === 1234)"],
1479
	\})
1480


1481
call s:add_definition('typescript', {
1482
	\"type": 'variable',
1483
	\"pcre2_regexp": '\bfunction\b[^\(]*\(\s*[^\)]*\bKEYWORD\b\s*,?\s*\)?',
1484
	\"emacs_regexp": '\bfunction\b[^\(]*\(\s*[^\)]*\bJJJ\b\s*,?\s*\)?',
1485
	\"supports": ["ag", "grep", "rg", "git-grep"],
1486
	\"spec_success": ["function (test)","function (test, blah)","function somefunc(test, blah) {","function(blah, test)"],
1487
	\"spec_failed": ["function (testLen)","function (test1, blah)","function somefunc(testFirst, blah) {","function(blah, testLast)","function (Lentest)","function (blahtest, blah)","function somefunc(Firsttest, blah) {","function(blah, Lasttest)"],
1488
	\})
1489


1490
call s:add_definition('julia', {
1491
	\"type": 'function',
1492
	\"pcre2_regexp": '(@noinline|@inline)?\s*function\s*KEYWORD(\{[^\}]*\})?\(',
1493
	\"emacs_regexp": '(@noinline|@inline)?\s*function\s*JJJ(\{[^\}]*\})?\(',
1494
	\"supports": ["ag", "grep", "rg", "git-grep"],
1495
	\"spec_success": ["function test()","@inline function test()","function test{T}(h)"],
1496
	\"spec_failed": [],
1497
	\})
1498


1499
call s:add_definition('julia', {
1500
	\"type": 'function',
1501
	\"pcre2_regexp": '(@noinline|@inline)?KEYWORD(\{[^\}]*\})?\([^\)]*\)s*=',
1502
	\"emacs_regexp": '(@noinline|@inline)?JJJ(\{[^\}]*\})?\([^\)]*\)s*=',
1503
	\"supports": ["ag", "grep", "rg", "git-grep"],
1504
	\"spec_success": ["test(a)=1","test(a,b)=1*8","@noinline test()=1","test{T}(x)=x"],
1505
	\"spec_failed": [],
1506
	\})
1507


1508
call s:add_definition('julia', {
1509
	\"type": 'function',
1510
	\"pcre2_regexp": 'macro\s*KEYWORD\(',
1511
	\"emacs_regexp": 'macro\s*JJJ\(',
1512
	\"supports": ["ag", "grep", "rg", "git-grep"],
1513
	\"spec_success": ["macro test(a)=1"," macro test(a,b)=1*8"],
1514
	\"spec_failed": [],
1515
	\})
1516


1517
call s:add_definition('julia', {
1518
	\"type": 'variable',
1519
	\"pcre2_regexp": 'const\s+KEYWORD\b',
1520
	\"emacs_regexp": 'const\s+JJJ\b',
1521
	\"supports": ["ag", "rg"],
1522
	\"spec_success": ["const test = "],
1523
	\"spec_failed": [],
1524
	\})
1525


1526
call s:add_definition('julia', {
1527
	\"type": 'type',
1528
	\"pcre2_regexp": '(mutable)?\s*struct\s*KEYWORD',
1529
	\"emacs_regexp": '(mutable)?\s*struct\s*JJJ',
1530
	\"supports": ["ag", "rg"],
1531
	\"spec_success": ["struct test"],
1532
	\"spec_failed": [],
1533
	\})
1534


1535
call s:add_definition('julia', {
1536
	\"type": 'type',
1537
	\"pcre2_regexp": '(type|immutable|abstract)\s*KEYWORD',
1538
	\"emacs_regexp": '(type|immutable|abstract)\s*JJJ',
1539
	\"supports": ["ag", "rg"],
1540
	\"spec_success": ["type test","immutable test","abstract test <:Testable"],
1541
	\"spec_failed": [],
1542
	\})
1543


1544
call s:add_definition('haskell', {
1545
	\"type": 'module',
1546
	\"pcre2_regexp": '^module\s+KEYWORD\s+',
1547
	\"emacs_regexp": '^module\s+JJJ\s+',
1548
	\"supports": ["rg", "ag"],
1549
	\"spec_success": ["module Test (exportA, exportB) where"],
1550
	\"spec_failed": [],
1551
	\})
1552


1553
call s:add_definition('haskell', {
1554
	\"type": 'top level function',
1555
	\"pcre2_regexp": '^\bKEYWORD(?!(\s+::))\s+((.|\s)*?)=\s+',
1556
	\"emacs_regexp": '^\bJJJ(?!(\s+::))\s+((.|\s)*?)=\s+',
1557
	\"supports": ["rg", "ag"],
1558
	\"spec_success": ["test n = n * 2","test X{..} (Y a b c) \n bcd \n =\n x * y","test ab cd e@Datatype {..} (Another thing, inTheRow) = \n undefined","test = runRealBasedMode @ext @ctx identity identity","test unwrap wrap nr@Naoeu {..} (Action action, specSpecs) = \n    undefined"],
1559
	\"spec_failed": ["nottest n = n * 2","let testnot x y = x * y","test $ y z","let test a o = mda","test :: Sometype -> AnotherType aoeu kek = undefined"],
1560
	\})
1561


1562
call s:add_definition('haskell', {
1563
	\"type": 'type-like',
1564
	\"pcre2_regexp": '^\s*((data(\s+family)?)|(newtype)|(type(\s+family)?))\s+KEYWORD\s+',
1565
	\"emacs_regexp": '^\s*((data(\s+family)?)|(newtype)|(type(\s+family)?))\s+JJJ\s+',
1566
	\"supports": ["rg", "ag"],
1567
	\"spec_success": ["newtype Test a = Something { b :: Kek }","data Test a b = Somecase a | Othercase b","type family Test (x :: *) (xs :: [*]) :: Nat where","data family Test ","type Test = TestAlias"],
1568
	\"spec_failed": ["newtype NotTest a = NotTest (Not a)","data TestNot b = Aoeu"],
1569
	\})
1570


1571
call s:add_definition('haskell', {
1572
	\"type": '(data)type constructor 1',
1573
	\"pcre2_regexp": '(data|newtype)\s{1,3}(?!KEYWORD\s+)([^=]{1,40})=((\s{0,3}KEYWORD\s+)|([^=]{0,500}?((?<!(-- ))\|\s{0,3}KEYWORD\s+)))',
1574
	\"emacs_regexp": '(data|newtype)\s{1,3}(?!JJJ\s+)([^=]{1,40})=((\s{0,3}JJJ\s+)|([^=]{0,500}?((?<!(-- ))\|\s{0,3}JJJ\s+)))',
1575
	\"supports": ["rg", "ag"],
1576
	\"spec_success": ["data Something a = Test { b :: Kek }","data Mem a = TrueMem { b :: Kek } | Test (Mem Int) deriving Mda","newtype SafeTest a = Test (Kek a) deriving (YonedaEmbedding)"],
1577
	\"spec_failed": ["data Test = Test { b :: Kek }"],
1578
	\})
1579


1580
call s:add_definition('haskell', {
1581
	\"type": 'data/newtype record field',
1582
	\"pcre2_regexp": '(data|newtype)([^=]*)=[^=]*?({([^=}]*?)(\bKEYWORD)\s+::[^=}]+})',
1583
	\"emacs_regexp": '(data|newtype)([^=]*)=[^=]*?({([^=}]*?)(\bJJJ)\s+::[^=}]+})',
1584
	\"supports": ["rg", "ag"],
1585
	\"spec_success": ["data Mem = Mem { \n mda :: A \n  , test :: Kek \n , \n aoeu :: E \n }","data Mem = Mem { \n test :: A \n  , mda :: Kek \n , \n aoeu :: E \n }","data Mem = Mem { \n mda :: A \n  , aoeu :: Kek \n , \n test :: E \n }","data Mem = Mem { test :: Kek } deriving Mda","data Mem = Mem { \n test :: Kek \n } deriving Mda","newtype Mem = Mem { \n test :: Kek \n } deriving (Eq)","newtype Mem = Mem { -- | Some docs \n test :: Kek -- ^ More docs } deriving Eq","newtype Mem = Mem { test :: Kek } deriving (Eq,Monad)","newtype NewMem = OldMem { test :: [Tx] }","newtype BlockHeaderList ssc = BHL\n { test :: ([Aoeu a], [Ssss])\n    } deriving (Eq)"],
1586
	\"spec_failed": ["data Heh = Mda { sometest :: Kek, testsome :: Mem }"],
1587
	\})
1588


1589
call s:add_definition('haskell', {
1590
	\"type": 'typeclass',
1591
	\"pcre2_regexp": '^class\s+(.+=>\s*)?KEYWORD\s+',
1592
	\"emacs_regexp": '^class\s+(.+=>\s*)?JJJ\s+',
1593
	\"supports": ["rg", "ag"],
1594
	\"spec_success": ["class (Constr1 m, Constr 2) => Test (Kek a) where","class  Test  (Veryovka a)  where "],
1595
	\"spec_failed": ["class Test2 (Kek a) where","class MakeTest (AoeuTest x y z) where"],
1596
	\})
1597


1598
call s:add_definition('ocaml', {
1599
	\"type": 'type',
1600
	\"pcre2_regexp": '^\s*(and|type)\s+.*\bKEYWORD\b',
1601
	\"emacs_regexp": '^\s*(and|type)\s+.*\bJJJ\b',
1602
	\"supports": ["ag", "rg"],
1603
	\"spec_success": ["type test =","and test =","type 'a test =","type ('a, _, 'c) test"],
1604
	\"spec_failed": [],
1605
	\})
1606


1607
call s:add_definition('ocaml', {
1608
	\"type": 'variable',
1609
	\"pcre2_regexp": 'let\s+KEYWORD\b',
1610
	\"emacs_regexp": 'let\s+JJJ\b',
1611
	\"supports": ["ag", "rg"],
1612
	\"spec_success": ["let test =","let test x y ="],
1613
	\"spec_failed": [],
1614
	\})
1615


1616
call s:add_definition('ocaml', {
1617
	\"type": 'variable',
1618
	\"pcre2_regexp": 'let\s+rec\s+KEYWORD\b',
1619
	\"emacs_regexp": 'let\s+rec\s+JJJ\b',
1620
	\"supports": ["ag", "rg"],
1621
	\"spec_success": ["let rec test =","let rec  test x y ="],
1622
	\"spec_failed": [],
1623
	\})
1624


1625
call s:add_definition('ocaml', {
1626
	\"type": 'variable',
1627
	\"pcre2_regexp": '\s*val\s*\bKEYWORD\b\s*',
1628
	\"emacs_regexp": '\s*val\s*\bJJJ\b\s*',
1629
	\"supports": ["ag", "rg"],
1630
	\"spec_success": ["val test"],
1631
	\"spec_failed": [],
1632
	\})
1633


1634
call s:add_definition('ocaml', {
1635
	\"type": 'module',
1636
	\"pcre2_regexp": '^\s*module\s*\bKEYWORD\b',
1637
	\"emacs_regexp": '^\s*module\s*\bJJJ\b',
1638
	\"supports": ["ag", "rg"],
1639
	\"spec_success": ["module test ="],
1640
	\"spec_failed": [],
1641
	\})
1642


1643
call s:add_definition('ocaml', {
1644
	\"type": 'module',
1645
	\"pcre2_regexp": '^\s*module\s*type\s*\bKEYWORD\b',
1646
	\"emacs_regexp": '^\s*module\s*type\s*\bJJJ\b',
1647
	\"supports": ["ag", "rg"],
1648
	\"spec_success": ["module type test ="],
1649
	\"spec_failed": [],
1650
	\})
1651


1652
call s:add_definition('lua', {
1653
	\"type": 'variable',
1654
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+',
1655
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n]+',
1656
	\"supports": ["ag", "grep", "rg", "git-grep"],
1657
	\"spec_success": ["test = 1234"],
1658
	\"spec_failed": ["if test === 1234"],
1659
	\})
1660


1661
call s:add_definition('lua', {
1662
	\"type": 'variable',
1663
	\"pcre2_regexp": '\bfunction\b[^\(]*\(\s*[^\)]*\bKEYWORD\b\s*,?\s*\)?',
1664
	\"emacs_regexp": '\bfunction\b[^\(]*\(\s*[^\)]*\bJJJ\b\s*,?\s*\)?',
1665
	\"supports": ["ag", "grep", "rg", "git-grep"],
1666
	\"spec_success": ["function (test)","function (test, blah)","function somefunc(test, blah)","function(blah, test)"],
1667
	\"spec_failed": ["function (testLen)","function (test1, blah)","function somefunc(testFirst, blah)","function(blah, testLast)","function (Lentest)","function (blahtest, blah)","function somefunc(Firsttest, blah)","function(blah, Lasttest)"],
1668
	\})
1669


1670
call s:add_definition('lua', {
1671
	\"type": 'function',
1672
	\"pcre2_regexp": 'function\s*KEYWORD\s*\(',
1673
	\"emacs_regexp": 'function\s*JJJ\s*\(',
1674
	\"supports": ["ag", "grep", "rg", "git-grep"],
1675
	\"spec_success": ["function test()","function test ()"],
1676
	\"spec_failed": [],
1677
	\})
1678


1679
call s:add_definition('lua', {
1680
	\"type": 'function',
1681
	\"pcre2_regexp": 'function\s*.+[.:]KEYWORD\s*\(',
1682
	\"emacs_regexp": 'function\s*.+[.:]JJJ\s*\(',
1683
	\"supports": ["ag", "grep", "rg", "git-grep"],
1684
	\"spec_success": ["function MyClass.test()","function MyClass.test ()","function MyClass:test()","function MyClass:test ()"],
1685
	\"spec_failed": [],
1686
	\})
1687


1688
call s:add_definition('lua', {
1689
	\"type": 'function',
1690
	\"pcre2_regexp": '\bKEYWORD\s*=\s*function\s*\(',
1691
	\"emacs_regexp": '\bJJJ\s*=\s*function\s*\(',
1692
	\"supports": ["ag", "grep", "rg", "git-grep"],
1693
	\"spec_success": ["test = function()"],
1694
	\"spec_failed": [],
1695
	\})
1696


1697
call s:add_definition('lua', {
1698
	\"type": 'function',
1699
	\"pcre2_regexp": '\b.+\.KEYWORD\s*=\s*function\s*\(',
1700
	\"emacs_regexp": '\b.+\.JJJ\s*=\s*function\s*\(',
1701
	\"supports": ["ag", "grep", "rg", "git-grep"],
1702
	\"spec_success": ["MyClass.test = function()"],
1703
	\"spec_failed": [],
1704
	\})
1705


1706
call s:add_definition('rust', {
1707
	\"type": 'variable',
1708
	\"pcre2_regexp": '\blet\s+(\([^=\n]*)?(muts+)?KEYWORD([^=\n]*\))?(:\s*[^=\n]+)?\s*=\s*[^=\n]+',
1709
	\"emacs_regexp": '\blet\s+(\([^=\n]*)?(muts+)?JJJ([^=\n]*\))?(:\s*[^=\n]+)?\s*=\s*[^=\n]+',
1710
	\"supports": ["ag", "grep", "rg", "git-grep"],
1711
	\"spec_success": ["let test = 1234;","let test: u32 = 1234;","let test: Vec<u32> = Vec::new();","let mut test = 1234;","let mut test: Vec<u32> = Vec::new();","let (a, test, b) = (1, 2, 3);","let (a, mut test, mut b) = (1, 2, 3);","let (mut a, mut test): (u32, usize) = (1, 2);"],
1712
	\"spec_failed": [],
1713
	\})
1714


1715
call s:add_definition('rust', {
1716
	\"type": 'variable',
1717
	\"pcre2_regexp": '\bconst\s+KEYWORD:\s*[^=\n]+\s*=[^=\n]+',
1718
	\"emacs_regexp": '\bconst\s+JJJ:\s*[^=\n]+\s*=[^=\n]+',
1719
	\"supports": ["ag", "grep", "rg", "git-grep"],
1720
	\"spec_success": ["const test: u32 = 1234;"],
1721
	\"spec_failed": [],
1722
	\})
1723


1724
call s:add_definition('rust', {
1725
	\"type": 'variable',
1726
	\"pcre2_regexp": '\bstatic\s+(mut\s+)?KEYWORD:\s*[^=\n]+\s*=[^=\n]+',
1727
	\"emacs_regexp": '\bstatic\s+(mut\s+)?JJJ:\s*[^=\n]+\s*=[^=\n]+',
1728
	\"supports": ["ag", "grep", "rg", "git-grep"],
1729
	\"spec_success": ["static test: u32 = 1234;","static mut test: u32 = 1234;"],
1730
	\"spec_failed": [],
1731
	\})
1732


1733
call s:add_definition('rust', {
1734
	\"type": 'variable',
1735
	\"pcre2_regexp": '\bfn\s+.+\s*\((.+,\s+)?KEYWORD:\s*[^=\n]+\s*(,\s*.+)*\)',
1736
	\"emacs_regexp": '\bfn\s+.+\s*\((.+,\s+)?JJJ:\s*[^=\n]+\s*(,\s*.+)*\)',
1737
	\"supports": ["ag", "grep", "rg", "git-grep"],
1738
	\"spec_success": ["fn abc(test: u32) -> u32 {","fn abc(x: u32, y: u32, test: Vec<u32>, z: Vec<Foo>)","fn abc(x: u32, y: u32, test: &mut Vec<u32>, z: Vec<Foo>)"],
1739
	\"spec_failed": [],
1740
	\})
1741


1742
call s:add_definition('rust', {
1743
	\"type": 'variable',
1744
	\"pcre2_regexp": '(if|while)\s+let\s+([^=\n]+)?(mut\s+)?KEYWORD([^=\n\(]+)?\s*=\s*[^=\n]+',
1745
	\"emacs_regexp": '(if|while)\s+let\s+([^=\n]+)?(mut\s+)?JJJ([^=\n\(]+)?\s*=\s*[^=\n]+',
1746
	\"supports": ["ag", "grep", "rg", "git-grep"],
1747
	\"spec_success": ["if let Some(test) = abc() {","if let Some(mut test) = abc() {","if let Ok(test) = abc() {","if let Ok(mut test) = abc() {","if let Foo(mut test) = foo {","if let test = abc() {","if let Some(test) = abc()","if let Some((a, test, b)) = abc()","while let Some(test) = abc() {","while let Some(mut test) = abc() {","while let Ok(test) = abc() {","while let Ok(mut test) = abc() {"],
1748
	\"spec_failed": ["while let test(foo) = abc() {"],
1749
	\})
1750


1751
call s:add_definition('rust', {
1752
	\"type": 'variable',
1753
	\"pcre2_regexp": 'struct\s+[^\n{]+[{][^}]*(\s*KEYWORD\s*:\s*[^\n},]+)[^}]*}',
1754
	\"emacs_regexp": 'struct\s+[^\n{]+[{][^}]*(\s*JJJ\s*:\s*[^\n},]+)[^}]*}',
1755
	\"supports": ["ag", "grep", "rg", "git-grep"],
1756
	\"spec_success": ["struct Foo { abc: u32, test: Vec<String>, b: PathBuf }","struct Foo<T>{test:Vec<T>}","struct FooBar<'a> { test: Vec<String> }"],
1757
	\"spec_failed": ["struct Foo { abc: u32, b: Vec<String> }","/// ... construct the equivalent ...\nfn abc() {\n"],
1758
	\})
1759


1760
call s:add_definition('rust', {
1761
	\"type": 'variable',
1762
	\"pcre2_regexp": 'enum\s+[^\n{]+\s*[{][^}]*\bKEYWORD\b[^}]*}',
1763
	\"emacs_regexp": 'enum\s+[^\n{]+\s*[{][^}]*\bJJJ\b[^}]*}',
1764
	\"supports": ["ag", "grep", "rg", "git-grep"],
1765
	\"spec_success": ["enum Foo { VariantA, test, VariantB(u32) }","enum Foo<T> { test(T) }","enum BadStyle{test}","enum Foo32 { Bar, testing, test(u8) }"],
1766
	\"spec_failed": ["enum Foo { testing }"],
1767
	\})
1768


1769
call s:add_definition('rust', {
1770
	\"type": 'function',
1771
	\"pcre2_regexp": '\bfn\s+KEYWORD\s*\(',
1772
	\"emacs_regexp": '\bfn\s+JJJ\s*\(',
1773
	\"supports": ["ag", "grep", "rg", "git-grep"],
1774
	\"spec_success": ["fn test(asdf: u32)","fn test()","pub fn test()"],
1775
	\"spec_failed": [],
1776
	\})
1777


1778
call s:add_definition('rust', {
1779
	\"type": 'function',
1780
	\"pcre2_regexp": '\bmacro_rules!\s+KEYWORD',
1781
	\"emacs_regexp": '\bmacro_rules!\s+JJJ',
1782
	\"supports": ["ag", "grep", "rg", "git-grep"],
1783
	\"spec_success": ["macro_rules! test"],
1784
	\"spec_failed": [],
1785
	\})
1786


1787
call s:add_definition('rust', {
1788
	\"type": 'type',
1789
	\"pcre2_regexp": 'struct\s+KEYWORD\s*[{\(]?',
1790
	\"emacs_regexp": 'struct\s+JJJ\s*[{\(]?',
1791
	\"supports": ["ag", "grep", "rg", "git-grep"],
1792
	\"spec_success": ["struct test(u32, u32)","struct test;","struct test { abc: u32, def: Vec<String> }"],
1793
	\"spec_failed": [],
1794
	\})
1795


1796
call s:add_definition('rust', {
1797
	\"type": 'type',
1798
	\"pcre2_regexp": 'trait\s+KEYWORD\s*[{]?',
1799
	\"emacs_regexp": 'trait\s+JJJ\s*[{]?',
1800
	\"supports": ["ag", "grep", "rg", "git-grep"],
1801
	\"spec_success": ["trait test;","trait test { fn abc() -> u32; }"],
1802
	\"spec_failed": [],
1803
	\})
1804


1805
call s:add_definition('rust', {
1806
	\"type": 'type',
1807
	\"pcre2_regexp": '\btype\s+KEYWORD([^=\n]+)?\s*=[^=\n]+;',
1808
	\"emacs_regexp": '\btype\s+JJJ([^=\n]+)?\s*=[^=\n]+;',
1809
	\"supports": ["ag", "grep", "rg", "git-grep"],
1810
	\"spec_success": ["type test<T> = Rc<RefCell<T>>;","type test = Arc<RwLock<Vec<u32>>>;"],
1811
	\"spec_failed": [],
1812
	\})
1813


1814
call s:add_definition('rust', {
1815
	\"type": 'type',
1816
	\"pcre2_regexp": 'impl\s+((\w+::)*\w+\s+for\s+)?(\w+::)*KEYWORD\s+[{]?',
1817
	\"emacs_regexp": 'impl\s+((\w+::)*\w+\s+for\s+)?(\w+::)*JJJ\s+[{]?',
1818
	\"supports": ["ag", "grep", "rg", "git-grep"],
1819
	\"spec_success": ["impl test {","impl abc::test {","impl std::io::Read for test {","impl std::io::Read for abc::test {"],
1820
	\"spec_failed": [],
1821
	\})
1822


1823
call s:add_definition('rust', {
1824
	\"type": 'type',
1825
	\"pcre2_regexp": 'mod\s+KEYWORD\s*[{]?',
1826
	\"emacs_regexp": 'mod\s+JJJ\s*[{]?',
1827
	\"supports": ["ag", "grep", "rg", "git-grep"],
1828
	\"spec_success": ["mod test;","pub mod test {"],
1829
	\"spec_failed": [],
1830
	\})
1831


1832
call s:add_definition('elixir', {
1833
	\"type": 'function',
1834
	\"pcre2_regexp": '\bdef(p)?\s+KEYWORD\s*[ ,\(]',
1835
	\"emacs_regexp": '\bdef(p)?\s+JJJ\s*[ ,\(]',
1836
	\"supports": ["ag", "grep", "rg", "git-grep"],
1837
	\"spec_success": ["def test do","def test, do:","def test() do","def test(), do:","def test(foo, bar) do","def test(foo, bar), do:","defp test do","defp test(), do:"],
1838
	\"spec_failed": [],
1839
	\})
1840


1841
call s:add_definition('elixir', {
1842
	\"type": 'variable',
1843
	\"pcre2_regexp": '\s*KEYWORD\s*=[^=\n]+',
1844
	\"emacs_regexp": '\s*JJJ\s*=[^=\n]+',
1845
	\"supports": ["ag", "grep", "rg", "git-grep"],
1846
	\"spec_success": ["test = 1234"],
1847
	\"spec_failed": ["if test == 1234"],
1848
	\})
1849


1850
call s:add_definition('elixir', {
1851
	\"type": 'module',
1852
	\"pcre2_regexp": 'defmodule\s+(\w+\.)*KEYWORD\s+',
1853
	\"emacs_regexp": 'defmodule\s+(\w+\.)*JJJ\s+',
1854
	\"supports": ["ag", "grep", "rg", "git-grep"],
1855
	\"spec_success": ["defmodule test do","defmodule Foo.Bar.test do"],
1856
	\"spec_failed": [],
1857
	\})
1858


1859
call s:add_definition('elixir', {
1860
	\"type": 'module',
1861
	\"pcre2_regexp": 'defprotocol\s+(\w+\.)*KEYWORD\s+',
1862
	\"emacs_regexp": 'defprotocol\s+(\w+\.)*JJJ\s+',
1863
	\"supports": ["ag", "grep", "rg", "git-grep"],
1864
	\"spec_success": ["defprotocol test do","defprotocol Foo.Bar.test do"],
1865
	\"spec_failed": [],
1866
	\})
1867


1868
call s:add_definition('erlang', {
1869
	\"type": 'function',
1870
	\"pcre2_regexp": '^KEYWORD\b\s*\(',
1871
	\"emacs_regexp": '^JJJ\b\s*\(',
1872
	\"supports": ["ag", "grep", "rg", "git-grep"],
1873
	\"spec_success": ["test() ->","test()->","test(Foo) ->","test (Foo,Bar) ->","test(Foo, Bar)->"],
1874
	\"spec_failed": [],
1875
	\})
1876


1877
call s:add_definition('erlang', {
1878
	\"type": 'variable',
1879
	\"pcre2_regexp": '\s*KEYWORD\s*=[^:=\n]+',
1880
	\"emacs_regexp": '\s*JJJ\s*=[^:=\n]+',
1881
	\"supports": ["ag", "grep", "rg", "git-grep"],
1882
	\"spec_success": ["test = 1234"],
1883
	\"spec_failed": ["if test =:= 1234","if test == 1234"],
1884
	\})
1885


1886
call s:add_definition('erlang', {
1887
	\"type": 'module',
1888
	\"pcre2_regexp": '^-module\(KEYWORD\)',
1889
	\"emacs_regexp": '^-module\(JJJ\)',
1890
	\"supports": ["ag", "grep", "rg", "git-grep"],
1891
	\"spec_success": ["-module(test)."],
1892
	\"spec_failed": [],
1893
	\})
1894


1895
call s:add_definition('scss', {
1896
	\"type": 'function',
1897
	\"pcre2_regexp": '@mixin\sKEYWORD\b\s*\(',
1898
	\"emacs_regexp": '@mixin\sJJJ\b\s*\(',
1899
	\"supports": ["ag", "grep", "rg", "git-grep"],
1900
	\"spec_success": ["@mixin test()"],
1901
	\"spec_failed": [],
1902
	\})
1903


1904
call s:add_definition('scss', {
1905
	\"type": 'function',
1906
	\"pcre2_regexp": '@function\sKEYWORD\b\s*\(',
1907
	\"emacs_regexp": '@function\sJJJ\b\s*\(',
1908
	\"supports": ["ag", "grep", "rg", "git-grep"],
1909
	\"spec_success": ["@function test()"],
1910
	\"spec_failed": [],
1911
	\})
1912


1913
call s:add_definition('scss', {
1914
	\"type": 'variable',
1915
	\"pcre2_regexp": 'KEYWORD\s*:\s*',
1916
	\"emacs_regexp": 'JJJ\s*:\s*',
1917
	\"supports": ["ag", "grep", "rg", "git-grep"],
1918
	\"spec_success": ["test  :"],
1919
	\"spec_failed": [],
1920
	\})
1921


1922
call s:add_definition('sml', {
1923
	\"type": 'type',
1924
	\"pcre2_regexp": '\s*(data)?type\s+.*\bKEYWORD\b',
1925
	\"emacs_regexp": '\s*(data)?type\s+.*\bJJJ\b',
1926
	\"supports": ["ag", "grep", "rg", "git-grep"],
1927
	\"spec_success": ["datatype test =","datatype test=","datatype 'a test =","type test =","type 'a test =","type 'a test","type test"],
1928
	\"spec_failed": ["datatypetest ="],
1929
	\})
1930


1931
call s:add_definition('sml', {
1932
	\"type": 'variable',
1933
	\"pcre2_regexp": '\s*val\s+\bKEYWORD\b',
1934
	\"emacs_regexp": '\s*val\s+\bJJJ\b',
1935
	\"supports": ["ag", "grep", "rg", "git-grep"],
1936
	\"spec_success": ["val test =","val test=","val test : bool"],
1937
	\"spec_failed": [],
1938
	\})
1939


1940
call s:add_definition('sml', {
1941
	\"type": 'function',
1942
	\"pcre2_regexp": '\s*fun\s+\bKEYWORD\b.*\s*=',
1943
	\"emacs_regexp": '\s*fun\s+\bJJJ\b.*\s*=',
1944
	\"supports": ["ag", "grep", "rg", "git-grep"],
1945
	\"spec_success": ["fun test list =","fun test (STRING_NIL, a) =","fun test ((s1,s2): 'a queue) : 'a * 'a queue =","fun test (var : q) : int =","fun test f e xs ="],
1946
	\"spec_failed": [],
1947
	\})
1948


1949
call s:add_definition('sml', {
1950
	\"type": 'module',
1951
	\"pcre2_regexp": '\s*(structure|signature|functor)\s+\bKEYWORD\b',
1952
	\"emacs_regexp": '\s*(structure|signature|functor)\s+\bJJJ\b',
1953
	\"supports": ["ag", "grep", "rg", "git-grep"],
1954
	\"spec_success": ["structure test =","structure test : MYTEST =","signature test =","functor test (T:TEST) =","functor test(T:TEST) ="],
1955
	\"spec_failed": [],
1956
	\})
1957


1958
call s:add_definition('sql', {
1959
	\"type": 'function',
1960
	\"pcre2_regexp": '(CREATE|create)\s+(.+?\s+)?(FUNCTION|function|PROCEDURE|procedure)\s+KEYWORD\s*\(',
1961
	\"emacs_regexp": '(CREATE|create)\s+(.+?\s+)?(FUNCTION|function|PROCEDURE|procedure)\s+JJJ\s*\(',
1962
	\"supports": ["ag", "grep", "rg", "git-grep"],
1963
	\"spec_success": ["CREATE FUNCTION test(i INT) RETURNS INT","create or replace function test (int)","CREATE PROCEDURE test (OUT p INT)","create definer = 'test'@'localhost' procedure test()"],
1964
	\"spec_failed": [],
1965
	\})
1966


1967
call s:add_definition('sql', {
1968
	\"type": 'table',
1969
	\"pcre2_regexp": '(CREATE|create)\s+(.+?\s+)?(TABLE|table)(\s+(IF NOT EXISTS|if not exists))?\s+KEYWORD\b',
1970
	\"emacs_regexp": '(CREATE|create)\s+(.+?\s+)?(TABLE|table)(\s+(IF NOT EXISTS|if not exists))?\s+JJJ\b',
1971
	\"supports": ["ag", "grep", "rg", "git-grep"],
1972
	\"spec_success": ["CREATE TABLE test (","create temporary table if not exists test","CREATE TABLE IF NOT EXISTS test (","create global temporary table test"],
1973
	\"spec_failed": [],
1974
	\})
1975


1976
call s:add_definition('sql', {
1977
	\"type": 'view',
1978
	\"pcre2_regexp": '(CREATE|create)\s+(.+?\s+)?(VIEW|view)\s+KEYWORD\b',
1979
	\"emacs_regexp": '(CREATE|create)\s+(.+?\s+)?(VIEW|view)\s+JJJ\b',
1980
	\"supports": ["ag", "grep", "rg", "git-grep"],
1981
	\"spec_success": ["CREATE VIEW test (","create sql security definer view test","CREATE OR REPLACE VIEW test AS foo"],
1982
	\"spec_failed": [],
1983
	\})
1984


1985
call s:add_definition('sql', {
1986
	\"type": 'type',
1987
	\"pcre2_regexp": '(CREATE|create)\s+(.+?\s+)?(TYPE|type)\s+KEYWORD\b',
1988
	\"emacs_regexp": '(CREATE|create)\s+(.+?\s+)?(TYPE|type)\s+JJJ\b',
1989
	\"supports": ["ag", "grep", "rg", "git-grep"],
1990
	\"spec_success": ["CREATE TYPE test","CREATE OR REPLACE TYPE test AS foo (","create type test as ("],
1991
	\"spec_failed": [],
1992
	\})
1993


1994
call s:add_definition('systemverilog', {
1995
	\"type": 'type',
1996
	\"pcre2_regexp": '\s*class\s+\bKEYWORD\b',
1997
	\"emacs_regexp": '\s*class\s+\bJJJ\b',
1998
	\"supports": ["ag", "grep", "rg", "git-grep"],
1999
	\"spec_success": ["virtual class test;","class test;","class test extends some_class"],
2000
	\"spec_failed": ["virtual class testing;","class test2;","class some_test","class some_class extends test"],
2001
	\})
2002


2003
call s:add_definition('systemverilog', {
2004
	\"type": 'type',
2005
	\"pcre2_regexp": '\s*task\s+\bKEYWORD\b',
2006
	\"emacs_regexp": '\s*task\s+\bJJJ\b',
2007
	\"supports": ["ag", "grep", "rg", "git-grep"],
2008
	\"spec_success": ["task test (","task test("],
2009
	\"spec_failed": ["task testing (","task test2("],
2010
	\})
2011


2012
call s:add_definition('systemverilog', {
2013
	\"type": 'type',
2014
	\"pcre2_regexp": '\s*\bKEYWORD\b\s*=',
2015
	\"emacs_regexp": '\s*\bJJJ\b\s*=',
2016
	\"supports": ["ag", "grep", "rg", "git-grep"],
2017
	\"spec_success": ["assign test =","assign test=","int test =","int test="],
2018
	\"spec_failed": ["assign testing =","assign test2="],
2019
	\})
2020


2021
call s:add_definition('systemverilog', {
2022
	\"type": 'function',
2023
	\"pcre2_regexp": 'function\s[^\s]+\s*\bKEYWORD\b',
2024
	\"emacs_regexp": 'function\s[^\s]+\s*\bJJJ\b',
2025
	\"supports": ["ag", "rg", "git-grep"],
2026
	\"spec_success": ["function Matrix test ;","function Matrix test;"],
2027
	\"spec_failed": ["function test blah"],
2028
	\})
2029


2030
call s:add_definition('systemverilog', {
2031
	\"type": 'function',
2032
	\"pcre2_regexp": '^\s*[^\s]*\s*[^\s]+\s+\bKEYWORD\b',
2033
	\"emacs_regexp": '^\s*[^\s]*\s*[^\s]+\s+\bJJJ\b',
2034
	\"supports": ["ag", "rg", "git-grep"],
2035
	\"spec_success": ["some_class_name test","  another_class_name  test ;","some_class test[];","some_class #(1) test"],
2036
	\"spec_failed": ["test some_class_name","class some_class extends test"],
2037
	\})
2038


2039
call s:add_definition('vhdl', {
2040
	\"type": 'type',
2041
	\"pcre2_regexp": '\s*type\s+\bKEYWORD\b',
2042
	\"emacs_regexp": '\s*type\s+\bJJJ\b',
2043
	\"supports": ["ag", "grep", "rg", "git-grep"],
2044
	\"spec_success": ["type test is","type test  is"],
2045
	\"spec_failed": ["type testing is","type test2  is"],
2046
	\})
2047


2048
call s:add_definition('vhdl', {
2049
	\"type": 'type',
2050
	\"pcre2_regexp": '\s*constant\s+\bKEYWORD\b',
2051
	\"emacs_regexp": '\s*constant\s+\bJJJ\b',
2052
	\"supports": ["ag", "grep", "rg", "git-grep"],
2053
	\"spec_success": ["constant test :","constant test:"],
2054
	\"spec_failed": ["constant testing ","constant test2:"],
2055
	\})
2056


2057
call s:add_definition('vhdl', {
2058
	\"type": 'function',
2059
	\"pcre2_regexp": 'function\s*\"?KEYWORD\"?\s*\(',
2060
	\"emacs_regexp": 'function\s*\"?JJJ\"?\s*\(',
2061
	\"supports": ["ag", "grep", "rg", "git-grep"],
2062
	\"spec_success": ["function test(signal)","function test (signal)","function \"test\" (signal)"],
2063
	\"spec_failed": ["function testing(signal"],
2064
	\})
2065


2066
call s:add_definition('tex', {
2067
	\"type": 'command',
2068
	\"pcre2_regexp": '\\.*newcommand\*?\s*\{\s*(\\)KEYWORD\s*}',
2069
	\"emacs_regexp": '\\.*newcommand\*?\s*\{\s*(\\)JJJ\s*}',
2070
	\"supports": ["ag", "grep", "rg", "git-grep"],
2071
	\"spec_success": ["\\newcommand{\\test}","\\renewcommand{\\test}","\\renewcommand*{\\test}","\\newcommand*{\\test}","\\renewcommand{ \\test }"],
2072
	\"spec_failed": ["\\test","test"],
2073
	\})
2074


2075
call s:add_definition('tex', {
2076
	\"type": 'command',
2077
	\"pcre2_regexp": '\\.*newcommand\*?\s*(\\)KEYWORD($|[^a-zA-Z0-9\?\*-])',
2078
	\"emacs_regexp": '\\.*newcommand\*?\s*(\\)JJJ\j',
2079
	\"supports": ["ag", "grep", "rg", "git-grep"],
2080
	\"spec_success": ["\\newcommand\\test {}","\\renewcommand\\test{}","\\newcommand \\test"],
2081
	\"spec_failed": ["\\test","test"],
2082
	\})
2083


2084
call s:add_definition('tex', {
2085
	\"type": 'length',
2086
	\"pcre2_regexp": '\\(s)etlength\s*\{\s*(\\)KEYWORD\s*}',
2087
	\"emacs_regexp": '\\(s)etlength\s*\{\s*(\\)JJJ\s*}',
2088
	\"supports": ["ag", "grep", "rg", "git-grep"],
2089
	\"spec_success": ["\\setlength { \\test}","\\setlength{\\test}","\\setlength{\\test}{morecommands}"],
2090
	\"spec_failed": ["\\test","test"],
2091
	\})
2092


2093
call s:add_definition('tex', {
2094
	\"type": 'counter',
2095
	\"pcre2_regexp": '\\newcounter\{\s*KEYWORD\s*}',
2096
	\"emacs_regexp": '\\newcounter\{\s*JJJ\s*}',
2097
	\"supports": ["ag", "grep", "rg", "git-grep"],
2098
	\"spec_success": ["\\newcounter{test}"],
2099
	\"spec_failed": ["\\test","test"],
2100
	\})
2101


2102
call s:add_definition('tex', {
2103
	\"type": 'environment',
2104
	\"pcre2_regexp": '\\.*newenvironment\s*\{\s*KEYWORD\s*}',
2105
	\"emacs_regexp": '\\.*newenvironment\s*\{\s*JJJ\s*}',
2106
	\"supports": ["ag", "grep", "rg", "git-grep"],
2107
	\"spec_success": ["\\newenvironment{test}","\\newenvironment {test}{morecommands}","\\lstnewenvironment{test}","\\newenvironment {test}"],
2108
	\"spec_failed": ["\\test","test"],
2109
	\})
2110


2111
call s:add_definition('pascal', {
2112
	\"type": 'function',
2113
	\"pcre2_regexp": '\bfunction\s+KEYWORD\b',
2114
	\"emacs_regexp": '\bfunction\s+JJJ\b',
2115
	\"supports": ["ag", "grep", "rg", "git-grep"],
2116
	\"spec_success": ["  function test : "],
2117
	\"spec_failed": [],
2118
	\})
2119


2120
call s:add_definition('pascal', {
2121
	\"type": 'function',
2122
	\"pcre2_regexp": '\bprocedure\s+KEYWORD\b',
2123
	\"emacs_regexp": '\bprocedure\s+JJJ\b',
2124
	\"supports": ["ag", "grep", "rg", "git-grep"],
2125
	\"spec_success": ["  procedure test ; "],
2126
	\"spec_failed": [],
2127
	\})
2128


2129
call s:add_definition('fsharp', {
2130
	\"type": 'variable',
2131
	\"pcre2_regexp": 'let\s+KEYWORD\b.*\=',
2132
	\"emacs_regexp": 'let\s+JJJ\b.*\=',
2133
	\"supports": ["ag", "grep", "git-grep"],
2134
	\"spec_success": ["let test = 1234","let test() = 1234","let test abc def = 1234"],
2135
	\"spec_failed": ["let testnot = 1234","let testnot() = 1234","let testnot abc def = 1234"],
2136
	\})
2137


2138
call s:add_definition('fsharp', {
2139
	\"type": 'interface',
2140
	\"pcre2_regexp": 'member(\b.+\.|\s+)KEYWORD\b.*\=',
2141
	\"emacs_regexp": 'member(\b.+\.|\s+)JJJ\b.*\=',
2142
	\"supports": ["ag", "grep", "git-grep"],
2143
	\"spec_success": ["member test = 1234","member this.test = 1234"],
2144
	\"spec_failed": ["member testnot = 1234","member this.testnot = 1234"],
2145
	\})
2146


2147
call s:add_definition('fsharp', {
2148
	\"type": 'type',
2149
	\"pcre2_regexp": 'type\s+KEYWORD\b.*\=',
2150
	\"emacs_regexp": 'type\s+JJJ\b.*\=',
2151
	\"supports": ["ag", "grep", "git-grep"],
2152
	\"spec_success": ["type test = 1234"],
2153
	\"spec_failed": ["type testnot = 1234"],
2154
	\})
2155


2156
call s:add_definition('kotlin', {
2157
	\"type": 'function',
2158
	\"pcre2_regexp": 'fun\s*(<[^>]*>)?\s*KEYWORD\s*\(',
2159
	\"emacs_regexp": 'fun\s*(<[^>]*>)?\s*JJJ\s*\(',
2160
	\"supports": ["ag", "grep", "rg", "git-grep"],
2161
	\"spec_success": ["fun test()","fun <T> test()"],
2162
	\"spec_failed": [],
2163
	\})
2164


2165
call s:add_definition('kotlin', {
2166
	\"type": 'variable',
2167
	\"pcre2_regexp": '(val|var)\s*KEYWORD\b',
2168
	\"emacs_regexp": '(val|var)\s*JJJ\b',
2169
	\"supports": ["ag", "grep", "rg", "git-grep"],
2170
	\"spec_success": ["val test ","var test"],
2171
	\"spec_failed": ["val testval","var testvar"],
2172
	\})
2173


2174
call s:add_definition('kotlin', {
2175
	\"type": 'type',
2176
	\"pcre2_regexp": '(class|interface)\s*KEYWORD\b',
2177
	\"emacs_regexp": '(class|interface)\s*JJJ\b',
2178
	\"supports": ["ag", "grep", "rg", "git-grep"],
2179
	\"spec_success": ["class test","class test : SomeInterface","interface test"],
2180
	\"spec_failed": [],
2181
	\})
2182


2183
call s:add_definition('zig', {
2184
	\"type": 'function',
2185
	\"pcre2_regexp": 'fn\s+KEYWORD\b',
2186
	\"emacs_regexp": 'fn\s+JJJ\b',
2187
	\"supports": ["ag", "grep", "rg", "git-grep"],
2188
	\"spec_success": ["fn test() void {","fn test(a: i32) i32 {","pub fn test(a: i32) i32 {","export fn test(a: i32) i32 {","extern \"c\" fn test(a: i32) i32 {","inline fn test(a: i32) i32 {"],
2189
	\"spec_failed": [],
2190
	\})
2191


2192
call s:add_definition('zig', {
2193
	\"type": 'variable',
2194
	\"pcre2_regexp": '(var|const)\s+KEYWORD\b',
2195
	\"emacs_regexp": '(var|const)\s+JJJ\b',
2196
	\"supports": ["ag", "grep", "rg", "git-grep"],
2197
	\"spec_success": ["const test: i32 = 3;","var test: i32 = 3;","pub const test: i32 = 3;"],
2198
	\"spec_failed": [],
2199
	\})
2200


2201
call s:add_definition('protobuf', {
2202
	\"type": 'message',
2203
	\"pcre2_regexp": 'message\s+KEYWORD\s*\{',
2204
	\"emacs_regexp": 'message\s+JJJ\s*\{',
2205
	\"supports": ["ag", "grep", "rg", "git-grep"],
2206
	\"spec_success": ["message test{","message test {"],
2207
	\"spec_failed": [],
2208
	\})
2209


2210
call s:add_definition('protobuf', {
2211
	\"type": 'enum',
2212
	\"pcre2_regexp": 'enum\s+KEYWORD\s*\{',
2213
	\"emacs_regexp": 'enum\s+JJJ\s*\{',
2214
	\"supports": ["ag", "grep", "rg", "git-grep"],
2215
	\"spec_success": ["enum test{","enum test {"],
2216
	\"spec_failed": [],
2217
	\})
2218


2219
call s:add_definition('apex', {
2220
	\"type": 'function',
2221
	\"pcre2_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}KEYWORD\s*\(',
2222
	\"emacs_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}JJJ\s*\(',
2223
	\"supports": ["ag", "rg"],
2224
	\"spec_success": ["int test()","int test(param)","static int test()","static int test(param)","public static MyType test()","private virtual SomeType test(param)","static int test()","private foo[] test()"],
2225
	\"spec_failed": ["test()","testnot()","blah = new test()","foo bar = test()"],
2226
	\})
2227


2228
call s:add_definition('apex', {
2229
	\"type": 'variable',
2230
	\"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n)]+',
2231
	\"emacs_regexp": '\s*\bJJJ\s*=[^=\n)]+',
2232
	\"supports": ["ag", "grep", "rg", "git-grep"],
2233
	\"spec_success": ["int test = 1234"],
2234
	\"spec_failed": ["if test == 1234:","int nottest = 44"],
2235
	\})
2236


2237
call s:add_definition('apex', {
2238
	\"type": 'type',
2239
	\"pcre2_regexp": '(class|interface)\s*KEYWORD\b',
2240
	\"emacs_regexp": '(class|interface)\s*JJJ\b',
2241
	\"supports": ["ag", "grep", "rg", "git-grep"],
2242
	\"spec_success": ["class test:","public class test implements Something"],
2243
	\"spec_failed": ["class testnot:","public class testnot implements Something"],
2244
	\})
2245

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.