Merge branch 'nvim-treesitter:master' into masterHEADmaster

4 files changed, 188 insertions, 132 deletions

diff --git a/queries/julia/folds.scm b/queries/julia/folds.scm
index a8cfc940..61718215 100644
--- a/queries/julia/folds.scm
+++ b/queries/julia/folds.scm
@@ -12,6 +12,6 @@
   (quote_statement)
 
   (do_clause)
-  (compound_expression)
+  (compound_statement)
 ] @fold
 
diff --git a/queries/julia/highlights.scm b/queries/julia/highlights.scm
index 1b7e5b72..8d30ff55 100644
--- a/queries/julia/highlights.scm
+++ b/queries/julia/highlights.scm
@@ -1,106 +1,110 @@
-(identifier) @variable
+;;; Identifiers
 
-(operator) @operator
-(range_expression ":" @operator)
-(pair_expression "=>" @operator)
+(identifier) @variable
 
-;; In case you want type highlighting based on Julia naming conventions (this might collide with mathematical notation)
-;((identifier) @type ; exception: mark `A_foo` sort of identifiers as variables
-  ;(match? @type "^[A-Z][^_]"))
+; ;; If you want type highlighting based on Julia naming conventions (this might collide with mathematical notation)
+; ((identifier) @type
+;   (match? @type "^[A-Z][^_]"))  ; exception: Highlight `A_foo` sort of identifiers as variables
 
 (macro_identifier) @function.macro
-(macro_identifier (identifier) @function.macro) ; for any one using the variable highlight
+(macro_identifier
+  (identifier) @function.macro) ; for any one using the variable highlight
+
 (macro_definition
-  name: (identifier) @function.macro
-  ["macro" "end" @keyword])
+  name: (identifier) @function.macro)
+
+(quote_expression ":" (identifier)) @symbol
+
+
+;;; Fields and indexes
 
 (field_expression
-  (identifier)
   (identifier) @field .)
 
+(index_expression
+  (_)
+  (range_expression
+    (identifier) @constant.builtin .)
+  (#eq? @constant.builtin "end"))
+
+
+;;; Function names
+
+;; definitions
+
 (function_definition
   name: (identifier) @function)
+(short_function_definition
+  name: (identifier) @function)
+
+(function_definition
+  name: (scoped_identifier (identifier) @function .))
+(short_function_definition
+  name: (scoped_identifier (identifier) @function .))
+
+;; calls
+
 (call_expression
   (identifier) @function.call)
 (call_expression
-  (field_expression (identifier) @method.call .))
+  (field_expression (identifier) @function.call .))
+
 (broadcast_call_expression
   (identifier) @function.call)
 (broadcast_call_expression
-  (field_expression (identifier) @method.call .))
+  (field_expression (identifier) @function.call .))
+
+
+;;; Parameters
+
 (parameter_list
   (identifier) @parameter)
-(parameter_list
-  (optional_parameter .
-    (identifier) @parameter))
+(optional_parameter .
+  (identifier) @parameter)
+(slurp_parameter
+  (identifier) @parameter)
+
 (typed_parameter
-  (identifier) @parameter
-  (identifier) @type)
-(type_parameter_list
-  (identifier) @type)
+  parameter: (identifier) @parameter
+  type: (_) @type)
 (typed_parameter
-  (identifier) @parameter
-  (parameterized_identifier) @type)
+  type: (_) @type)
+
 (function_expression
-  . (identifier) @parameter)
-(spread_parameter) @parameter
-(spread_parameter
-  (identifier) @parameter)
-(named_argument
-    . (identifier) @parameter)
-(argument_list
-  (typed_expression
-    (identifier) @parameter
-    (identifier) @type))
-(argument_list
-  (typed_expression
-    (identifier) @parameter
-    (parameterized_identifier) @type))
-
-;; Symbol expressions (:my-wanna-be-lisp-keyword)
-(quote_expression
- (identifier)) @symbol
-
-;; Parsing error! foo (::Type) gets parsed as two quote expressions
-(argument_list
-  (quote_expression
-    (quote_expression
-      (identifier) @type)))
-
-(type_argument_list
-  (identifier) @type)
-(parameterized_identifier (_)) @type
-(argument_list
-  (typed_expression . (identifier) @parameter))
+  . (identifier) @parameter) ; Single parameter arrow functions
 
-(typed_expression
-  (identifier) @type .)
-(typed_expression
-  (parameterized_identifier) @type .)
+
+;;; Types
+
+;; Definitions
 
 (abstract_definition
   name: (identifier) @type)
+(primitive_definition
+  name: (identifier) @type)
 (struct_definition
   name: (identifier) @type)
 
-(subscript_expression
-  (_)
-  (range_expression
-    (identifier) @constant.builtin .)
-  (#eq? @constant.builtin "end"))
+;; Annotations
 
-"end" @keyword
+(parametrized_type_expression (_) @type)
 
-(if_statement
-  ["if" "end"] @conditional)
-(elseif_clause
-  ["elseif"] @conditional)
-(else_clause
-  ["else"] @conditional)
-(ternary_expression
-  ["?" ":"] @conditional)
+(type_parameter_list
+  (identifier) @type)
+
+(typed_expression
+  (identifier) @type .)
+
+(function_definition
+  return_type: (identifier) @type)
+(short_function_definition
+  return_type: (identifier) @type)
+
+(where_clause
+  (identifier) @type) ; where clause without braces
 
-(function_definition ["function" "end"] @keyword.function)
+
+;;; Keywords
 
 [
   "abstract"
@@ -110,51 +114,91 @@
   "struct"
   "type"
   "mutable"
+  "where"
 ] @keyword
 
-"return" @keyword.return
+"end" @keyword
 
-((identifier) @keyword (#any-of? @keyword "global" "local"))
+((identifier) @keyword (#any-of? @keyword "global" "local")) ; Grammar error
 
-(compound_expression
+(compound_statement
   ["begin" "end"] @keyword)
+(quote_statement
+  ["quote" "end"] @keyword)
+(let_statement
+  ["let" "end"] @keyword)
+
+(if_statement
+  ["if" "end"] @conditional)
+(elseif_clause
+  ["elseif"] @conditional)
+(else_clause
+  ["else"] @conditional)
+(ternary_expression
+  ["?" ":"] @conditional)
+
 (try_statement
-  ["try" "end" ] @exception)
+  ["try" "end"] @exception)
 (finally_clause
   "finally" @exception)
 (catch_clause
   "catch" @exception)
-(quote_statement
-  ["quote" "end"] @keyword)
-(let_statement
-  ["let" "end"] @keyword)
+
 (for_statement
   ["for" "end"] @repeat)
 (while_statement
   ["while" "end"] @repeat)
-(break_statement) @repeat
-(continue_statement) @repeat
 (for_clause
   "for" @repeat)
+[
+  (break_statement)
+  (continue_statement)
+] @repeat
+
+(module_definition
+  ["module" "baremodule" "end"] @include)
+(import_statement
+  ["import" "using"] @include)
+(export_statement
+  "export" @include)
+
+(macro_definition
+  ["macro" "end" @keyword])
+
+(function_definition
+  ["function" "end"] @keyword.function)
 (do_clause
-  ["do" "end"] @keyword)
+  ["do" "end"] @keyword.function)
+(function_expression
+  "->" @keyword.function)
+(return_statement
+  "return" @keyword.return)
 
-"in" @keyword.operator
 
-(export_statement
-  ["export"] @include)
+;;; Operators & Punctuation
 
-(import_statement
-  ["import" "using"] @include)
+(operator) @operator
+(for_binding ["in" "=" "∈"] @operator)
+(pair_expression "=>" @operator)
+(range_expression ":" @operator)
 
-(module_definition
-  ["module" "end"] @include)
+(slurp_parameter "..." @operator)
+(spread_expression "..." @operator)
+
+"." @operator
+["::" "<:"] @operator
 
-((identifier) @include (#eq? @include "baremodule"))
+["," ";"] @punctuation.delimiter
+["(" ")" "[" "]" "{" "}"] @punctuation.bracket
 
 
 ;;; Literals
 
+[
+  (true)
+  (false)
+] @boolean
+
 (integer_literal) @number
 (float_literal) @float
 
@@ -162,9 +206,6 @@
   (#any-of? @float "NaN" "NaN16" "NaN32"
                    "Inf" "Inf16" "Inf32"))
 
-((identifier) @boolean
-  (#any-of? @boolean "true" "false"))
-
 ((identifier) @constant.builtin
   (#any-of? @constant.builtin "nothing" "missing"))
 
@@ -184,8 +225,3 @@
   (block_comment)
 ] @comment
 
-;;; Punctuation
-
-(quote_expression ":" @symbol)
-["::" "." "," "..."] @punctuation.delimiter
-["[" "]" "(" ")" "{" "}"] @punctuation.bracket
diff --git a/queries/julia/indents.scm b/queries/julia/indents.scm
index e6423d34..9cfdc407 100644
--- a/queries/julia/indents.scm
+++ b/queries/julia/indents.scm
@@ -11,7 +11,7 @@
   (quote_statement)
 
   (do_clause)
-  (compound_expression)
+  (compound_statement)
 
   (assignment_expression)
   (binary_expression)
diff --git a/queries/julia/locals.scm b/queries/julia/locals.scm
index f8b34f71..655affe0 100644
--- a/queries/julia/locals.scm
+++ b/queries/julia/locals.scm
@@ -1,59 +1,79 @@
+;;; Variables
+(assignment_expression
+  (identifier) @definition.var)
+(assignment_expression
+  (tuple_expression
+    (identifier) @definition.var))
 
-(import_statement
- (identifier) @definition.import)
+;;; let/const bindings
 (variable_declaration
  (identifier) @definition.var)
 (variable_declaration
  (tuple_expression
   (identifier) @definition.var))
+
+
+;;; For bindings
 (for_binding
- (identifier) @definition.var)
+  (identifier) @definition.var)
 (for_binding
- (tuple_expression
-  (identifier) @definition.var))
+  (tuple_expression
+    (identifier) @definition.var))
 
-(assignment_expression
- (tuple_expression
-  (identifier) @definition.var))
-(assignment_expression
- (bare_tuple_expression
-  (identifier) @definition.var))
-(assignment_expression
- (identifier) @definition.var)
 
-(type_parameter_list
-  (identifier) @definition.type)
-(type_argument_list
-  (identifier) @definition.type)
+;;; Types
+
 (struct_definition
   name: (identifier) @definition.type)
+(abstract_definition
+  name: (identifier) @definition.type)
+(abstract_definition
+  name: (identifier) @definition.type)
+
+(type_parameter_list
+  (identifier) @definition.type)
+
+;;; Module imports
+
+(import_statement
+  (identifier) @definition.import)
+
+
+;;; Parameters
 
 (parameter_list
- (identifier) @definition.parameter)
+  (identifier) @definition.parameter)
+(optional_parameter .
+  (identifier) @definition.parameter)
+(slurp_parameter
+  (identifier) @definition.parameter)
+
 (typed_parameter
- (identifier) @definition.parameter
- (identifier))
+  parameter: (identifier) @definition.parameter
+  (_))
+
 (function_expression
- . (identifier) @definition.parameter)
-(argument_list
- (typed_expression
-  (identifier) @definition.parameter
-  (identifier)))
-(spread_parameter
- (identifier) @definition.parameter)
+ . (identifier) @definition.parameter) ;; Single parameter arrow function
+
+
+;;; Function/macro definitions
 
 (function_definition
- name: (identifier) @definition.function) @scope
+  name: (identifier) @definition.function) @scope
+(short_function_definition
+  name: (identifier) @definition.function) @scope
 (macro_definition 
- name: (identifier) @definition.macro) @scope
+  name: (identifier) @definition.macro) @scope
 
 (identifier) @reference
 
 [
+  (for_statement)
+  (while_statement)
   (try_statement)
+  (catch_clause)
   (finally_clause)
-  (quote_statement)
   (let_statement)
-  (compound_expression)
-  (for_statement)
+  (quote_statement)
+  (do_clause)
 ] @scope