Update locals with support for deep pattern matches

2 files changed, 66 insertions, 75 deletions

diff --git a/queries/elixir/highlights.scm b/queries/elixir/highlights.scm
index 228a0397..f8c81016 100644
--- a/queries/elixir/highlights.scm
+++ b/queries/elixir/highlights.scm
@@ -19,6 +19,9 @@
   "%"
 ] @punctuation.special
 
+; Parser errors
+(ERROR) @error
+
 ; Identifiers
 (identifier) @variable
 
@@ -201,7 +204,7 @@
           quoted_end: _ @comment) @comment
         (boolean) @comment
       ]))
-  (#any-of? @_identifier "moduledoc" "typedoc" "doc"))
+  (#any-of? @_identifier "moduledoc" "typedoc" "shortdoc" "doc"))
 
 ; Sigils
 (sigil 
@@ -220,5 +223,3 @@
   ((sigil_modifiers) @string)?
   (#any-of? @_sigil_name "s" "S")) @string
 
-; Parser errors
-(ERROR) @error
diff --git a/queries/elixir/locals.scm b/queries/elixir/locals.scm
index f4011d4c..8f279f99 100644
--- a/queries/elixir/locals.scm
+++ b/queries/elixir/locals.scm
@@ -1,80 +1,70 @@
-[
-  (after_block)
-  (catch_block)
-  (do_block)
-  (stab_expression)
-  (rescue_block)
-] @scope
+; Scopes
+(call (do_block)) @scope
+(stab_clause) @scope
 
+; References
 (identifier) @reference
+(alias) @reference
 
+; Module Definitions
 (call
- function: (function_identifier) @_call-name
- (module) @definition.type
- (#eq? @_call-name "defmodule"))
+  target: ((identifier) @_identifier (#eq? @_identifier "defmodule"))
+  (arguments (alias) @definition.type))
 
-; Function definition without arguments
-(call (function_identifier) @_call-name
- (identifier) @definition.function
- (#any-of? @_call-name "def" "defp" "defguard" "defguardp"))
-
-; Function definition with arguments
-(call (function_identifier) @_call-name
- (call
-  function: (function_identifier) @definition.function
-  (arguments
-   [(identifier) @definition.parameter
-    (tuple (identifier) @definition.parameter)
-    (list (identifier) @definition.parameter)
-    (_
-     (keyword_list (identifier) @definition.parameter))
-    (binary_op
-     left: (identifier) @definition.parameter
-     operator: "\\\\")]))
- (#any-of? @_call-name "def" "defp"))
-
-; Function definition with (some) arguments and guard(s)
-(call (function_identifier) @_call-name
- (binary_op
-  left:
-   (call
-    function: (function_identifier) @definition.function
-    (arguments
-     [(identifier) @definition.parameter
-      (tuple (identifier) @definition.parameter)
-      (list (identifier) @definition.parameter)
-      (_
-       (keyword_list (identifier) @definition.parameter))]))
-  operator: "when")
- (#any-of? @_call-name "def" "defp" "defguard" "defguardp"))
+; Local Function Definitions
+; TODO: add support for test blocks
+; test "foo", %{conn: conn} do
+(call
+  target: ((identifier) @_identifier (#any-of? @_identifier "def" "defp" "defmacro" "defmacrop" "defguard" "defguardp" "defn" "defnp" "for"))
+  (arguments [
+    (identifier) @definition.function
+    (binary_operator left: (identifier) @definition.function)
+    (call target: (identifier) @definition.function (arguments [
+      (identifier) @definition.parameter
+      (_ (identifier) @definition.parameter)
+      (_ (_ (identifier) @definition.parameter))
+      (_ (_ (_ (identifier) @definition.parameter)))
+      (_ (_ (_ (_ (identifier) @definition.parameter))))
+      (_ (_ (_ (_ (_ (identifier) @definition.parameter)))))
+      (_ (_ (_ (_ (_ (_ (identifier) @definition.parameter))))))
+      (_ (_ (_ (_ (_ (_ (_ (identifier) @definition.parameter)))))))
+    ]))
+  ]?) (#set! definition.function.scope parent))
 
-; Variable assignment and simple pattern matching
-(binary_op
- left:
- [(identifier) @definition.var
-  (tuple (identifier) @definition.var)
-  (list (identifier) @definition.var)
-  (_
-   (keyword_list (identifier) @definition.var))]
- operator: "=")
+; Pattern Match Definitions
+(binary_operator left: [
+  (identifier) @definition.var
+  (_ (identifier) @definition.var)
+  (_ (_ (identifier) @definition.var))
+  (_ (_ (_ (identifier) @definition.var)))
+  (_ (_ (_ (_ (identifier) @definition.var))))
+  (_ (_ (_ (_ (_ (identifier) @definition.var)))))
+  (_ (_ (_ (_ (_ (_ (identifier) @definition.var))))))
+  (_ (_ (_ (_ (_ (_ (_ (identifier) @definition.var)))))))
+] operator: "=")
 
-; Simple stab expression (ex. case pattern matching) without guard(s)
-(stab_expression
- left:
- (bare_arguments
-  [(identifier) @definition.var
-   (tuple (identifier) @definition.var)
-   (list (identifier) @definition.var)
-   (_
-    (keyword_list (identifier) @definition.var))]))
+; Stab Clause Definitions
+(stab_clause left: [
+  (_ (identifier) @definition.var)
+  (_ (_ (identifier) @definition.var))
+  (_ (_ (_ (identifier) @definition.var)))
+  (_ (_ (_ (_ (identifier) @definition.var))))
+  (_ (_ (_ (_ (_ (identifier) @definition.var)))))
+  (_ (_ (_ (_ (_ (_ (identifier) @definition.var))))))
+  (_ (_ (_ (_ (_ (_ (_ (identifier) @definition.var)))))))
+])
 
-; Simple stab expression (ex. case pattern matching) with guard(s)
-(stab_expression
- left:
- (bare_arguments
-  (binary_op
-   left: [(identifier) @definition.var
-          (tuple (identifier) @definition.var)
-          (list (identifier) @definition.var)
-          (_
-           (keyword_list (identifier) @definition.var))])))
+; Aliases
+(call
+  target: ((identifier) @_identifier (#any-of? @_identifier "require" "alias" "use" "import"))
+  (arguments [
+    (alias) @definition.import
+    (_ (alias) @definition.import)
+    (_ (_ (alias) @definition.import))
+    (_ (_ (_ (alias) @definition.import)))
+    (_ (_ (_ (_ (alias) @definition.import))))
+    (_ (_ (_ (_ (_ (alias) @definition.import)))))
+    (_ (_ (_ (_ (_ (_ (alias) @definition.import))))))
+    (_ (_ (_ (_ (_ (_ (_ (alias) @definition.import)))))))
+  ]
+))