on master help sign in
Add julia support (LSP not working)
aa70362wesh
languages.toml+25
@@ -165,6 +165,31 @@ roots = []
165
165
166indent = { tab-width = 4, unit = "\t" }
166indent = { tab-width = 4, unit = "\t" }
167
167
168+[[language]]
169+name = "julia"
170+scope = "source.julia"
171+injection-regex = "julia"
172+file-types = ["jl"]
173+roots = []
174+
175+args = [
176+ "--startup-file=no",
177+ "--history-file=no",
178+ "-e",
179+ """
180+ using LanguageServer;
181+ using Pkg;
182+ import StaticLint;
183+ import SymbolServer;
184+ env_path = dirname(Pkg.Types.Context().env.project_file);
185+
186+ server = LanguageServer.LanguageServerInstance(stdin, stdout, env_path, "");
187+ server.runlinter = true;
188+ run(server);
189+ """,
190+ ]
191+indent = { tab-width = 2, unit = " " }
192+
168# [[language]]
193# [[language]]
169# name = "haskell"
194# name = "haskell"
170# scope = "source.haskell"
195# scope = "source.haskell"
runtime/queries/julia/folds.scmnew file+11
@@ -0,0 +1,11 @@
1+[
2+ (module_definition)
3+ (struct_definition)
4+ (macro_definition)
5+ (function_definition)
6+ (compound_expression) ; begin blocks
7+ (let_statement)
8+ (if_statement)
9+ (for_statement)
10+ (while_statement)
11+] @fold
runtime/queries/julia/highlights.scmnew file+180
@@ -0,0 +1,180 @@
1+(identifier) @variable
2+;; In case you want type highlighting based on Julia naming conventions (this might collide with mathematical notation)
3+;((identifier) @type ; exception: mark `A_foo` sort of identifiers as variables
4+ ;(match? @type "^[A-Z][^_]"))
5+((identifier) @constant
6+ (match? @constant "^[A-Z][A-Z_]{2}[A-Z_]*$"))
7+
8+[
9+ (triple_string)
10+ (string)
11+] @string
12+
13+(string
14+ prefix: (identifier) @constant.builtin)
15+
16+(macro_identifier) @function.macro
17+(macro_identifier (identifier) @function.macro) ; for any one using the variable highlight
18+(macro_definition
19+ name: (identifier) @function.macro
20+ ["macro" "end" @keyword])
21+
22+(field_expression
23+ (identifier)
24+ (identifier) @field .)
25+
26+(function_definition
27+ name: (identifier) @function)
28+(call_expression
29+ (identifier) @function)
30+(call_expression
31+ (field_expression (identifier) @method .))
32+(broadcast_call_expression
33+ (identifier) @function)
34+(broadcast_call_expression
35+ (field_expression (identifier) @method .))
36+(parameter_list
37+ (identifier) @parameter)
38+(parameter_list
39+ (optional_parameter .
40+ (identifier) @parameter))
41+(typed_parameter
42+ (identifier) @parameter
43+ (identifier) @type)
44+(type_parameter_list
45+ (identifier) @type)
46+(typed_parameter
47+ (identifier) @parameter
48+ (parameterized_identifier) @type)
49+(function_expression
50+ . (identifier) @parameter)
51+(spread_parameter) @parameter
52+(spread_parameter
53+ (identifier) @parameter)
54+(named_argument
55+ . (identifier) @parameter)
56+(argument_list
57+ (typed_expression
58+ (identifier) @parameter
59+ (identifier) @type))
60+(argument_list
61+ (typed_expression
62+ (identifier) @parameter
63+ (parameterized_identifier) @type))
64+
65+;; Symbol expressions (:my-wanna-be-lisp-keyword)
66+(quote_expression
67+ (identifier)) @symbol
68+
69+;; Parsing error! foo (::Type) get's parsed as two quote expressions
70+(argument_list
71+ (quote_expression
72+ (quote_expression
73+ (identifier) @type)))
74+
75+(type_argument_list
76+ (identifier) @type)
77+(parameterized_identifier (_)) @type
78+(argument_list
79+ (typed_expression . (identifier) @parameter))
80+
81+(typed_expression
82+ (identifier) @type .)
83+(typed_expression
84+ (parameterized_identifier) @type .)
85+
86+(struct_definition
87+ name: (identifier) @type)
88+
89+(number) @number
90+(range_expression
91+ (identifier) @number
92+ (eq? @number "end"))
93+(range_expression
94+ (_
95+ (identifier) @number
96+ (eq? @number "end")))
97+(coefficient_expression
98+ (number)
99+ (identifier) @constant.builtin)
100+
101+;; TODO: operators.
102+;; Those are a bit difficult to implement since the respective nodes are hidden right now (_power_operator)
103+;; and heavily use Unicode chars (support for those are bad in vim/lua regexes)
104+;[;
105+ ;(power_operator);
106+ ;(times_operator);
107+ ;(plus_operator);
108+ ;(arrow_operator);
109+ ;(comparison_operator);
110+ ;(assign_operator);
111+;] @operator ;
112+
113+"end" @keyword
114+
115+(if_statement
116+ ["if" "end"] @conditional)
117+(elseif_clause
118+ ["elseif"] @conditional)
119+(else_clause
120+ ["else"] @conditional)
121+(ternary_expression
122+ ["?" ":"] @conditional)
123+
124+(function_definition ["function" "end"] @keyword.function)
125+
126+(comment) @comment
127+
128+[
129+ "const"
130+ "return"
131+ "macro"
132+ "struct"
133+ "primitive"
134+ "type"
135+] @keyword
136+
137+((identifier) @keyword (#any-of? @keyword "global" "local"))
138+
139+(compound_expression
140+ ["begin" "end"] @keyword)
141+(try_statement
142+ ["try" "end" ] @exception)
143+(finally_clause
144+ "finally" @exception)
145+(catch_clause
146+ "catch" @exception)
147+(quote_statement
148+ ["quote" "end"] @keyword)
149+(let_statement
150+ ["let" "end"] @keyword)
151+(for_statement
152+ ["for" "end"] @repeat)
153+(while_statement
154+ ["while" "end"] @repeat)
155+(break_statement) @repeat
156+(continue_statement) @repeat
157+(for_binding
158+ "in" @repeat)
159+(for_clause
160+ "for" @repeat)
161+(do_clause
162+ ["do" "end"] @keyword)
163+
164+(export_statement
165+ ["export"] @include)
166+
167+[
168+ "using"
169+ "module"
170+ "import"
171+] @include
172+
173+((identifier) @include (#eq? @include "baremodule"))
174+
175+(((identifier) @constant.builtin) (match? @constant.builtin "^(nothing|Inf|NaN)$"))
176+(((identifier) @boolean) (eq? @boolean "true"))
177+(((identifier) @boolean) (eq? @boolean "false"))
178+
179+["::" ":" "." "," "..." "!"] @punctuation.delimiter
180+["[" "]" "(" ")" "{" "}"] @punctuation.bracket
runtime/queries/julia/injections.scmnew file+5
@@ -0,0 +1,5 @@
1+; TODO: re-add when markdown is added.
2+; ((triple_string) @markdown
3+; (#offset! @markdown 0 3 0 -3))
4+
5+(comment) @comment
runtime/queries/julia/locals.scmnew file+59
@@ -0,0 +1,59 @@
1+
2+(import_statement
3+ (identifier) @definition.import)
4+(variable_declaration
5+ (identifier) @definition.var)
6+(variable_declaration
7+ (tuple_expression
8+ (identifier) @definition.var))
9+(for_binding
10+ (identifier) @definition.var)
11+(for_binding
12+ (tuple_expression
13+ (identifier) @definition.var))
14+
15+(assignment_expression
16+ (tuple_expression
17+ (identifier) @definition.var))
18+(assignment_expression
19+ (bare_tuple_expression
20+ (identifier) @definition.var))
21+(assignment_expression
22+ (identifier) @definition.var)
23+
24+(type_parameter_list
25+ (identifier) @definition.type)
26+(type_argument_list
27+ (identifier) @definition.type)
28+(struct_definition
29+ name: (identifier) @definition.type)
30+
31+(parameter_list
32+ (identifier) @definition.parameter)
33+(typed_parameter
34+ (identifier) @definition.parameter
35+ (identifier))
36+(function_expression
37+ . (identifier) @definition.parameter)
38+(argument_list
39+ (typed_expression
40+ (identifier) @definition.parameter
41+ (identifier)))
42+(spread_parameter
43+ (identifier) @definition.parameter)
44+
45+(function_definition
46+ name: (identifier) @definition.function) @scope
47+(macro_definition
48+ name: (identifier) @definition.macro) @scope
49+
50+(identifier) @reference
51+
52+[
53+ (try_statement)
54+ (finally_clause)
55+ (quote_statement)
56+ (let_statement)
57+ (compound_expression)
58+ (for_statement)
59+] @scope