From f5c4671bfbad96bf346bd7e9a21fc4317b4959df Mon Sep 17 00:00:00 2001 From: Indrajith K L Date: Sat, 3 Dec 2022 17:00:20 +0530 Subject: Adds most of the tools --- .../runtime/queries/bash/highlights.scm | 54 +++ .../runtime/queries/bash/injections.scm | 2 + .../runtime/queries/c-sharp/highlights.scm | 336 +++++++++++++++++ .../runtime/queries/c-sharp/injections.scm | 2 + .../runtime/queries/c/highlights.scm | 87 +++++ .../runtime/queries/c/indents.toml | 16 + .../runtime/queries/c/injections.scm | 2 + .../runtime/queries/c/textobjects.scm | 17 + .../runtime/queries/cmake/highlights.scm | 97 +++++ .../runtime/queries/cmake/indents.toml | 12 + .../runtime/queries/cmake/injections.scm | 4 + .../runtime/queries/cmake/textobjects.scm | 12 + .../runtime/queries/comment/highlights.scm | 30 ++ .../runtime/queries/cpp/highlights.scm | 67 ++++ .../runtime/queries/cpp/indents.toml | 17 + .../runtime/queries/cpp/injections.scm | 1 + .../runtime/queries/cpp/textobjects.scm | 7 + .../runtime/queries/css/highlights.scm | 64 ++++ .../runtime/queries/css/injections.scm | 2 + .../runtime/queries/dart/highlights.scm | 237 ++++++++++++ .../runtime/queries/dart/indents.toml | 20 + .../runtime/queries/dart/injections.scm | 2 + .../runtime/queries/dart/locals.scm | 20 + .../runtime/queries/dockerfile/highlights.scm | 51 +++ .../runtime/queries/dockerfile/injections.scm | 6 + .../runtime/queries/elixir/highlights.scm | 221 +++++++++++ .../runtime/queries/elixir/injections.scm | 9 + .../runtime/queries/elm/highlights.scm | 83 +++++ .../runtime/queries/elm/injections.scm | 4 + .../runtime/queries/elm/locals.scm | 14 + .../runtime/queries/elm/tags.scm | 19 + .../runtime/queries/erlang/highlights.scm | 118 ++++++ .../runtime/queries/erlang/injections.scm | 2 + .../runtime/queries/fish/highlights.scm | 156 ++++++++ .../runtime/queries/fish/indents.toml | 12 + .../runtime/queries/fish/injections.scm | 2 + .../runtime/queries/fish/textobjects.scm | 5 + .../runtime/queries/git-commit/highlights.scm | 14 + .../runtime/queries/git-commit/injections.scm | 8 + .../runtime/queries/git-config/highlights.scm | 27 ++ .../runtime/queries/git-diff/highlights.scm | 6 + .../runtime/queries/git-rebase/highlights.scm | 11 + .../runtime/queries/git-rebase/injections.scm | 4 + .../runtime/queries/glsl/folds.scm | 1 + .../runtime/queries/glsl/highlights.scm | 37 ++ .../runtime/queries/glsl/indents.toml | 19 + .../runtime/queries/glsl/injections.scm | 4 + .../runtime/queries/glsl/locals.scm | 1 + .../runtime/queries/go/highlights.scm | 152 ++++++++ .../runtime/queries/go/indents.toml | 30 ++ .../runtime/queries/go/injections.scm | 2 + .../runtime/queries/go/locals.scm | 30 ++ .../runtime/queries/go/tags.scm | 30 ++ .../runtime/queries/go/textobjects.scm | 25 ++ .../runtime/queries/graphql/highlights.scm | 163 ++++++++ .../runtime/queries/haskell/highlights.scm | 125 +++++++ .../runtime/queries/haskell/injections.scm | 2 + .../runtime/queries/haskell/locals.scm | 4 + .../runtime/queries/hcl/folds.scm | 6 + .../runtime/queries/hcl/highlights.scm | 100 +++++ .../runtime/queries/hcl/indents.toml | 13 + .../runtime/queries/hcl/injections.scm | 2 + .../runtime/queries/html/highlights.scm | 12 + .../runtime/queries/html/injections.scm | 10 + .../runtime/queries/iex/highlights.scm | 1 + .../runtime/queries/iex/injections.scm | 6 + .../runtime/queries/java/highlights.scm | 130 +++++++ .../runtime/queries/java/injections.scm | 2 + .../runtime/queries/javascript/highlights-jsx.scm | 4 + .../queries/javascript/highlights-params.scm | 12 + .../runtime/queries/javascript/highlights.scm | 205 +++++++++++ .../runtime/queries/javascript/indents.toml | 28 ++ .../runtime/queries/javascript/injections.scm | 28 ++ .../runtime/queries/javascript/locals.scm | 23 ++ .../runtime/queries/javascript/tags.scm | 88 +++++ .../runtime/queries/json/highlights.scm | 20 + .../runtime/queries/json/indents.toml | 9 + .../runtime/queries/julia/folds.scm | 11 + .../runtime/queries/julia/highlights.scm | 184 +++++++++ .../runtime/queries/julia/injections.scm | 5 + .../runtime/queries/julia/locals.scm | 59 +++ .../runtime/queries/kotlin/folds.scm | 17 + .../runtime/queries/kotlin/highlights.scm | 295 +++++++++++++++ .../runtime/queries/kotlin/injections.scm | 36 ++ .../runtime/queries/latex/folds.scm | 12 + .../runtime/queries/latex/highlights.scm | 410 +++++++++++++++++++++ .../runtime/queries/latex/injections.scm | 2 + .../runtime/queries/lean/folds.scm | 15 + .../runtime/queries/lean/highlights.scm | 217 +++++++++++ .../runtime/queries/lean/injections.scm | 2 + .../runtime/queries/lean/locals.scm | 5 + .../runtime/queries/ledger/highlights.scm | 38 ++ .../runtime/queries/ledger/injections.scm | 2 + .../runtime/queries/llvm-mir-yaml/highlights.scm | 1 + .../runtime/queries/llvm-mir-yaml/indents.toml | 3 + .../runtime/queries/llvm-mir-yaml/injections.scm | 9 + .../runtime/queries/llvm-mir/highlights.scm | 136 +++++++ .../runtime/queries/llvm-mir/indents.toml | 7 + .../runtime/queries/llvm-mir/injections.scm | 2 + .../runtime/queries/llvm-mir/textobjects.scm | 12 + .../runtime/queries/llvm/highlights.scm | 158 ++++++++ .../runtime/queries/llvm/indents.toml | 8 + .../runtime/queries/llvm/injections.scm | 2 + .../runtime/queries/llvm/locals.scm | 14 + .../runtime/queries/llvm/textobjects.scm | 20 + .../runtime/queries/lua/highlights.scm | 166 +++++++++ .../runtime/queries/lua/indents.toml | 24 ++ .../runtime/queries/lua/injections.scm | 2 + .../runtime/queries/make/highlights.scm | 170 +++++++++ .../runtime/queries/make/injections.scm | 2 + .../runtime/queries/markdown/highlights.scm | 46 +++ .../runtime/queries/markdown/injections.scm | 9 + .../runtime/queries/nix/highlights.scm | 90 +++++ .../runtime/queries/nix/indents.toml | 18 + .../runtime/queries/ocaml-interface/highlights.scm | 1 + .../runtime/queries/ocaml-interface/injections.scm | 2 + .../runtime/queries/ocaml/highlights.scm | 160 ++++++++ .../runtime/queries/ocaml/indents.toml | 13 + .../runtime/queries/ocaml/injections.scm | 2 + .../runtime/queries/ocaml/locals.scm | 24 ++ .../runtime/queries/org/highlights.scm | 24 ++ .../runtime/queries/org/injections.scm | 4 + .../runtime/queries/perl/highlights.scm | 181 +++++++++ .../runtime/queries/perl/indents.toml | 17 + .../runtime/queries/perl/injections.scm | 2 + .../runtime/queries/perl/textobjects.scm | 17 + .../runtime/queries/php/highlights.scm | 118 ++++++ .../runtime/queries/php/indents.toml | 17 + .../runtime/queries/php/injections.scm | 6 + .../runtime/queries/php/tags.scm | 26 ++ .../runtime/queries/php/textobjects.scm | 34 ++ .../runtime/queries/protobuf/highlights.scm | 58 +++ .../runtime/queries/protobuf/indents.toml | 12 + .../runtime/queries/protobuf/injections.scm | 2 + .../runtime/queries/python/highlights.scm | 121 ++++++ .../runtime/queries/python/indents.toml | 39 ++ .../runtime/queries/python/injections.scm | 2 + .../runtime/queries/python/tags.scm | 12 + .../runtime/queries/python/textobjects.scm | 18 + .../runtime/queries/regex/highlights.scm | 53 +++ .../runtime/queries/rescript/highlights.scm | 178 +++++++++ .../runtime/queries/rescript/injections.scm | 8 + .../runtime/queries/rescript/textobjects.scm | 16 + .../runtime/queries/ruby/highlights.scm | 146 ++++++++ .../runtime/queries/ruby/indents.toml | 25 ++ .../runtime/queries/ruby/injections.scm | 2 + .../runtime/queries/ruby/locals.scm | 27 ++ .../runtime/queries/ruby/tags.scm | 64 ++++ .../runtime/queries/rust/highlights.scm | 356 ++++++++++++++++++ .../runtime/queries/rust/indents.toml | 28 ++ .../runtime/queries/rust/injections.scm | 26 ++ .../runtime/queries/rust/locals.scm | 17 + .../runtime/queries/rust/textobjects.scm | 35 ++ .../runtime/queries/scala/highlights.scm | 203 ++++++++++ .../runtime/queries/scala/indents.toml | 23 ++ .../runtime/queries/scala/injections.scm | 2 + .../runtime/queries/solidity/highlights.scm | 189 ++++++++++ .../runtime/queries/svelte/highlights.scm | 68 ++++ .../runtime/queries/svelte/indents.toml | 18 + .../runtime/queries/svelte/injections.scm | 30 ++ .../runtime/queries/tablegen/highlights.scm | 90 +++++ .../runtime/queries/tablegen/indents.toml | 7 + .../runtime/queries/tablegen/injections.scm | 2 + .../runtime/queries/tablegen/textobjects.scm | 16 + .../runtime/queries/toml/highlights.scm | 33 ++ .../runtime/queries/toml/injections.scm | 2 + .../runtime/queries/tsq/highlights.scm | 46 +++ .../runtime/queries/tsq/injections.scm | 2 + .../runtime/queries/tsx/highlights.scm | 1 + .../runtime/queries/tsx/injections.scm | 1 + .../runtime/queries/twig/highlights.scm | 16 + .../runtime/queries/twig/injections.scm | 3 + .../runtime/queries/typescript/highlights.scm | 36 ++ .../runtime/queries/typescript/indents.toml | 28 ++ .../runtime/queries/typescript/injections.scm | 1 + .../runtime/queries/typescript/locals.scm | 2 + .../runtime/queries/typescript/tags.scm | 23 ++ .../runtime/queries/vue/highlights.scm | 21 ++ .../runtime/queries/vue/injections.scm | 20 + .../runtime/queries/wgsl/highlights.scm | 102 +++++ .../runtime/queries/wgsl/injections.scm | 2 + .../runtime/queries/yaml/highlights.scm | 43 +++ .../runtime/queries/yaml/indents.toml | 3 + .../runtime/queries/yaml/injections.scm | 2 + .../runtime/queries/zig/highlights.scm | 234 ++++++++++++ .../runtime/queries/zig/indents.toml | 16 + .../runtime/queries/zig/injections.scm | 2 + 187 files changed, 8593 insertions(+) create mode 100644 helix-22.03-x86_64-windows/runtime/queries/bash/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/bash/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/c-sharp/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/c-sharp/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/c/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/c/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/c/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/c/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/cmake/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/cmake/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/cmake/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/cmake/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/comment/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/cpp/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/cpp/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/cpp/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/cpp/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/css/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/css/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/dart/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/dart/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/dart/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/dart/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/dockerfile/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/dockerfile/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/elixir/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/elixir/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/elm/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/elm/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/elm/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/elm/tags.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/erlang/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/erlang/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/fish/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/fish/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/fish/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/fish/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/git-commit/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/git-commit/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/git-config/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/git-diff/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/git-rebase/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/git-rebase/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/glsl/folds.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/glsl/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/glsl/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/glsl/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/glsl/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/go/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/go/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/go/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/go/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/go/tags.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/go/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/graphql/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/haskell/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/haskell/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/haskell/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/hcl/folds.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/hcl/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/hcl/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/hcl/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/html/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/html/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/iex/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/iex/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/java/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/java/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/javascript/highlights-jsx.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/javascript/highlights-params.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/javascript/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/javascript/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/javascript/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/javascript/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/javascript/tags.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/json/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/json/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/julia/folds.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/julia/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/julia/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/julia/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/kotlin/folds.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/kotlin/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/kotlin/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/latex/folds.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/latex/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/latex/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/lean/folds.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/lean/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/lean/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/lean/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ledger/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ledger/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm-mir/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm-mir/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm-mir/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm-mir/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/llvm/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/lua/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/lua/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/lua/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/make/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/make/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/markdown/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/markdown/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/nix/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/nix/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ocaml-interface/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ocaml-interface/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ocaml/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ocaml/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ocaml/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ocaml/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/org/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/org/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/perl/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/perl/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/perl/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/perl/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/php/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/php/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/php/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/php/tags.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/php/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/protobuf/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/protobuf/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/protobuf/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/python/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/python/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/python/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/python/tags.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/python/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/regex/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/rescript/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/rescript/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/rescript/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ruby/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ruby/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ruby/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ruby/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/ruby/tags.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/rust/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/rust/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/rust/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/rust/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/rust/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/scala/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/scala/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/scala/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/solidity/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/svelte/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/svelte/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/svelte/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/tablegen/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/tablegen/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/tablegen/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/tablegen/textobjects.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/toml/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/toml/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/tsq/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/tsq/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/tsx/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/tsx/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/twig/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/twig/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/typescript/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/typescript/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/typescript/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/typescript/locals.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/typescript/tags.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/vue/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/vue/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/wgsl/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/wgsl/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/yaml/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/yaml/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/yaml/injections.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/zig/highlights.scm create mode 100644 helix-22.03-x86_64-windows/runtime/queries/zig/indents.toml create mode 100644 helix-22.03-x86_64-windows/runtime/queries/zig/injections.scm (limited to 'helix-22.03-x86_64-windows/runtime/queries') diff --git a/helix-22.03-x86_64-windows/runtime/queries/bash/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/bash/highlights.scm new file mode 100644 index 0000000..57898f2 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/bash/highlights.scm @@ -0,0 +1,54 @@ +[ + (string) + (raw_string) + (heredoc_body) + (heredoc_start) +] @string + +(command_name) @function + +(variable_name) @variable.other.member + +[ + "case" + "do" + "done" + "elif" + "else" + "esac" + "export" + "fi" + "for" + "function" + "if" + "in" + "unset" + "while" + "then" +] @keyword + +(comment) @comment + +(function_definition name: (word) @function) + +(file_descriptor) @constant.numeric.integer + +[ + (command_substitution) + (process_substitution) + (expansion) +]@embedded + +[ + "$" + "&&" + ">" + ">>" + "<" + "|" +] @operator + +( + (command (_) @constant) + (#match? @constant "^-") +) diff --git a/helix-22.03-x86_64-windows/runtime/queries/bash/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/bash/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/bash/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/c-sharp/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/c-sharp/highlights.scm new file mode 100644 index 0000000..6b94dd8 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/c-sharp/highlights.scm @@ -0,0 +1,336 @@ +;; Methods +(method_declaration + name: (identifier) @function) + +(method_declaration + type: [(identifier) (qualified_name)] @type) + +(invocation_expression + (member_access_expression + name: (identifier) @function)) + +(invocation_expression + (member_access_expression + expression: (identifier) @variable)) + +(invocation_expression + function: (conditional_access_expression + (member_binding_expression + name: (identifier) @function))) + +(invocation_expression + [(identifier) (qualified_name)] @function) + +; Generic Method invocation with generic type +(invocation_expression + function: (generic_name + . (identifier) @function)) + +;; Namespaces + +(namespace_declaration + name: [(identifier) (qualified_name)] @namespace) + +;; Types +(interface_declaration name: (identifier) @type) +(class_declaration name: (identifier) @type) +(enum_declaration name: (identifier) @type) +(struct_declaration (identifier) @type) +(record_declaration (identifier) @type) +(namespace_declaration name: (identifier) @type) +(using_directive (_) @namespace) +(constructor_declaration name: (identifier) @type) +(object_creation_expression [(identifier) (qualified_name)] @type) +(type_parameter_list (type_parameter) @type) + +[ + (implicit_type) + (nullable_type) + (pointer_type) + (function_pointer_type) + (predefined_type) +] @type.builtin + +;; Generic Types +(type_of_expression + (generic_name + (identifier) @type)) + +(base_list + (generic_name + (identifier) @type)) + +(type_constraint + (generic_name + (identifier) @type)) + +(object_creation_expression + (generic_name + (identifier) @type)) + +(property_declaration + (generic_name + (identifier) @type)) + +(_ + type: (generic_name + (identifier) @type)) + +;; Enum +(enum_member_declaration (identifier) @variable.other.member) + +;; Literals +[ + (real_literal) + (integer_literal) +] @constant.numeric.integer + +(character_literal) @constant.character +[ + (string_literal) + (verbatim_string_literal) + (interpolated_string_text) + (interpolated_verbatim_string_text) + "\"" + "$\"" + "@$\"" + "$@\"" + ] @string + +(boolean_literal) @constant.builtin.boolean +[ + (null_literal) + (void_keyword) +] @constant.builtin + +;; Comments +(comment) @comment + +;; Tokens +[ + ";" + "." + "," +] @punctuation.delimiter + +[ + "--" + "-" + "-=" + "&" + "&&" + "+" + "++" + "+=" + "<" + "<=" + "<<" + "<<=" + "=" + "==" + "!" + "!=" + "=>" + ">" + ">=" + ">>" + ">>=" + "|" + "||" + "|=" + "?" + "??" + "^" + "^=" + "~" + "*" + "*=" + "/" + "/=" + "%" + "%=" + ":" + ".." + "&=" + "->" + "??=" +] @operator + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +;; Keywords +(modifier) @keyword +(this_expression) @keyword +(escape_sequence) @constant.character.escape + +[ + "as" + "base" + "break" + "case" + "catch" + "checked" + "class" + "continue" + "default" + "delegate" + "do" + "else" + "enum" + "event" + "explicit" + "finally" + "for" + "foreach" + "goto" + "if" + "implicit" + "interface" + "is" + "lock" + "namespace" + "operator" + "params" + "return" + "sizeof" + "stackalloc" + "static" + "struct" + "switch" + "throw" + "try" + "typeof" + "unchecked" + "using" + "while" + "new" + "await" + "in" + "yield" + "get" + "set" + "when" + "out" + "ref" + "from" + "where" + "select" + "record" + "init" + "with" + "let" +] @keyword + +(preprocessor_call) @keyword.directive +(preprocessor_call (_) @keyword.directive) + +;; Linq +(from_clause (identifier) @variable) +(group_clause) +(order_by_clause) +(select_clause (identifier) @variable) +(query_continuation (identifier) @variable) @keyword + +;; Record +(with_expression + (with_initializer_expression + (simple_assignment_expression + (identifier) @variable))) + +;; Exprs +(binary_expression [(identifier) (qualified_name)] @variable [(identifier) (qualified_name)] @variable) +(binary_expression [(identifier) (qualified_name)]* @variable) +(conditional_expression [(identifier) (qualified_name)] @variable) +(prefix_unary_expression [(identifier) (qualified_name)] @variable) +(postfix_unary_expression [(identifier) (qualified_name)]* @variable) +(assignment_expression [(identifier) (qualified_name)] @variable) +(cast_expression [(identifier) (qualified_name)] @type [(identifier) (qualified_name)] @variable) + +;; Class +(base_list (identifier) @type) +(property_declaration (generic_name)) +(property_declaration + type: (nullable_type) @type + name: (identifier) @variable) +(property_declaration + type: (predefined_type) @type + name: (identifier) @variable) +(property_declaration + type: (identifier) @type + name: (identifier) @variable) + +;; Delegate + +(delegate_declaration (identifier) @type) + +;; Lambda +(lambda_expression) @variable + +;; Attribute +(attribute) @type + +;; Parameter +(parameter + type: (identifier) @type + name: (identifier) @variable.parameter) +(parameter (identifier) @variable.parameter) +(parameter_modifier) @keyword + +(parameter_list + (parameter + name: (identifier) @parameter)) + +(parameter_list + (parameter + type: [(identifier) (qualified_name)] @type)) + +;; Typeof +(type_of_expression [(identifier) (qualified_name)] @type) + +;; Variable +(variable_declaration [(identifier) (qualified_name)] @type) +(variable_declarator [(identifier) (qualified_name)] @variable) + +;; Return +(return_statement (identifier) @variable) +(yield_statement (identifier) @variable) + +;; Type +(generic_name (identifier) @type) +(type_parameter [(identifier) (qualified_name)] @variable.parameter) +(type_argument_list [(identifier) (qualified_name)] @type) + +;; Type constraints +(type_parameter_constraints_clause (identifier) @variable.parameter) +(type_constraint (identifier) @type) + +;; Exception +(catch_declaration (identifier) @type (identifier) @variable) +(catch_declaration (identifier) @type) + +;; Switch +(switch_statement (identifier) @variable) +(switch_expression (identifier) @variable) + +;; Lock statement +(lock_statement (identifier) @variable) + +;; Rest +(member_access_expression) @variable +(element_access_expression (identifier) @variable) +(argument (identifier) @variable) +(for_statement (identifier) @variable) +(for_each_statement (identifier) @variable) +(expression_statement (identifier) @variable) +(member_access_expression expression: (identifier) @variable) +(member_access_expression name: (identifier) @variable) +(conditional_access_expression [(identifier) (qualified_name)] @variable) +((identifier) @comment.unused + (#eq? @comment.unused "_")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/c-sharp/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/c-sharp/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/c-sharp/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/c/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/c/highlights.scm new file mode 100644 index 0000000..918f3f6 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/c/highlights.scm @@ -0,0 +1,87 @@ +"goto" @keyword +"register" @keyword +"break" @keyword +"case" @keyword +"const" @keyword +"continue" @keyword +"default" @keyword +"do" @keyword +"else" @keyword +"enum" @keyword +"extern" @keyword +"for" @keyword +"if" @keyword +"inline" @keyword +"return" @keyword +"sizeof" @keyword +"static" @keyword +"struct" @keyword +"switch" @keyword +"typedef" @keyword +"union" @keyword +"volatile" @keyword +"while" @keyword + +[ + "#define" + "#elif" + "#else" + "#endif" + "#if" + "#ifdef" + "#ifndef" + "#include" + (preproc_directive) +] @keyword.directive + +"--" @operator +"-" @operator +"-=" @operator +"->" @operator +"=" @operator +"!=" @operator +"*" @operator +"&" @operator +"&&" @operator +"+" @operator +"++" @operator +"+=" @operator +"<" @operator +"==" @operator +">" @operator +"||" @operator + +"." @punctuation.delimiter +";" @punctuation.delimiter + +(enumerator) @type.enum.variant + +(string_literal) @string +(system_lib_string) @string + +(null) @constant +(number_literal) @constant.numeric.integer +(char_literal) @constant.character + +(call_expression + function: (identifier) @function) +(call_expression + function: (field_expression + field: (field_identifier) @function)) +(function_declarator + declarator: (identifier) @function) +(preproc_function_def + name: (identifier) @function.special) + +(field_identifier) @variable.other.member +(statement_identifier) @label +(type_identifier) @type +(primitive_type) @type +(sized_type_specifier) @type + +((identifier) @constant + (#match? @constant "^[A-Z][A-Z\\d_]*$")) + +(identifier) @variable + +(comment) @comment diff --git a/helix-22.03-x86_64-windows/runtime/queries/c/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/c/indents.toml new file mode 100644 index 0000000..f4076e1 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/c/indents.toml @@ -0,0 +1,16 @@ +indent = [ + "compound_statement", + "field_declaration_list", + "enumerator_list", + "parameter_list", + "init_declarator", + "case_statement", + "condition_clause", + "expression_statement", +] + +outdent = [ + "case", + "}", + "]", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/c/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/c/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/c/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/c/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/c/textobjects.scm new file mode 100644 index 0000000..45f554e --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/c/textobjects.scm @@ -0,0 +1,17 @@ +(function_definition + body: (_) @function.inside) @function.around + +(struct_specifier + body: (_) @class.inside) @class.around + +(enum_specifier + body: (_) @class.inside) @class.around + +(union_specifier + body: (_) @class.inside) @class.around + +(parameter_declaration) @parameter.inside + +(comment) @comment.inside + +(comment)+ @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/cmake/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/cmake/highlights.scm new file mode 100644 index 0000000..71e9b5d --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/cmake/highlights.scm @@ -0,0 +1,97 @@ +[ + (quoted_argument) + (bracket_argument) + ] @string + +(variable) @variable + +[ + (bracket_comment) + (line_comment) + ] @comment + +(normal_command (identifier) @function) + +["ENV" "CACHE"] @string.special.symbol +["$" "{" "}" "<" ">"] @punctuation +["(" ")"] @punctuation.bracket + +[ + (function) + (endfunction) + (macro) + (endmacro) + ] @keyword.function + +[ + (if) + (elseif) + (else) + (endif) + ] @keyword.control.conditional + +[ + (foreach) + (endforeach) + (while) + (endwhile) + ] @keyword.control.repeat + +(function_command + (function) + . (argument) @function + (argument)* @variable.parameter + ) + +(macro_command + (macro) + . (argument) @function.macro + (argument)* @variable.parameter + ) + +(normal_command + (identifier) @function.builtin + . (argument) @variable + (#match? @function.builtin "^(?i)(set)$")) + +(normal_command + (identifier) @function.builtin + . (argument) + (argument) @constant + (#match? @constant "^(?:PARENT_SCOPE|CACHE)$") + (#match? @function.builtin "^(?i)(unset)$")) + +(normal_command + (identifier) @function.builtin + . (argument) + . (argument) + (argument) @constant + (#match? @constant "^(?:PARENT_SCOPE|CACHE|FORCE)$") + (#match? @function.builtin "^(?i)(set)$") + ) + +((argument) @constant.builtin.boolean + (#match? @constant.builtin.boolean "^(?i)(?:1|on|yes|true|y|0|off|no|false|n|ignore|notfound|.*-notfound)$") + ) + +(if_command + (if) + (argument) @operator + (#match? @operator "^(?:NOT|AND|OR|COMMAND|POLICY|TARGET|TEST|DEFINED|IN_LIST|EXISTS|IS_NEWER_THAN|IS_DIRECTORY|IS_SYMLINK|IS_ABSOLUTE|MATCHES|LESS|GREATER|EQUAL|LESS_EQUAL|GREATER_EQUAL|STRLESS|STRGREATER|STREQUAL|STRLESS_EQUAL|STRGREATER_EQUAL|VERSION_LESS|VERSION_GREATER|VERSION_EQUAL|VERSION_LESS_EQUAL|VERSION_GREATER_EQUAL)$") +) + +(normal_command + (identifier) @function.builtin + . (argument) + (argument) @constant + (#match? @constant "^(?:ALL|COMMAND|DEPENDS|BYPRODUCTS|WORKING_DIRECTORY|COMMENT|JOB_POOL|VERBATIM|USES_TERMINAL|COMMAND_EXPAND_LISTS|SOURCES)$") + (#match? @function.builtin "^(?i)(add_custom_target)$") + ) + +(normal_command + (identifier) @function.builtin + (argument) @constant + (#match? @constant "^(?:OUTPUT|COMMAND|MAIN_DEPENDENCY|DEPENDS|BYPRODUCTS|IMPLICIT_DEPENDS|WORKING_DIRECTORY|COMMENT|DEPFILE|JOB_POOL|VERBATIM|APPEND|USES_TERMINAL|COMMAND_EXPAND_LISTS)$") + (#match? @function.builtin "^(?i)(add_custom_command)$") + ) + diff --git a/helix-22.03-x86_64-windows/runtime/queries/cmake/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/cmake/indents.toml new file mode 100644 index 0000000..8b886a4 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/cmake/indents.toml @@ -0,0 +1,12 @@ +indent = [ + "if_condition", + "foreach_loop", + "while_loop", + "function_def", + "macro_def", + "normal_command", +] + +outdent = [ + ")" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/cmake/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/cmake/injections.scm new file mode 100644 index 0000000..6cb6c25 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/cmake/injections.scm @@ -0,0 +1,4 @@ +((line_comment) @injection.content + (#set! injection.language "comment")) +((bracket_comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/cmake/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/cmake/textobjects.scm new file mode 100644 index 0000000..1fa9ded --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/cmake/textobjects.scm @@ -0,0 +1,12 @@ +(macro_def) @function.around + +(argument) @parameter.inside + +[ + (bracket_comment) + (line_comment) +] @comment.inside + +(line_comment)+ @comment.around + +(bracket_comment) @comment.around \ No newline at end of file diff --git a/helix-22.03-x86_64-windows/runtime/queries/comment/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/comment/highlights.scm new file mode 100644 index 0000000..88685d5 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/comment/highlights.scm @@ -0,0 +1,30 @@ +[ + "(" + ")" +] @punctuation.bracket + +":" @punctuation.delimiter + +((tag (name) @warning) + (#match? @warning "^(TODO|HACK|WARNING)$")) + +("text" @warning + (#match? @warning "^(TODO|HACK|WARNING)$")) + +((tag (name) @error) + (match? @error "^(FIXME|XXX|BUG)$")) + +("text" @error + (match? @error "^(FIXME|XXX|BUG)$")) + +(tag + (name) @ui.text + (user)? @constant) + +; Issue number (#123) +("text" @constant.numeric + (#match? @constant.numeric "^#[0-9]+$")) + +; User mention (@user) +("text" @tag + (#match? @tag "^[@][a-zA-Z0-9_-]+$")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/cpp/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/cpp/highlights.scm new file mode 100644 index 0000000..3348ef3 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/cpp/highlights.scm @@ -0,0 +1,67 @@ +; inherits: c + +; Functions + +(call_expression + function: (qualified_identifier + name: (identifier) @function)) + +(template_function + name: (identifier) @function) + +(template_method + name: (field_identifier) @function) + +(template_function + name: (identifier) @function) + +(function_declarator + declarator: (qualified_identifier + name: (identifier) @function)) + +(function_declarator + declarator: (qualified_identifier + name: (identifier) @function)) + +(function_declarator + declarator: (field_identifier) @function) + +; Types + +((namespace_identifier) @type + (#match? @type "^[A-Z]")) + +(auto) @type + +; Constants + +(this) @variable.builtin +(nullptr) @constant + +; Keywords + +"catch" @keyword +"class" @keyword +"constexpr" @keyword +"delete" @keyword +"explicit" @keyword +"final" @keyword +"friend" @keyword +"mutable" @keyword +"namespace" @keyword +"noexcept" @keyword +"new" @keyword +"override" @keyword +"private" @keyword +"protected" @keyword +"public" @keyword +"template" @keyword +"throw" @keyword +"try" @keyword +"typename" @keyword +"using" @keyword +"virtual" @keyword + +; Strings + +(raw_string_literal) @string diff --git a/helix-22.03-x86_64-windows/runtime/queries/cpp/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/cpp/indents.toml new file mode 100644 index 0000000..0ca2ed8 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/cpp/indents.toml @@ -0,0 +1,17 @@ +indent = [ + "compound_statement", + "field_declaration_list", + "enumerator_list", + "parameter_list", + "init_declarator", + "case_statement", + "condition_clause", + "expression_statement", +] + +outdent = [ + "case", + "access_specifier", + "}", + "]", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/cpp/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/cpp/injections.scm new file mode 100644 index 0000000..a5a5208 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/cpp/injections.scm @@ -0,0 +1 @@ +; inherits: c diff --git a/helix-22.03-x86_64-windows/runtime/queries/cpp/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/cpp/textobjects.scm new file mode 100644 index 0000000..6e3de1a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/cpp/textobjects.scm @@ -0,0 +1,7 @@ +; inherits: c + +(lambda_expression + body: (_) @function.inside) @function.around + +(class_specifier + body: (_) @class.inside) @class.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/css/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/css/highlights.scm new file mode 100644 index 0000000..4dfc0c6 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/css/highlights.scm @@ -0,0 +1,64 @@ +(comment) @comment + +(tag_name) @tag +(nesting_selector) @tag +(universal_selector) @tag + +"~" @operator +">" @operator +"+" @operator +"-" @operator +"*" @operator +"/" @operator +"=" @operator +"^=" @operator +"|=" @operator +"~=" @operator +"$=" @operator +"*=" @operator + +"and" @operator +"or" @operator +"not" @operator +"only" @operator + +(attribute_selector (plain_value) @string) +(pseudo_element_selector (tag_name) @attribute) +(pseudo_class_selector (class_name) @attribute) + +(class_name) @variable.other.member +(id_name) @variable.other.member +(namespace_name) @variable.other.member +(property_name) @variable.other.member +(feature_name) @variable.other.member + +(attribute_name) @attribute + +(function_name) @function + +((property_name) @variable + (#match? @variable "^--")) +((plain_value) @variable + (#match? @variable "^--")) + +"@media" @keyword +"@import" @keyword +"@charset" @keyword +"@namespace" @keyword +"@supports" @keyword +"@keyframes" @keyword +(at_keyword) @keyword +(to) @keyword +(from) @keyword +(important) @keyword + +(string_value) @string +(color_value) @string.special + +(integer_value) @constant.numeric.integer +(float_value) @constant.numeric.float +(unit) @type + +"#" @punctuation.delimiter +"," @punctuation.delimiter +":" @punctuation.delimiter diff --git a/helix-22.03-x86_64-windows/runtime/queries/css/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/css/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/css/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/dart/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/dart/highlights.scm new file mode 100644 index 0000000..9f667d6 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/dart/highlights.scm @@ -0,0 +1,237 @@ +(dotted_identifier_list) @string + +; Methods +; -------------------- +(super) @function.builtin + +(function_expression_body (identifier) @function.method) +((identifier)(selector (argument_part)) @function.method) + +; Annotations +; -------------------- +(annotation + name: (identifier) @attribute) +(marker_annotation + name: (identifier) @attribute) + +; Types +; -------------------- +(class_definition + name: (identifier) @type) + +(constructor_signature + name: (identifier) @function.method) + +(function_signature + name: (identifier) @function.method) + +(getter_signature + (identifier) @function.builtin) + +(setter_signature + name: (identifier) @function.builtin) + +(enum_declaration + name: (identifier) @type) + +(enum_constant + name: (identifier) @type.builtin) + +(void_type) @type.builtin + +((scoped_identifier + scope: (identifier) @type) + (#match? @type "^[a-zA-Z]")) + +((scoped_identifier + scope: (identifier) @type + name: (identifier) @type) + (#match? @type "^[a-zA-Z]")) + +; the DisabledDrawerButtons in : const DisabledDrawerButtons(history: true), +(type_identifier) @type.builtin + +; Variables +; -------------------- +; the "File" in var file = File(); +((identifier) @namespace + (#match? @namespace "^_?[A-Z].*[a-z]")) ; catch Classes or IClasses not CLASSES + +("Function" @type.builtin) +(inferred_type) @type.builtin + +; properties +(unconditional_assignable_selector + (identifier) @variable.other.member) + +(conditional_assignable_selector + (identifier) @variable.other.member) + +; assignments +; -------------------- +; the "strings" in : strings = "some string" +(assignment_expression + left: (assignable_expression) @variable) + +(this) @variable.builtin + +; Parameters +; -------------------- +(formal_parameter + name: (identifier) @variable) + +(named_argument + (label (identifier) @variable)) + +; Literals +; -------------------- +[ + (hex_integer_literal) + (decimal_integer_literal) + (decimal_floating_point_literal) + ;(octal_integer_literal) + ;(hex_floating_point_literal) +] @constant.numeric.integer + +(symbol_literal) @string.special.symbol +(string_literal) @string + +[ + (const_builtin) + (final_builtin) +] @variable.builtin + +[ + (true) + (false) +] @constant.builtin.boolean + +(null_literal) @constant.builtin + +(comment) @comment.line +(documentation_comment) @comment.block.documentation + +; Tokens +; -------------------- +(template_substitution + "$" @punctuation.special + "{" @punctuation.special + "}" @punctuation.special +) @embedded + +(template_substitution + "$" @punctuation.special + (identifier_dollar_escaped) @variable +) @embedded + +(escape_sequence) @constant.character.escape + +; Punctuation +;--------------------- +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +[ + ";" + "." + "," + ":" +] @punctuation.delimiter + +; Operators +;--------------------- +[ + "@" + "?" + "=>" + ".." + "==" + "&&" + "%" + "<" + ">" + "=" + ">=" + "<=" + "||" + (multiplicative_operator) + (increment_operator) + (is_operator) + (prefix_operator) + (equality_operator) + (additive_operator) +] @operator + +; Keywords +; -------------------- +["import" "library" "export"] @keyword.control.import +["do" "while" "continue" "for"] @keyword.control.repeat +["return" "yield"] @keyword.control.return +["as" "in" "is"] @keyword.operator + +[ + "?." + "??" + "if" + "else" + "switch" + "default" + "late" +] @keyword.control.conditional + +[ + "try" + "throw" + "catch" + "finally" + (break_statement) +] @keyword.control.exception + +; Reserved words (cannot be used as identifiers) +[ + (case_builtin) + "abstract" + "async" + "async*" + "await" + "class" + "covariant" + "deferred" + "dynamic" + "enum" + "extends" + "extension" + "external" + "factory" + "Function" + "get" + "implements" + "interface" + "mixin" + "new" + "on" + "operator" + "part" + "required" + "set" + "show" + "static" + "super" + "sync*" + "typedef" + "with" +] @keyword + +; when used as an identifier: +((identifier) @variable.builtin + (#match? @variable.builtin "^(abstract|as|covariant|deferred|dynamic|export|external|factory|Function|get|implements|import|interface|library|operator|mixin|part|set|static|typedef)$")) + +; Error +(ERROR) @error + diff --git a/helix-22.03-x86_64-windows/runtime/queries/dart/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/dart/indents.toml new file mode 100644 index 0000000..5c11e05 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/dart/indents.toml @@ -0,0 +1,20 @@ +indent = [ + "class_body", + "function_body", + "function_expression_body", + "declaration", + "initializers", + "switch_block", + "if_statement", + "formal_parameter_list", + "formal_parameter", + "list_literal", + "return_statement", + "arguments" +] + +outdent = [ + "}", + "]", + ")" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/dart/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/dart/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/dart/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/dart/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/dart/locals.scm new file mode 100644 index 0000000..629838e --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/dart/locals.scm @@ -0,0 +1,20 @@ +; Scopes +;------- + +[ + (block) + (try_statement) + (catch_clause) + (finally_clause) +] @local.scope + +; Definitions +;------------ + +(class_definition + body: (_) @local.definition) + +; References +;------------ + +(identifier) @local.reference diff --git a/helix-22.03-x86_64-windows/runtime/queries/dockerfile/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/dockerfile/highlights.scm new file mode 100644 index 0000000..5a945fb --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/dockerfile/highlights.scm @@ -0,0 +1,51 @@ +[ + "FROM" + "AS" + "RUN" + "CMD" + "LABEL" + "EXPOSE" + "ENV" + "ADD" + "COPY" + "ENTRYPOINT" + "VOLUME" + "USER" + "WORKDIR" + "ARG" + "ONBUILD" + "STOPSIGNAL" + "HEALTHCHECK" + "SHELL" + "MAINTAINER" + "CROSS_BUILD" +] @keyword + +[ + ":" + "@" +] @operator + +(comment) @comment + + +(image_spec + (image_tag + ":" @punctuation.special) + (image_digest + "@" @punctuation.special)) + +(double_quoted_string) @string + +(expansion + [ + "$" + "{" + "}" + ] @punctuation.special +) @none + +((variable) @constant + (#match? @constant "^[A-Z][A-Z_0-9]*$")) + + diff --git a/helix-22.03-x86_64-windows/runtime/queries/dockerfile/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/dockerfile/injections.scm new file mode 100644 index 0000000..20396f1 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/dockerfile/injections.scm @@ -0,0 +1,6 @@ +((comment) @injection.content + (#set! injection.language "comment")) + +([(shell_command) (shell_fragment)] @injection.content + (#set! injection.language "bash")) + diff --git a/helix-22.03-x86_64-windows/runtime/queries/elixir/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/elixir/highlights.scm new file mode 100644 index 0000000..76fd2af --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/elixir/highlights.scm @@ -0,0 +1,221 @@ +; The following code originates mostly from +; https://github.com/elixir-lang/tree-sitter-elixir, with minor edits to +; align the captures with helix. The following should be considered +; Copyright 2021 The Elixir Team +; +; Licensed under the Apache License, Version 2.0 (the "License"); +; you may not use this file except in compliance with the License. +; You may obtain a copy of the License at +; +; https://www.apache.org/licenses/LICENSE-2.0 +; +; Unless required by applicable law or agreed to in writing, software +; distributed under the License is distributed on an "AS IS" BASIS, +; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +; See the License for the specific language governing permissions and +; limitations under the License. + +; Reserved keywords + +["when" "and" "or" "not" "in" "not in" "fn" "do" "end" "catch" "rescue" "after" "else"] @keyword + +; Operators + +; * doc string +(unary_operator + operator: "@" @comment.block.documentation + operand: (call + target: (identifier) @comment.block.documentation.__attribute__ + (arguments + [ + (string) @comment.block.documentation + (charlist) @comment.block.documentation + (sigil + quoted_start: _ @comment.block.documentation + quoted_end: _ @comment.block.documentation) @comment.block.documentation + (boolean) @comment.block.documentation + ])) + (#match? @comment.block.documentation.__attribute__ "^(moduledoc|typedoc|doc)$")) + +; * module attribute +(unary_operator + operator: "@" @variable.other.member + operand: [ + (identifier) @variable.other.member + (call + target: (identifier) @variable.other.member) + (boolean) @variable.other.member + (nil) @variable.other.member + ]) + +; * capture operator +(unary_operator + operator: "&" + operand: [ + (integer) @operator + (binary_operator + left: [ + (call target: (dot left: (_) right: (identifier) @function)) + (identifier) @function + ] operator: "/" right: (integer) @operator) + ]) + +(operator_identifier) @operator + +(unary_operator + operator: _ @operator) + +(binary_operator + operator: _ @operator) + +(dot + operator: _ @operator) + +(stab_clause + operator: _ @operator) + +; Literals + +(nil) @constant.builtin + +(boolean) @constant.builtin.boolean +(integer) @constant.numeric.integer +(float) @constant.numeric.float + +(alias) @type + +(call + target: (dot + left: (atom) @type)) + +(char) @constant.character + +; Quoted content + +(interpolation "#{" @punctuation.special "}" @punctuation.special) @embedded + +(escape_sequence) @constant.character.escape + +[ + (atom) + (quoted_atom) + (keyword) + (quoted_keyword) +] @string.special.symbol + +[ + (string) + (charlist) +] @string + +; Note that we explicitly target sigil quoted start/end, so they are not overridden by delimiters + +(sigil + (sigil_name) @__name__ + quoted_start: _ @string + quoted_end: _ @string + (#match? @__name__ "^[sS]$")) @string + +(sigil + (sigil_name) @__name__ + quoted_start: _ @string.regexp + quoted_end: _ @string.regexp + (#match? @__name__ "^[rR]$")) @string.regexp + +(sigil + (sigil_name) @__name__ + quoted_start: _ @string.special + quoted_end: _ @string.special) @string.special + +; Calls + +; * definition keyword +(call + target: (identifier) @keyword + (#match? @keyword "^(def|defdelegate|defexception|defguard|defguardp|defimpl|defmacro|defmacrop|defmodule|defn|defnp|defoverridable|defp|defprotocol|defstruct)$")) + +; * kernel or special forms keyword +(call + target: (identifier) @keyword + (#match? @keyword "^(alias|case|cond|else|for|if|import|quote|raise|receive|require|reraise|super|throw|try|unless|unquote|unquote_splicing|use|with)$")) + +; * function call +(call + target: [ + ; local + (identifier) @function + ; remote + (dot + right: (identifier) @function) + ]) + +; * just identifier in function definition +(call + target: (identifier) @keyword + (arguments + [ + (identifier) @function + (binary_operator + left: (identifier) @function + operator: "when") + ]) + (#match? @keyword "^(def|defdelegate|defguard|defguardp|defmacro|defmacrop|defn|defnp|defp)$")) + +; * pipe into identifier (definition) +(call + target: (identifier) @keyword + (arguments + (binary_operator + operator: "|>" + right: (identifier) @variable)) + (#match? @keyword "^(def|defdelegate|defguard|defguardp|defmacro|defmacrop|defn|defnp|defp)$")) + +; * pipe into identifier (function call) +(binary_operator + operator: "|>" + right: (identifier) @function) + +; Identifiers + +; * special +( + (identifier) @constant.builtin + (#match? @constant.builtin "^(__MODULE__|__DIR__|__ENV__|__CALLER__|__STACKTRACE__)$") +) + +; * unused +( + (identifier) @comment + (#match? @comment "^_") +) + +; * regular +(identifier) @variable + +; Comment + +(comment) @comment + +; Punctuation + +[ + "%" +] @punctuation + +[ + "," + ";" +] @punctuation.delimiter + +[ + "(" + ")" + "[" + "]" + "{" + "}" + "<<" + ">>" +] @punctuation.bracket + +(ERROR) @warning diff --git a/helix-22.03-x86_64-windows/runtime/queries/elixir/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/elixir/injections.scm new file mode 100644 index 0000000..8370a0d --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/elixir/injections.scm @@ -0,0 +1,9 @@ +((comment) @injection.content + (#set! injection.language "comment")) + +((sigil + (sigil_name) @_sigil_name + (quoted_content) @injection.content) + (#match? @_sigil_name "^(r|R)$") + (#set! injection.language "regex") + (#set! injection.combined)) diff --git a/helix-22.03-x86_64-windows/runtime/queries/elm/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/elm/highlights.scm new file mode 100644 index 0000000..3c8fd12 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/elm/highlights.scm @@ -0,0 +1,83 @@ +; Keywords +[ + "if" + "then" + "else" + "let" + "in" + ] @keyword.control +(case) @keyword.control +(of) @keyword.control + +(colon) @keyword.operator +(backslash) @keyword +(as) @keyword +(port) @keyword +(exposing) @keyword +(alias) @keyword +(infix) @keyword + +(arrow) @keyword.operator +(dot) @keyword.operator + +(port) @keyword + +(type_annotation(lower_case_identifier) @function) +(port_annotation(lower_case_identifier) @function) +(file (value_declaration (function_declaration_left(lower_case_identifier) @function))) + +(field name: (lower_case_identifier) @attribute) +(field_access_expr(lower_case_identifier) @attribute) + +(operator_identifier) @keyword.operator +(eq) @keyword.operator.assignment + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +"|" @keyword +"," @punctuation.delimiter + +[ + "|>" +] @keyword + + +(import) @keyword.contol.import +(module) @keyword.other + +(number_constant_expr) @constant.numeric + +(type) @type + +(type_declaration(upper_case_identifier) @type) +(type_ref) @type +(type_alias_declaration name: (upper_case_identifier) @type) + +(union_pattern constructor: (upper_case_qid (upper_case_identifier) @label (dot) (upper_case_identifier) @variable.other.member)) +(union_pattern constructor: (upper_case_qid (upper_case_identifier) @variable.other.member)) + +(union_variant(upper_case_identifier) @variable.other.member) +(value_expr name: (value_qid (upper_case_identifier) @label)) +(value_expr (upper_case_qid (upper_case_identifier) @label (dot) (upper_case_identifier) @variable.other.member)) +(value_expr(upper_case_qid(upper_case_identifier)) @variable.other.member) + +; comments +(line_comment) @comment +(block_comment) @comment + +; strings +(string_escape) @constant.character.escape + +(open_quote) @string +(close_quote) @string +(regular_string_part) @string + +(open_char) @constant.character +(close_char) @constant.character diff --git a/helix-22.03-x86_64-windows/runtime/queries/elm/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/elm/injections.scm new file mode 100644 index 0000000..83f8245 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/elm/injections.scm @@ -0,0 +1,4 @@ +; Parse glsl where defined + +((glsl_content) @injection.content + (#set! injection.language "glsl")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/elm/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/elm/locals.scm new file mode 100644 index 0000000..ab10311 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/elm/locals.scm @@ -0,0 +1,14 @@ +(value_declaration) @local.scope +(type_alias_declaration) @local.scope +(type_declaration) @local.scope +(type_annotation) @local.scope +(port_annotation) @local.scope +(infix_declaration) @local.scope +(let_in_expr) @local.scope + +(function_declaration_left (lower_pattern (lower_case_identifier)) @local.definition) +(function_declaration_left (lower_case_identifier) @local.definition) + +(value_expr(value_qid(upper_case_identifier)) @local.reference) +(value_expr(value_qid(lower_case_identifier)) @local.reference) +(type_ref (upper_case_qid) @local.reference) diff --git a/helix-22.03-x86_64-windows/runtime/queries/elm/tags.scm b/helix-22.03-x86_64-windows/runtime/queries/elm/tags.scm new file mode 100644 index 0000000..03999fb --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/elm/tags.scm @@ -0,0 +1,19 @@ +(value_declaration (function_declaration_left (lower_case_identifier) @name)) @definition.function + +(function_call_expr (value_expr (value_qid) @name)) @reference.function +(exposed_value (lower_case_identifier) @name) @reference.function +(type_annotation ((lower_case_identifier) @name) (colon)) @reference.function + +(type_declaration ((upper_case_identifier) @name) ) @definition.type + +(type_ref (upper_case_qid (upper_case_identifier) @name)) @reference.type +(exposed_type (upper_case_identifier) @name) @reference.type + +(type_declaration (union_variant (upper_case_identifier) @name)) @definition.union + +(value_expr (upper_case_qid (upper_case_identifier) @name)) @reference.union + + +(module_declaration + (upper_case_qid (upper_case_identifier)) @name +) @definition.module diff --git a/helix-22.03-x86_64-windows/runtime/queries/erlang/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/erlang/highlights.scm new file mode 100644 index 0000000..fc742f3 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/erlang/highlights.scm @@ -0,0 +1,118 @@ +; Attributes +; module declaration +(attribute + name: (atom) @keyword + (arguments (atom) @module) + (#eq? @keyword "module")) + +(attribute + name: (atom) @keyword + (arguments + . + (atom) @module) + (#eq? @keyword "import")) + +(attribute + name: (atom) @keyword + (arguments + . + (atom) @type + [ + (tuple (atom) @variable.other.member) + (tuple + (binary_operator + left: (atom) @variable.other.member + operator: "=")) + (tuple + (binary_operator + left: + (binary_operator + left: (atom) @variable.other.member + operator: "=") + operator: "::")) + ]) + (#eq? @keyword "record")) + +(attribute + name: (atom) @keyword + (arguments + . + [ + (atom) @keyword.directive + (variable) @keyword.directive + (call + function: + [(variable) (atom)] @keyword.directive) + ]) + (#eq? @keyword "define")) + +(attribute + name: (atom) @keyword + module: (atom) @module + (#eq? @keyword "spec")) + +; Functions +(function name: (atom) @function) +(call module: (atom) @module) +(call function: (atom) @function) +(stab_clause name: (atom) @function) +(function_capture module: (atom) @module) +(function_capture function: (atom) @function) + +; Records +(record_content + (binary_operator + left: (atom) @variable.other.member + operator: "=")) + +(record field: (atom) @variable.other.member) +(record name: (atom) @type) + +; Keywords +((attribute name: (atom) @keyword) + (#match? + @keyword + "^(define|export|export_type|include|include_lib|ifdef|ifndef|if|elif|else|endif|vsn|on_load|behaviour|record|file|type|opaque|spec)$")) + +["case" "fun" "if" "of" "when" "end" "receive" "try" "catch" "after"] @keyword + +; Operators +(binary_operator + left: (atom) @function + operator: "/" + right: (integer) @constant.numeric.integer) + +(binary_operator operator: _ @operator) +(unary_operator operator: _ @operator) +["/" ":" "#" "->"] @operator + +; Comments +((variable) @comment.discard + (#match? @comment.discard "^_")) + +(tripledot) @comment.discard + +(comment) @comment + +; Macros +(macro + "?"+ @keyword.directive + name: (_) @keyword.directive) + +; Basic types +(variable) @variable +[ + (atom) + (quoted_atom) +] @string.special.symbol +(string) @string +(character) @constant.character + +(integer) @constant.numeric.integer +(float) @constant.numeric.float + +; Punctuation +["," "." "-" ";"] @punctuation.delimiter +["(" ")" "{" "}" "[" "]" "<<" ">>"] @punctuation.bracket + +; (ERROR) @error diff --git a/helix-22.03-x86_64-windows/runtime/queries/erlang/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/erlang/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/erlang/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/fish/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/fish/highlights.scm new file mode 100644 index 0000000..def5393 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/fish/highlights.scm @@ -0,0 +1,156 @@ +;; Operators + +[ + "&&" + "||" + "|" + "&" + "=" + "!=" + ".." + "!" + (direction) + (stream_redirect) + (test_option) +] @operator + +[ + "not" + "and" + "or" +] @keyword.operator + +;; Conditionals + +(if_statement +[ + "if" + "end" +] @keyword.control.conditional) + +(switch_statement +[ + "switch" + "end" +] @keyword.control.conditional) + +(case_clause +[ + "case" +] @keyword.control.conditional) + +(else_clause +[ + "else" +] @keyword.control.conditional) + +(else_if_clause +[ + "else" + "if" +] @keyword.control.conditional) + +;; Loops/Blocks + +(while_statement +[ + "while" + "end" +] @keyword.control.repeat) + +(for_statement +[ + "for" + "end" +] @keyword.control.repeat) + +(begin_statement +[ + "begin" + "end" +] @keyword.control.repeat) + +;; Keywords + +[ + "in" + (break) + (continue) +] @keyword + +"return" @keyword.control.return + +;; Punctuation + +[ + "[" + "]" + "{" + "}" + "(" + ")" +] @punctuation.bracket + +"," @punctuation.delimiter + +;; Commands + +(command + argument: [ + (word) @variable.parameter (#match? @variable.parameter "^-") + ] +) + +; non-bultin command names +(command name: (word) @function) + +; derived from builtin -n (fish 3.2.2) +(command + name: [ + (word) @function.builtin + (#match? @function.builtin "^(\.|:|_|alias|argparse|bg|bind|block|breakpoint|builtin|cd|command|commandline|complete|contains|count|disown|echo|emit|eval|exec|exit|fg|functions|history|isatty|jobs|math|printf|pwd|random|read|realpath|set|set_color|source|status|string|test|time|type|ulimit|wait)$") + ] +) + +(test_command "test" @function.builtin) + +;; Functions + +(function_definition ["function" "end"] @keyword.function) + +(function_definition + name: [ + (word) (concatenation) + ] +@function) + +(function_definition + option: [ + (word) + (concatenation (word)) + ] @variable.parameter (#match? @variable.parameter "^-") +) + +;; Strings + +[(double_quote_string) (single_quote_string)] @string +(escape_sequence) @constant.character.escape + +;; Variables + +(variable_name) @variable +(variable_expansion) @constant + +;; Nodes + +(integer) @constant.numeric.integer +(float) @constant.numeric.float +(comment) @comment +(test_option) @string + +((word) @constant.builtin.boolean +(#match? @constant.builtin.boolean "^(true|false)$")) + +;; Error + +(ERROR) @error diff --git a/helix-22.03-x86_64-windows/runtime/queries/fish/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/fish/indents.toml new file mode 100644 index 0000000..6f1e563 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/fish/indents.toml @@ -0,0 +1,12 @@ +indent = [ + "function_definition", + "while_statement", + "for_statement", + "if_statement", + "begin_statement", + "switch_statement", +] + +outdent = [ + "end" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/fish/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/fish/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/fish/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/fish/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/fish/textobjects.scm new file mode 100644 index 0000000..de8caa9 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/fish/textobjects.scm @@ -0,0 +1,5 @@ +(function_definition) @function.around + +(comment) @comment.inside + +(comment)+ @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/git-commit/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/git-commit/highlights.scm new file mode 100644 index 0000000..0b50d41 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/git-commit/highlights.scm @@ -0,0 +1,14 @@ +(subject) @markup.heading +(path) @string.special.path +(branch) @string.special.symbol +(commit) @constant +(item) @markup.link.url +(header) @tag + +(change kind: "new file" @diff.plus) +(change kind: "deleted" @diff.minus) +(change kind: "modified" @diff.delta) +(change kind: "renamed" @diff.delta.moved) + +[":" "->"] @punctuation.delimeter +(comment) @comment diff --git a/helix-22.03-x86_64-windows/runtime/queries/git-commit/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/git-commit/injections.scm new file mode 100644 index 0000000..79f7691 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/git-commit/injections.scm @@ -0,0 +1,8 @@ +(((scissors) + (message) @injection.content) + (#set! injection.include-children) + (#set! injection.language "diff")) + +((rebase_command) @injection.content + (#set! injection.include-children) + (#set! injection.language "git-rebase")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/git-config/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/git-config/highlights.scm new file mode 100644 index 0000000..84767ed --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/git-config/highlights.scm @@ -0,0 +1,27 @@ +((section_name) @keyword.directive + (#eq? @keyword.directive "include")) + +((section_header + (section_name) @keyword.directive + (subsection_name)) + (#eq? @keyword.directive "includeIf")) + +(section_name) @markup.heading +(variable (name) @variable.other.member) +[(true) (false)] @constant.builtin.boolean +(integer) @constant.numeric.integer + +((string) @string.special.path + (#match? @string.special.path "^(~|./|/)")) + +[(string) (subsection_name)] @string + +[ + "[" + "]" + "\"" +] @punctuation.bracket + +"=" @punctuation.delimiter + +(comment) @comment diff --git a/helix-22.03-x86_64-windows/runtime/queries/git-diff/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/git-diff/highlights.scm new file mode 100644 index 0000000..1c1a882 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/git-diff/highlights.scm @@ -0,0 +1,6 @@ +[(addition) (new_file)] @diff.plus +[(deletion) (old_file)] @diff.minus + +(commit) @constant +(location) @attribute +(command) @markup.bold diff --git a/helix-22.03-x86_64-windows/runtime/queries/git-rebase/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/git-rebase/highlights.scm new file mode 100644 index 0000000..4f00703 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/git-rebase/highlights.scm @@ -0,0 +1,11 @@ +(operation operator: ["p" "pick" "r" "reword" "e" "edit" "s" "squash" "m" "merge" "d" "drop" "b" "break" "x" "exec"] @keyword) +(operation operator: ["l" "label" "t" "reset"] @function) +(operation operator: ["f" "fixup"] @function.special) + +(option) @operator +(label) @string.special.symbol +(commit) @constant +"#" @punctuation.delimiter +(comment) @comment + +(ERROR) @error diff --git a/helix-22.03-x86_64-windows/runtime/queries/git-rebase/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/git-rebase/injections.scm new file mode 100644 index 0000000..070129b --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/git-rebase/injections.scm @@ -0,0 +1,4 @@ +((operation + operator: ["x" "exec"] + (command) @injection.content) + (#set! injection.language "bash")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/glsl/folds.scm b/helix-22.03-x86_64-windows/runtime/queries/glsl/folds.scm new file mode 100644 index 0000000..a5a5208 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/glsl/folds.scm @@ -0,0 +1 @@ +; inherits: c diff --git a/helix-22.03-x86_64-windows/runtime/queries/glsl/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/glsl/highlights.scm new file mode 100644 index 0000000..af2a049 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/glsl/highlights.scm @@ -0,0 +1,37 @@ +; inherits: c + +[ + "in" + "out" + "inout" + "uniform" + "shared" + "layout" + "attribute" + "varying" + "buffer" + "coherent" + "readonly" + "writeonly" + "precision" + "highp" + "mediump" + "lowp" + "centroid" + "sample" + "patch" + "smooth" + "flat" + "noperspective" + "invariant" + "precise" +] @keyword + +"subroutine" @keyword.function + +(extension_storage_class) @attribute + +( + (identifier) @variable.builtin + (#match? @variable.builtin "^gl_") +) diff --git a/helix-22.03-x86_64-windows/runtime/queries/glsl/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/glsl/indents.toml new file mode 100644 index 0000000..a7fd499 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/glsl/indents.toml @@ -0,0 +1,19 @@ +indent = [ + "init_declarator", + "compound_statement", + "preproc_arg", + "field_declaration_list", + "case_statement", + "conditional_expression", + "enumerator_list", + "struct_specifier", + "compound_literal_expression" +] + +outdent = [ + "#define", + "#ifdef", + "#endif", + "{", + "}" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/glsl/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/glsl/injections.scm new file mode 100644 index 0000000..6330ea3 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/glsl/injections.scm @@ -0,0 +1,4 @@ +; inherits: c + +((preproc_arg) @injection.content + (#set! injection.language "glsl")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/glsl/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/glsl/locals.scm new file mode 100644 index 0000000..a5a5208 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/glsl/locals.scm @@ -0,0 +1 @@ +; inherits: c diff --git a/helix-22.03-x86_64-windows/runtime/queries/go/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/go/highlights.scm new file mode 100644 index 0000000..4ff8675 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/go/highlights.scm @@ -0,0 +1,152 @@ +; Function calls + +(call_expression + function: (identifier) @function) + +(call_expression + function: (selector_expression + field: (field_identifier) @function.method)) + +; Function definitions + +(function_declaration + name: (identifier) @function) + +(method_declaration + name: (field_identifier) @function.method) + +; Identifiers + +((identifier) @constant (match? @constant "^[A-Z][A-Z\\d_]+$")) +(const_spec + name: (identifier) @constant) + +(parameter_declaration (identifier) @variable.parameter) +(variadic_parameter_declaration (identifier) @variable.parameter) + +(type_identifier) @type +(field_identifier) @variable.other.member +(identifier) @variable +(package_identifier) @variable + + +; Operators + +[ + "--" + "-" + "-=" + ":=" + "!" + "!=" + "..." + "*" + "*" + "*=" + "/" + "/=" + "&" + "&&" + "&=" + "%" + "%=" + "^" + "^=" + "+" + "++" + "+=" + "<-" + "<" + "<<" + "<<=" + "<=" + "=" + "==" + ">" + ">=" + ">>" + ">>=" + "|" + "|=" + "||" + "~" +] @operator + +; Keywords + +[ + "break" + "case" + "chan" + "const" + "continue" + "default" + "defer" + "else" + "fallthrough" + "for" + "func" + "go" + "goto" + "if" + "interface" + "map" + "range" + "return" + "select" + "struct" + "switch" + "type" + "var" +] @keyword + +[ + "import" + "package" +] @keyword.control.import + +; Delimiters + +[ + ":" + "." + "," + ";" +] @punctuation.delimiter + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +; Literals + +[ + (interpreted_string_literal) + (raw_string_literal) + (rune_literal) +] @string + +(escape_sequence) @constant.character.escape + +[ + (int_literal) + (float_literal) + (imaginary_literal) +] @constant.numeric.integer + +[ + (true) + (false) +] @constant.builtin.boolean + +[ + (nil) + (iota) +] @constant.builtin + +(comment) @comment diff --git a/helix-22.03-x86_64-windows/runtime/queries/go/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/go/indents.toml new file mode 100644 index 0000000..7929ff5 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/go/indents.toml @@ -0,0 +1,30 @@ +indent = [ + "import_declaration", + "const_declaration", + #"var_declaration", + #"short_var_declaration", + "type_declaration", + "type_spec", + # simply block should be enough + # "function_declaration", + # "method_declaration", + # "composite_literal", + "func_literal", + "literal_value", + "element", + "keyed_element", + "expression_case", + "default_case", + "type_case", + "communication_case", + "argument_list", + "field_declaration_list", + "block", +] + +outdent = [ + "case", + "}", + "]", + ")" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/go/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/go/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/go/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/go/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/go/locals.scm new file mode 100644 index 0000000..d240e2b --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/go/locals.scm @@ -0,0 +1,30 @@ +; Scopes + +(block) @local.scope + +; Definitions + +(parameter_declaration (identifier) @local.definition) +(variadic_parameter_declaration (identifier) @local.definition) + +(short_var_declaration + left: (expression_list + (identifier) @local.definition)) + +(var_spec + name: (identifier) @local.definition) + +(for_statement + (range_clause + left: (expression_list + (identifier) @local.definition))) + +(const_declaration + (const_spec + name: (identifier) @local.definition)) + +; References + +(identifier) @local.reference +(field_identifier) @local.reference + diff --git a/helix-22.03-x86_64-windows/runtime/queries/go/tags.scm b/helix-22.03-x86_64-windows/runtime/queries/go/tags.scm new file mode 100644 index 0000000..d87008a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/go/tags.scm @@ -0,0 +1,30 @@ +( + (comment)* @doc + . + (function_declaration + name: (identifier) @name) @definition.function + (#strip! @doc "^//\\s*") + (#set-adjacent! @doc @definition.function) +) + +( + (comment)* @doc + . + (method_declaration + name: (field_identifier) @name) @definition.method + (#strip! @doc "^//\\s*") + (#set-adjacent! @doc @definition.method) +) + +(call_expression + function: [ + (identifier) @name + (parenthesized_expression (identifier) @name) + (selector_expression field: (field_identifier) @name) + (parenthesized_expression (selector_expression field: (field_identifier) @name)) + ]) @reference.call + +(type_spec + name: (type_identifier) @name) @definition.type + +(type_identifier) @name @reference.type diff --git a/helix-22.03-x86_64-windows/runtime/queries/go/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/go/textobjects.scm new file mode 100644 index 0000000..d77e14b --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/go/textobjects.scm @@ -0,0 +1,25 @@ +(function_declaration + body: (block)? @function.inside) @function.around + +(func_literal + (_)? @function.inside) @function.around + +(method_declaration + body: (block)? @function.inside) @function.around + +;; struct and interface declaration as class textobject? +(type_declaration + (type_spec (type_identifier) (struct_type (field_declaration_list (_)?) @class.inside))) @class.around + +(type_declaration + (type_spec (type_identifier) (interface_type (method_spec_list (_)?) @class.inside))) @class.around + +(parameter_list + (_) @parameter.inside) + +(argument_list + (_) @parameter.inside) + +(comment) @comment.inside + +(comment)+ @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/graphql/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/graphql/highlights.scm new file mode 100644 index 0000000..9fab405 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/graphql/highlights.scm @@ -0,0 +1,163 @@ +; Types +;------ + +(scalar_type_definition + (name) @type) + +(object_type_definition + (name) @type) + +(interface_type_definition + (name) @type) + +(union_type_definition + (name) @type) + +(enum_type_definition + (name) @type) + +(input_object_type_definition + (name) @type) + +(directive_definition + (name) @type) + +(directive_definition + "@" @type) + +(scalar_type_extension + (name) @type) + +(object_type_extension + (name) @type) + +(interface_type_extension + (name) @type) + +(union_type_extension + (name) @type) + +(enum_type_extension + (name) @type) + +(input_object_type_extension + (name) @type) + +(named_type + (name) @type) + +(directive) @type + +; Properties +;----------- + +(field + (name) @variable.other.member) + +(field + (alias + (name) @variable.other.member)) + +(field_definition + (name) @variable.other.member) + +(object_value + (object_field + (name) @variable.other.member)) + +(enum_value + (name) @variable.other.member) + +; Variable Definitions and Arguments +;----------------------------------- + +(operation_definition + (name) @variable) + +(fragment_name + (name) @variable) + +(input_fields_definition + (input_value_definition + (name) @variable.parameter)) + +(argument + (name) @variable.parameter) + +(arguments_definition + (input_value_definition + (name) @variable.parameter)) + +(variable_definition + (variable) @variable.parameter) + +(argument + (value + (variable) @variable)) + +; Constants +;---------- + +(string_value) @string + +(int_value) @constants.numeric.integer + +(float_value) @constants.numeric.float + +(boolean_value) @constants.builtin.boolean + +; Literals +;--------- + +(description) @comment + +(comment) @comment + +(directive_location + (executable_directive_location) @type.builtin) + +(directive_location + (type_system_directive_location) @type.builtin) + +; Keywords +;---------- + +[ + "query" + "mutation" + "subscription" + "fragment" + "scalar" + "type" + "interface" + "union" + "enum" + "input" + "extend" + "directive" + "schema" + "on" + "repeatable" + "implements" +] @keyword + +; Punctuation +;------------ + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +"=" @operator + +"|" @punctuation.delimiter +"&" @punctuation.delimiter +":" @punctuation.delimiter + +"..." @punctuation.special +"!" @punctuation.special diff --git a/helix-22.03-x86_64-windows/runtime/queries/haskell/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/haskell/highlights.scm new file mode 100644 index 0000000..5009f3b --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/haskell/highlights.scm @@ -0,0 +1,125 @@ +;; ---------------------------------------------------------------------------- +;; Literals and comments + +(integer) @constant.numeric.integer +(exp_negation) @constant.numeric.integer +(exp_literal (float)) @constant.numeric.float +(char) @constant.character +(string) @string + +(con_unit) @constant.builtin ; unit, as in () + +(comment) @comment + + +;; ---------------------------------------------------------------------------- +;; Punctuation + +[ + "(" + ")" + "{" + "}" + "[" + "]" +] @punctuation.bracket + +[ + (comma) + ";" +] @punctuation.delimiter + + +;; ---------------------------------------------------------------------------- +;; Keywords, operators, includes + +(pragma) @constant.macro + +[ + "if" + "then" + "else" + "case" + "of" +] @keyword.control.conditional + +[ + "import" + "qualified" + "module" +] @keyword.control.import + +[ + (operator) + (constructor_operator) + (type_operator) + (tycon_arrow) + (qualified_module) ; grabs the `.` (dot), ex: import System.IO + (all_names) + (wildcard) + "=" + "|" + "::" + "=>" + "->" + "<-" + "\\" + "`" + "@" +] @operator + +(qualified_module (module) @constructor) +(qualified_type (module) @namespace) +(qualified_variable (module) @namespace) +(import (module) @namespace) + +[ + (where) + "let" + "in" + "class" + "instance" + "data" + "newtype" + "family" + "type" + "as" + "hiding" + "deriving" + "via" + "stock" + "anyclass" + "do" + "mdo" + "rec" + "forall" + "∀" + "infix" + "infixl" + "infixr" +] @keyword + + +;; ---------------------------------------------------------------------------- +;; Functions and variables + +(signature name: (variable) @type) +(function name: (variable) @function) + +(variable) @variable +"_" @variable.builtin + +(exp_infix (variable) @operator) ; consider infix functions as operators + +("@" @namespace) ; "as" pattern operator, e.g. x@Constructor + + +;; ---------------------------------------------------------------------------- +;; Types + +(type) @type + +(constructor) @constructor + +; True or False +((constructor) @_bool (#match? @_bool "(True|False)")) @constant.builtin.boolean diff --git a/helix-22.03-x86_64-windows/runtime/queries/haskell/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/haskell/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/haskell/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/haskell/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/haskell/locals.scm new file mode 100644 index 0000000..ad67fe4 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/haskell/locals.scm @@ -0,0 +1,4 @@ +(signature name: (variable)) @local.definition +(function name: (variable)) @local.definition +(pat_name (variable)) @local.definition +(exp_name (variable)) @local.reference diff --git a/helix-22.03-x86_64-windows/runtime/queries/hcl/folds.scm b/helix-22.03-x86_64-windows/runtime/queries/hcl/folds.scm new file mode 100644 index 0000000..cb20b2a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/hcl/folds.scm @@ -0,0 +1,6 @@ +[ + (comment) + (block) + (heredoc_template) + (object) +] @fold diff --git a/helix-22.03-x86_64-windows/runtime/queries/hcl/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/hcl/highlights.scm new file mode 100644 index 0000000..03b3e52 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/hcl/highlights.scm @@ -0,0 +1,100 @@ +(ERROR) @error + +; { key: val } + +(object_elem val: (expression + (variable_expr + (identifier) @type.builtin (#match? @type.builtin "^(bool|string|number|object|tuple|list|map|set|any)$")))) + +(get_attr (identifier) @variable.builtin (#match? @variable.builtin "^(root|cwd|module)$")) +(variable_expr (identifier) @variable.builtin (#match? @variable.builtin "^(var|local|path)$")) +((identifier) @type.builtin (#match? @type.builtin "^(bool|string|number|object|tuple|list|map|set|any)$")) +((identifier) @keyword (#match? @keyword "^(module|root|cwd|resource|variable|data|locals|terraform|provider|output)$")) + +; highlight identifier keys as though they were block attributes +(object_elem key: (expression (variable_expr (identifier) @variable.other.member))) + +(attribute (identifier) @variable.other.member) +(function_call (identifier) @function.method) +(block (identifier) @type.builtin) + +(identifier) @variable +(comment) @comment +(null_lit) @constant.builtin +(numeric_lit) @constant.number +(bool_lit) @constant.builtin.boolean + +[ + (template_interpolation_start) ; ${ + (template_interpolation_end) ; } + (template_directive_start) ; %{ + (template_directive_end) ; } + (strip_marker) ; ~ +] @punctuation.special + +[ + (heredoc_identifier) ; <" +] @punctuation.special + +[ + "." + ".*" + "," + "[*]" +] @punctuation.delimiter + +[ + "{" + "}" + "[" + "]" + "(" + ")" +] @punctuation.bracket + +[ + "!" + "\*" + "/" + "%" + "\+" + "-" + ">" + ">=" + "<" + "<=" + "==" + "!=" + "&&" + "||" +] @operator diff --git a/helix-22.03-x86_64-windows/runtime/queries/hcl/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/hcl/indents.toml new file mode 100644 index 0000000..b0d4a3f --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/hcl/indents.toml @@ -0,0 +1,13 @@ +indent = [ + "object", + "block", + "tuple", + "for_tuple_expr", + "for_object_expr" +] + +outdent = [ + "object_end", + "block_end", + "tuple_end" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/hcl/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/hcl/injections.scm new file mode 100644 index 0000000..fd69161 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/hcl/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/html/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/html/highlights.scm new file mode 100644 index 0000000..2c70a9c --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/html/highlights.scm @@ -0,0 +1,12 @@ +(tag_name) @tag +(erroneous_end_tag_name) @tag.error +(doctype) @constant +(attribute_name) @attribute +(attribute_value) @string +(comment) @comment + +[ + "<" + ">" + "" + ">" + ">=" + ">>" + ">>=" + ">>>" + ">>>=" + "~" + "^" + "&" + "|" + "^=" + "&=" + "|=" + "&&" + "||" + "??" + "&&=" + "||=" + "??=" +] @operator + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +[ + "as" + "async" + "await" + "break" + "case" + "catch" + "class" + "const" + "continue" + "debugger" + "default" + "delete" + "do" + "else" + "export" + "extends" + "finally" + "for" + "from" + "function" + "get" + "if" + "import" + "in" + "instanceof" + "let" + "new" + "of" + "return" + "set" + "static" + "switch" + "target" + "throw" + "try" + "typeof" + "var" + "void" + "while" + "with" + "yield" +] @keyword diff --git a/helix-22.03-x86_64-windows/runtime/queries/javascript/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/javascript/indents.toml new file mode 100644 index 0000000..9d711ab --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/javascript/indents.toml @@ -0,0 +1,28 @@ +indent = [ + "array", + "object", + "arguments", + "formal_parameters", + + "statement_block", + "object_pattern", + "class_body", + "named_imports", + + "binary_expression", + "return_statement", + "template_substitution", + # (expression_statement (call_expression)) + "export_clause", + + # typescript + "enum_declaration", + "interface_declaration", + "object_type", +] + +outdent = [ + "}", + "]", + ")" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/javascript/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/javascript/injections.scm new file mode 100644 index 0000000..e842911 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/javascript/injections.scm @@ -0,0 +1,28 @@ +; Parse the contents of tagged template literals using +; a language inferred from the tag. + +(call_expression + function: [ + (identifier) @injection.language + (member_expression + property: (property_identifier) @injection.language) + ] + arguments: (template_string) @injection.content) + +; Parse the contents of gql template literals + +((call_expression + function: (identifier) @_template_function_name + arguments: (template_string) @injection.content) + (#eq? @_template_function_name "gql") + (#set! injection.language "graphql")) + +; Parse regex syntax within regex literals + +((regex_pattern) @injection.content + (#set! injection.language "regex")) + + ; Parse JSDoc annotations in comments + +((comment) @injection.content + (#set! injection.language "jsdoc")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/javascript/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/javascript/locals.scm new file mode 100644 index 0000000..5d680ac --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/javascript/locals.scm @@ -0,0 +1,23 @@ +; Scopes +;------- + +[ + (statement_block) + (function) + (arrow_function) + (function_declaration) + (method_definition) +] @local.scope + +; Definitions +;------------ + +(pattern/identifier)@local.definition + +(variable_declarator + name: (identifier) @local.definition) + +; References +;------------ + +(identifier) @local.reference diff --git a/helix-22.03-x86_64-windows/runtime/queries/javascript/tags.scm b/helix-22.03-x86_64-windows/runtime/queries/javascript/tags.scm new file mode 100644 index 0000000..a7bbd31 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/javascript/tags.scm @@ -0,0 +1,88 @@ +( + (comment)* @doc + . + (method_definition + name: (property_identifier) @name) @definition.method + (#not-eq? @name "constructor") + (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$") + (#select-adjacent! @doc @definition.method) +) + +( + (comment)* @doc + . + [ + (class + name: (_) @name) + (class_declaration + name: (_) @name) + ] @definition.class + (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$") + (#select-adjacent! @doc @definition.class) +) + +( + (comment)* @doc + . + [ + (function + name: (identifier) @name) + (function_declaration + name: (identifier) @name) + (generator_function + name: (identifier) @name) + (generator_function_declaration + name: (identifier) @name) + ] @definition.function + (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$") + (#select-adjacent! @doc @definition.function) +) + +( + (comment)* @doc + . + (lexical_declaration + (variable_declarator + name: (identifier) @name + value: [(arrow_function) (function)]) @definition.function) + (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$") + (#select-adjacent! @doc @definition.function) +) + +( + (comment)* @doc + . + (variable_declaration + (variable_declarator + name: (identifier) @name + value: [(arrow_function) (function)]) @definition.function) + (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$") + (#select-adjacent! @doc @definition.function) +) + +(assignment_expression + left: [ + (identifier) @name + (member_expression + property: (property_identifier) @name) + ] + right: [(arrow_function) (function)] +) @definition.function + +(pair + key: (property_identifier) @name + value: [(arrow_function) (function)]) @definition.function + +( + (call_expression + function: (identifier) @name) @reference.call + (#not-match? @name "^(require)$") +) + +(call_expression + function: (member_expression + property: (property_identifier) @name) + arguments: (_) @reference.call) + +(new_expression + constructor: (_) @name) @reference.class diff --git a/helix-22.03-x86_64-windows/runtime/queries/json/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/json/highlights.scm new file mode 100644 index 0000000..6df6c9e --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/json/highlights.scm @@ -0,0 +1,20 @@ +[ + (true) + (false) +] @constant.builtin.boolean +(null) @constant.builtin +(number) @constant.numeric +(pair + key: (_) @keyword) + +(string) @string +(escape_sequence) @constant.character.escape +(ERROR) @error + +"," @punctuation.delimiter +[ + "[" + "]" + "{" + "}" +] @punctuation.bracket diff --git a/helix-22.03-x86_64-windows/runtime/queries/json/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/json/indents.toml new file mode 100644 index 0000000..64a8d17 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/json/indents.toml @@ -0,0 +1,9 @@ +indent = [ + "object", + "array" +] + +outdent = [ + "]", + "}" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/julia/folds.scm b/helix-22.03-x86_64-windows/runtime/queries/julia/folds.scm new file mode 100644 index 0000000..91eede5 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/julia/folds.scm @@ -0,0 +1,11 @@ +[ + (module_definition) + (struct_definition) + (macro_definition) + (function_definition) + (compound_expression) ; begin blocks + (let_statement) + (if_statement) + (for_statement) + (while_statement) +] @fold diff --git a/helix-22.03-x86_64-windows/runtime/queries/julia/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/julia/highlights.scm new file mode 100644 index 0000000..7c44798 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/julia/highlights.scm @@ -0,0 +1,184 @@ + +[ + (triple_string) + (string) +] @string + +(string + prefix: (identifier) @constant.builtin) + +(macro_identifier) @function.macro +(macro_identifier (identifier) @function.macro) ; for any one using the variable highlight +(macro_definition + name: (identifier) @function.macro + ["macro" "end" @keyword]) + +(field_expression + (identifier) + (identifier) @variable.other.member .) + +(function_definition + name: (identifier) @function) +(call_expression + (identifier) @function) +(call_expression + (field_expression (identifier) @function.method .)) +(broadcast_call_expression + (identifier) @function) +(broadcast_call_expression + (field_expression (identifier) @function.method .)) +(parameter_list + (identifier) @variable.parameter) +(parameter_list + (optional_parameter . + (identifier) @variable.parameter)) +(typed_parameter + (identifier) @variable.parameter + (identifier) @type) +(type_parameter_list + (identifier) @type) +(typed_parameter + (identifier) @variable.parameter + (parameterized_identifier) @type) +(function_expression + . (identifier) @variable.parameter) +(spread_parameter) @variable.parameter +(spread_parameter + (identifier) @variable.parameter) +(named_argument + . (identifier) @variable.parameter) +(argument_list + (typed_expression + (identifier) @variable.parameter + (identifier) @type)) +(argument_list + (typed_expression + (identifier) @variable.parameter + (parameterized_identifier) @type)) + +;; Symbol expressions (:my-wanna-be-lisp-keyword) +(quote_expression + (identifier)) @string.special.symbol + +;; Parsing error! foo (::Type) get's 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) @variable.parameter)) + +(typed_expression + (identifier) @type .) +(typed_expression + (parameterized_identifier) @type .) + +(struct_definition + name: (identifier) @type) + +(number) @constant.numeric.integer +(range_expression + (identifier) @constant.numeric.integer + (eq? @constant.numeric.integer "end")) +(range_expression + (_ + (identifier) @constant.numeric.integer + (eq? @constant.numeric.integer "end"))) +(coefficient_expression + (number) + (identifier) @constant.builtin) + +;; TODO: operators. +;; Those are a bit difficult to implement since the respective nodes are hidden right now (_power_operator) +;; and heavily use Unicode chars (support for those are bad in vim/lua regexes) +;[; + ;(power_operator); + ;(times_operator); + ;(plus_operator); + ;(arrow_operator); + ;(comparison_operator); + ;(assign_operator); +;] @operator ; + +"end" @keyword + +(if_statement + ["if" "end"] @keyword.control.conditional) +(elseif_clause + ["elseif"] @keyword.control.conditional) +(else_clause + ["else"] @keyword.control.conditional) +(ternary_expression + ["?" ":"] @keyword.control.conditional) + +(function_definition ["function" "end"] @keyword.function) + +(comment) @comment + +[ + "const" + "return" + "macro" + "struct" + "primitive" + "type" +] @keyword + +((identifier) @keyword (match? @keyword "global|local")) + +(compound_expression + ["begin" "end"] @keyword) +(try_statement + ["try" "end" ] @keyword.control.exception) +(finally_clause + "finally" @keyword.control.exception) +(catch_clause + "catch" @keyword.control.exception) +(quote_statement + ["quote" "end"] @keyword) +(let_statement + ["let" "end"] @keyword) +(for_statement + ["for" "end"] @keyword.control.repeat) +(while_statement + ["while" "end"] @keyword.control.repeat) +(break_statement) @keyword.control.repeat +(continue_statement) @keyword.control.repeat +(for_binding + "in" @keyword.control.repeat) +(for_clause + "for" @keyword.control.repeat) +(do_clause + ["do" "end"] @keyword) + +(export_statement + ["export"] @keyword.control.import) + +[ + "using" + "module" + "import" +] @keyword.control.import + +((identifier) @keyword.control.import (#eq? @keyword.control.import "baremodule")) + +(((identifier) @constant.builtin) (match? @constant.builtin "^(nothing|Inf|NaN)$")) +(((identifier) @constant.builtin.boolean) (#eq? @constant.builtin.boolean "true")) +(((identifier) @constant.builtin.boolean) (#eq? @constant.builtin.boolean "false")) + + +["::" ":" "." "," "..." "!"] @punctuation.delimiter +["[" "]" "(" ")" "{" "}"] @punctuation.bracket + +["="] @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][^_]")) +((identifier) @constant + (match? @constant "^[A-Z][A-Z_]{2}[A-Z_]*$")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/julia/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/julia/injections.scm new file mode 100644 index 0000000..1c1e804 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/julia/injections.scm @@ -0,0 +1,5 @@ +((triple_string) @injection.content + (#set! injection.language "markdown")) + +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/julia/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/julia/locals.scm new file mode 100644 index 0000000..d5ac794 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/julia/locals.scm @@ -0,0 +1,59 @@ + +(import_statement + (identifier) @definition.import) +(variable_declaration + (identifier) @local.definition) +(variable_declaration + (tuple_expression + (identifier) @local.definition)) +(for_binding + (identifier) @local.definition) +(for_binding + (tuple_expression + (identifier) @local.definition)) + +(assignment_expression + (tuple_expression + (identifier) @local.definition)) +(assignment_expression + (bare_tuple_expression + (identifier) @local.definition)) +(assignment_expression + (identifier) @local.definition) + +(type_parameter_list + (identifier) @definition.type) +(type_argument_list + (identifier) @definition.type) +(struct_definition + name: (identifier) @definition.type) + +(parameter_list + (identifier) @definition.parameter) +(typed_parameter + (identifier) @definition.parameter + (identifier)) +(function_expression + . (identifier) @definition.parameter) +(argument_list + (typed_expression + (identifier) @definition.parameter + (identifier))) +(spread_parameter + (identifier) @definition.parameter) + +(function_definition + name: (identifier) @definition.function) @local.scope +(macro_definition + name: (identifier) @definition.macro) @local.scope + +(identifier) @local.reference + +[ + (try_statement) + (finally_clause) + (quote_statement) + (let_statement) + (compound_expression) + (for_statement) +] @local.scope diff --git a/helix-22.03-x86_64-windows/runtime/queries/kotlin/folds.scm b/helix-22.03-x86_64-windows/runtime/queries/kotlin/folds.scm new file mode 100644 index 0000000..768972b --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/kotlin/folds.scm @@ -0,0 +1,17 @@ +[ + (import_list) + + (when_expression) + (control_structure_body) + + (lambda_literal) + (function_body) + (primary_constructor) + (secondary_constructor) + (anonymous_initializer) + + (class_body) + (enum_class_body) + + (interpolated_expression) +] @fold diff --git a/helix-22.03-x86_64-windows/runtime/queries/kotlin/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/kotlin/highlights.scm new file mode 100644 index 0000000..7b90fcf --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/kotlin/highlights.scm @@ -0,0 +1,295 @@ +;;; Operators & Punctuation + +(multi_line_string_literal + "$" @punctuation + (interpolated_identifier) @none) +(multi_line_string_literal + "${" @punctuation + (interpolated_expression) @none + "}" @punctuation.) + +; NOTE: `interpolated_identifier`s can be highlighted in any way +(line_string_literal + "$" @punctuation + (interpolated_identifier) @none) +(line_string_literal + "${" @punctuation + (interpolated_expression) @none + "}" @punctuation) + +[ + "." + "," + ";" + ":" + "::" +] @punctuation.delimiter + +[ + "(" ")" + "[" "]" + "{" "}" +] @punctuation.bracket + +[ + "!" + "!=" + "!==" + "=" + "==" + "===" + ">" + ">=" + "<" + "<=" + "||" + "&&" + "+" + "++" + "+=" + "-" + "--" + "-=" + "*" + "*=" + "/" + "/=" + "%" + "%=" + "?." + "?:" + "!!" + "is" + "!is" + "in" + "!in" + "as" + "as?" + ".." + "->" +] @operator + +;;; Keywords + +(type_alias "typealias" @keyword) +[ + (class_modifier) + (member_modifier) + (function_modifier) + (property_modifier) + (platform_modifier) + (variance_modifier) + (parameter_modifier) + (visibility_modifier) + (reification_modifier) + (inheritance_modifier) +]@keyword + +[ + "val" + "var" + "enum" + "class" + "object" + "interface" +; "typeof" ; NOTE: It is reserved for future use +] @keyword + +("fun") @keyword.function + +(jump_expression) @keyword.control.return + +[ + "if" + "else" + "when" +] @keyword.control.conditional + +[ + "for" + "do" + "while" +] @keyword.control.repeat + +[ + "try" + "catch" + "throw" + "finally" +] @keyword.control.exception + +(annotation + "@" @attribute (use_site_target)? @attribute) +(annotation + (user_type + (type_identifier) @attribute)) +(annotation + (constructor_invocation + (user_type + (type_identifier) @attribute))) + +(file_annotation + "@" @attribute "file" @attribute ":" @attribute) +(file_annotation + (user_type + (type_identifier) @attribute)) +(file_annotation + (constructor_invocation + (user_type + (type_identifier) @attribute))) + +;;; Literals +; NOTE: Escapes not allowed in multi-line strings +(line_string_literal (character_escape_seq) @constant.character.escape) + +[ + (line_string_literal) + (multi_line_string_literal) +] @string + +(character_literal) @constant.character + +[ + "null" ; should be highlighted the same as booleans + (boolean_literal) +] @constant.builtin.boolean + +(real_literal) @constant.numeric.float +[ + (integer_literal) + (long_literal) + (hex_literal) + (bin_literal) + (unsigned_literal) +] @constant.numeric.integer + +[ + (comment) + (shebang_line) +] @comment + +;;; Function calls + +(call_expression + . (simple_identifier) @function.builtin + (#match? @function.builtin "^(arrayOf|arrayOfNulls|byteArrayOf|shortArrayOf|intArrayOf|longArrayOf|ubyteArrayOf|ushortArrayOf|uintArrayOf|ulongArrayOf|floatArrayOf|doubleArrayOf|booleanArrayOf|charArrayOf|emptyArray|mapOf|setOf|listOf|emptyMap|emptySet|emptyList|mutableMapOf|mutableSetOf|mutableListOf|print|println|error|TODO|run|runCatching|repeat|lazy|lazyOf|enumValues|enumValueOf|assert|check|checkNotNull|require|requireNotNull|with|suspend|synchronized)$")) + +; object.function() or object.property.function() +(call_expression + (navigation_expression + (navigation_suffix + (simple_identifier) @function) . )) + +; function() +(call_expression + . (simple_identifier) @function) + +;;; Function definitions + +; lambda parameters +(lambda_literal + (lambda_parameters + (variable_declaration + (simple_identifier) @variable.parameter))) + +(parameter_with_optional_type + (simple_identifier) @variable.parameter) + +(parameter + (simple_identifier) @variable.parameter) + +(anonymous_initializer + ("init") @constructor) + +(constructor_invocation + (user_type + (type_identifier) @constructor)) + +(secondary_constructor + ("constructor") @constructor) +(primary_constructor) @constructor + +(getter + ("get") @function.builtin) +(setter + ("set") @function.builtin) + +(function_declaration + . (simple_identifier) @function) + +; TODO: Seperate labeled returns/breaks/continue/super/this +; Must be implemented in the parser first +(label) @label + +(import_header + (identifier + (simple_identifier) @function @_import .) + (import_alias + (type_identifier) @function)? + (#match? @_import "^[a-z]")) + +; The last `simple_identifier` in a `import_header` will always either be a function +; or a type. Classes can appear anywhere in the import path, unlike functions +(import_header + (identifier + (simple_identifier) @type @_import) + (import_alias + (type_identifier) @type)? + (#match? @_import "^[A-Z]")) + +(import_header + "import" @keyword.control.import) + +(package_header + . (identifier)) @namespace + +((type_identifier) @type.builtin + (#match? @function.builtin "^(Byte|Short|Int|Long|UByte|UShort|UInt|ULong|Float|Double|Boolean|Char|String|Array|ByteArray|ShortArray|IntArray|LongArray|UByteArray|UShortArray|UIntArray|ULongArray|FloatArray|DoubleArray|BooleanArray|CharArray|Map|Set|List|EmptyMap|EmptySet|EmptyList|MutableMap|MutableSet|MutableList)$")) + +(type_identifier) @type + +(enum_entry + (simple_identifier) @constant) + +(_ + (navigation_suffix + (simple_identifier) @constant + (#match? @constant "^[A-Z][A-Z0-9_]*$"))) + +; SCREAMING CASE identifiers are assumed to be constants +((simple_identifier) @constant +(#match? @constant "^[A-Z][A-Z0-9_]*$")) + +; id_1.id_2.id_3: `id_2` and `id_3` are assumed as object properties +(_ + (navigation_suffix + (simple_identifier) @variable.other.member)) + +(class_body + (property_declaration + (variable_declaration + (simple_identifier) @variable.other.member))) + +(class_parameter + (simple_identifier) @variable.other.member) + +; `super` keyword inside classes +(super_expression) @variable.builtin + +; `this` this keyword inside classes +(this_expression) @variable.builtin + +;;; Identifiers +; `field` keyword inside property getter/setter +; FIXME: This will highlight the keyword outside of getters and setters +; since tree-sitter does not allow us to check for arbitrary nestation +((simple_identifier) @variable.builtin +(#eq? @variable.builtin "field")) + +; `it` keyword inside lambdas +; FIXME: This will highlight the keyword outside of lambdas since tree-sitter +; does not allow us to check for arbitrary nestation +((simple_identifier) @variable.builtin +(#eq? @variable.builtin "it")) + +(simple_identifier) @variable diff --git a/helix-22.03-x86_64-windows/runtime/queries/kotlin/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/kotlin/injections.scm new file mode 100644 index 0000000..abdc205 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/kotlin/injections.scm @@ -0,0 +1,36 @@ +((comment) @injection.content + (#set! injection.language "comment")) + +; There are 3 ways to define a regex +; - "[abc]?".toRegex() +((call_expression + (navigation_expression + ([(line_string_literal) (multi_line_string_literal)] @injection.content) + (navigation_suffix + ((simple_identifier) @_function + (#eq? @_function "toRegex"))))) + (#set! injection.language "regex")) + +; - Regex("[abc]?") +((call_expression + ((simple_identifier) @_function + (#eq? @_function "Regex")) + (call_suffix + (value_arguments + (value_argument + [ (line_string_literal) (multi_line_string_literal) ] @injection.content)))) + (#set! injection.language "regex")) + +; - Regex.fromLiteral("[abc]?") +((call_expression + (navigation_expression + ((simple_identifier) @_class + (#eq? @_class "Regex")) + (navigation_suffix + ((simple_identifier) @_function + (#eq? @_function "fromLiteral")))) + (call_suffix + (value_arguments + (value_argument + [ (line_string_literal) (multi_line_string_literal) ] @injection.content)))) + (#set! injection.language "regex")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/latex/folds.scm b/helix-22.03-x86_64-windows/runtime/queries/latex/folds.scm new file mode 100644 index 0000000..fb5c717 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/latex/folds.scm @@ -0,0 +1,12 @@ +[ + (chapter) + (part) + (section) + (subsection) + (subsubsection) + (paragraph) + (subparagraph) + + (environment) + (displayed_equation) +] @fold diff --git a/helix-22.03-x86_64-windows/runtime/queries/latex/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/latex/highlights.scm new file mode 100644 index 0000000..0a030b3 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/latex/highlights.scm @@ -0,0 +1,410 @@ +;; Math +[ + (displayed_equation) + (inline_formula) +] @text.math + +;; This highlights the whole environment like vimtex does +((environment + (begin + name: (word) @_env)) @text.math + (#any-of? @_env + "displaymath" "displaymath*" + "equation" "equation*" + "multline" "multline*" + "eqnarray" "eqnarray*" + "align" "align*" + "array" "array*" + "split" "split*" + "alignat" "alignat*" + "gather" "gather*" + "flalign" "flalign*")) + +[ + (generic_command_name) + "\\newcommand" + "\\renewcommand" + "\\DeclareRobustCommand" + "\\DeclareMathOperator" + "\\newglossaryentry" + "\\caption" + "\\label" + "\\newlabel" + "\\color" + "\\colorbox" + "\\textcolor" + "\\pagecolor" + "\\definecolor" + "\\definecolorset" + "\\newtheorem" + "\\declaretheorem" + "\\newacronym" +] @function.macro + +[ + "\\ref" + "\\vref" + "\\Vref" + "\\autoref" + "\\pageref" + "\\cref" + "\\Cref" + "\\cref*" + "\\Cref*" + "\\namecref" + "\\nameCref" + "\\lcnamecref" + "\\namecrefs" + "\\nameCrefs" + "\\lcnamecrefs" + "\\labelcref" + "\\labelcpageref" + "\\crefrange" + "\\crefrange" + "\\Crefrange" + "\\Crefrange" + "\\crefrange*" + "\\crefrange*" + "\\Crefrange*" + "\\Crefrange*" +] @function.macro + +[ + "\\cite" + "\\cite*" + "\\Cite" + "\\nocite" + "\\citet" + "\\citep" + "\\citet*" + "\\citep*" + "\\citeauthor" + "\\citeauthor*" + "\\Citeauthor" + "\\Citeauthor*" + "\\citetitle" + "\\citetitle*" + "\\citeyear" + "\\citeyear*" + "\\citedate" + "\\citedate*" + "\\citeurl" + "\\fullcite" + "\\citeyearpar" + "\\citealt" + "\\citealp" + "\\citetext" + "\\parencite" + "\\parencite*" + "\\Parencite" + "\\footcite" + "\\footfullcite" + "\\footcitetext" + "\\textcite" + "\\Textcite" + "\\smartcite" + "\\Smartcite" + "\\supercite" + "\\autocite" + "\\Autocite" + "\\autocite*" + "\\Autocite*" + "\\volcite" + "\\Volcite" + "\\pvolcite" + "\\Pvolcite" + "\\fvolcite" + "\\ftvolcite" + "\\svolcite" + "\\Svolcite" + "\\tvolcite" + "\\Tvolcite" + "\\avolcite" + "\\Avolcite" + "\\notecite" + "\\notecite" + "\\pnotecite" + "\\Pnotecite" + "\\fnotecite" +] @function.macro + +[ + "\\ref" + "\\vref" + "\\Vref" + "\\autoref" + "\\pageref" + "\\cref" + "\\Cref" + "\\cref*" + "\\Cref*" + "\\namecref" + "\\nameCref" + "\\lcnamecref" + "\\namecrefs" + "\\nameCrefs" + "\\lcnamecrefs" + "\\labelcref" + "\\labelcpageref" +] @function.macro + + +[ + "\\crefrange" + "\\crefrange" + "\\Crefrange" + "\\Crefrange" + "\\crefrange*" + "\\crefrange*" + "\\Crefrange*" + "\\Crefrange*" +] @function.macro + + +[ + "\\gls" + "\\Gls" + "\\GLS" + "\\glspl" + "\\Glspl" + "\\GLSpl" + "\\glsdisp" + "\\glslink" + "\\glstext" + "\\Glstext" + "\\GLStext" + "\\glsfirst" + "\\Glsfirst" + "\\GLSfirst" + "\\glsplural" + "\\Glsplural" + "\\GLSplural" + "\\glsfirstplural" + "\\Glsfirstplural" + "\\GLSfirstplural" + "\\glsname" + "\\Glsname" + "\\GLSname" + "\\glssymbol" + "\\Glssymbol" + "\\glsdesc" + "\\Glsdesc" + "\\GLSdesc" + "\\glsuseri" + "\\Glsuseri" + "\\GLSuseri" + "\\glsuserii" + "\\Glsuserii" + "\\GLSuserii" + "\\glsuseriii" + "\\Glsuseriii" + "\\GLSuseriii" + "\\glsuseriv" + "\\Glsuseriv" + "\\GLSuseriv" + "\\glsuserv" + "\\Glsuserv" + "\\GLSuserv" + "\\glsuservi" + "\\Glsuservi" + "\\GLSuservi" +] @function.macro + + +[ + "\\acrshort" + "\\Acrshort" + "\\ACRshort" + "\\acrshortpl" + "\\Acrshortpl" + "\\ACRshortpl" + "\\acrlong" + "\\Acrlong" + "\\ACRlong" + "\\acrlongpl" + "\\Acrlongpl" + "\\ACRlongpl" + "\\acrfull" + "\\Acrfull" + "\\ACRfull" + "\\acrfullpl" + "\\Acrfullpl" + "\\ACRfullpl" + "\\acs" + "\\Acs" + "\\acsp" + "\\Acsp" + "\\acl" + "\\Acl" + "\\aclp" + "\\Aclp" + "\\acf" + "\\Acf" + "\\acfp" + "\\Acfp" + "\\ac" + "\\Ac" + "\\acp" + "\\glsentrylong" + "\\Glsentrylong" + "\\glsentrylongpl" + "\\Glsentrylongpl" + "\\glsentryshort" + "\\Glsentryshort" + "\\glsentryshortpl" + "\\Glsentryshortpl" + "\\glsentryfullpl" + "\\Glsentryfullpl" +] @function.macro + +(comment) @comment + +(bracket_group) @variable.parameter + +[(math_operator) "="] @operator + +[ + "\\usepackage" + "\\documentclass" + "\\input" + "\\include" + "\\subfile" + "\\subfileinclude" + "\\subfileinclude" + "\\includegraphics" + "\\addbibresource" + "\\bibliography" + "\\includesvg" + "\\includeinkscape" + "\\usepgflibrary" + "\\usetikzlibrary" +] @keyword.control.import + +[ + "\\part" + "\\chapter" + "\\section" + "\\subsection" + "\\subsubsection" + "\\paragraph" + "\\subparagraph" +] @type + +"\\item" @punctuation.special + +((word) @punctuation.delimiter +(#eq? @punctuation.delimiter "&")) + +["$" "\\[" "\\]" "\\(" "\\)"] @punctuation.delimiter + +(label_definition + name: (_) @text.reference) +(label_reference + label: (_) @text.reference) +(equation_label_reference + label: (_) @text.reference) +(label_reference + label: (_) @text.reference) +(label_number + label: (_) @text.reference) + +(citation + key: (word) @text.reference) + +(key_val_pair + key: (_) @variable.parameter + value: (_)) + +["[" "]" "{" "}"] @punctuation.bracket ;"(" ")" is has no special meaning in LaTeX + +(chapter + text: (brace_group) @markup.heading) + +(part + text: (brace_group) @markup.heading) + +(section + text: (brace_group) @markup.heading) + +(subsection + text: (brace_group) @markup.heading) + +(subsubsection + text: (brace_group) @markup.heading) + +(paragraph + text: (brace_group) @markup.heading) + +(subparagraph + text: (brace_group) @markup.heading) + +((environment + (begin + name: (word) @_frame) + (brace_group + child: (text) @markup.heading)) + (#eq? @_frame "frame")) + +((generic_command + name:(generic_command_name) @_name + arg: (brace_group + (text) @markup.heading)) + (#eq? @_name "\\frametitle")) + +;; Formatting + +((generic_command + name:(generic_command_name) @_name + arg: (_) @markup.italic) + (#eq? @_name "\\emph")) + +((generic_command + name:(generic_command_name) @_name + arg: (_) @markup.italic) + (#match? @_name "^(\\\\textit|\\\\mathit)$")) + +((generic_command + name:(generic_command_name) @_name + arg: (_) @markup.bold) + (#match? @_name "^(\\\\textbf|\\\\mathbf)$")) + +((generic_command + name:(generic_command_name) @_name + . + arg: (_) @markup.link.url) + (#match? @_name "^(\\\\url|\\\\href)$")) + +(ERROR) @error + +[ + "\\begin" + "\\end" +] @text.environment + +(begin + name: (_) @text.environment.name + (#not-any-of? @text.environment.name + "displaymath" "displaymath*" + "equation" "equation*" + "multline" "multline*" + "eqnarray" "eqnarray*" + "align" "align*" + "array" "array*" + "split" "split*" + "alignat" "alignat*" + "gather" "gather*" + "flalign" "flalign*")) + +(end + name: (_) @text.environment.name + (#not-any-of? @text.environment.name + "displaymath" "displaymath*" + "equation" "equation*" + "multline" "multline*" + "eqnarray" "eqnarray*" + "align" "align*" + "array" "array*" + "split" "split*" + "alignat" "alignat*" + "gather" "gather*" + "flalign" "flalign*")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/latex/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/latex/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/latex/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/lean/folds.scm b/helix-22.03-x86_64-windows/runtime/queries/lean/folds.scm new file mode 100644 index 0000000..2c2bbb3 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/lean/folds.scm @@ -0,0 +1,15 @@ +[ + (namespace) + (section) + + (instance) + (def) + (theorem) + (example) + + (product) + (array) + (list) + + (string) +] @fold diff --git a/helix-22.03-x86_64-windows/runtime/queries/lean/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/lean/highlights.scm new file mode 100644 index 0000000..a64feb1 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/lean/highlights.scm @@ -0,0 +1,217 @@ +(open + namespace: (identifier) @namespace) +(namespace + name: (identifier) @namespace) +(section + name: (identifier) @namespace) + +;; Identifier naming conventions +((identifier) @type + (#match? @type "^[A-Z]")) + +(arrow) @type +(product) @type + +;; Declarations + +[ + "abbrev" + "def" + "theorem" + "constant" + "instance" + "axiom" + "example" + "inductive" + "structure" + "class" + + "deriving" + + "section" + "namespace" +] @keyword + +(attributes + (identifier) @function) + +(abbrev + name: (identifier) @type) +(def + name: (identifier) @function) +(theorem + name: (identifier) @function) +(constant + name: (identifier) @type) +(instance + name: (identifier) @function) +(instance + type: (identifier) @type) +(axiom + name: (identifier) @function) +(structure + name: (identifier) @type) +(structure + extends: (identifier) @type) + +(where_decl + type: (identifier) @type) + +(proj + name: (identifier) @field) + +(binders + type: (identifier) @type) + +["if" "then" "else"] @keyword.control.conditional + +["for" "in" "do"] @keyword.control.repeat + +(import) @include + +; Tokens + +[ + "!" + "$" + "%" + "&&" + "*" + "*>" + "+" + "++" + "-" + "/" + "::" + ":=" + "<" + "<$>" + "<*" + "<*>" + "<=" + "<|" + "<|>" + "=" + "==" + "=>" + ">" + ">" + ">=" + ">>" + ">>=" + "@" + "^" + "|>" + "|>." + "||" + "←" + "→" + "↔" + "∘" + "∧" + "∨" + "≠" + "≤" + "≥" +] @operator + +[ + "@&" +] @operator + +[ + "attribute" + "by" + "end" + "export" + "extends" + "fun" + "let" + "have" + "match" + "open" + "return" + "universe" + "variable" + "where" + "with" + "λ" + (hash_command) + (prelude) + (sorry) +] @keyword + +[ + "prefix" + "infix" + "infixl" + "infixr" + "postfix" + "notation" + "macro_rules" + "syntax" + "elab" + "builtin_initialize" +] @keyword + +[ + "noncomputable" + "partial" + "private" + "protected" + "unsafe" +] @keyword + +[ + "apply" + "exact" + "rewrite" + "rw" + "simp" + (trivial) +] @keyword + +[ + "catch" + "finally" + "try" +] @exception + +((apply + name: (identifier) @exception) + (#match? @exception "throw")) + +[ + "unless" + "mut" +] @keyword + +[(true) (false)] @boolean + +(number) @constant.numeric.integer +(float) @constant.numeric.float + +(comment) @comment +(char) @character +(string) @string +(interpolated_string) @string +; (escape_sequence) @string.escape + +; Reset highlighing in string interpolation +(interpolation) @none + +(interpolation + "{" @punctuation.special + "}" @punctuation.special) + +["(" ")" "[" "]" "{" "}" "⟨" "⟩"] @punctuation.bracket + +["|" "," "." ":" ";"] @punctuation.delimiter + +(sorry) @error + +;; Error +(ERROR) @error + +; Variables +(identifier) @variable diff --git a/helix-22.03-x86_64-windows/runtime/queries/lean/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/lean/injections.scm new file mode 100644 index 0000000..030714f --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/lean/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "markdown")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/lean/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/lean/locals.scm new file mode 100644 index 0000000..dd6c203 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/lean/locals.scm @@ -0,0 +1,5 @@ +[ + (module) + (namespace) + (section) +] @local.scope diff --git a/helix-22.03-x86_64-windows/runtime/queries/ledger/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/ledger/highlights.scm new file mode 100644 index 0000000..02a9ea9 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ledger/highlights.scm @@ -0,0 +1,38 @@ +[ + (comment) + (note) +] @comment + +[ + (date) + (interval) + (quantity) +] @constant.numeric.integer + +((account) @variable.other.member) +((commodity) @text.literal) + +"include" @keyword.local.import + +[ + "account" + "alias" + "assert" + "check" + "commodity" + "def" + "default" + "end" + "eval" + "format" + "nomarket" + "note" + "payee" + "check" + "A" + "Y" + "N" + "D" + "C" + "P" +] @keyword diff --git a/helix-22.03-x86_64-windows/runtime/queries/ledger/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/ledger/injections.scm new file mode 100644 index 0000000..c171478 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ledger/injections.scm @@ -0,0 +1,2 @@ +([(comment) (note)] @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/highlights.scm new file mode 100644 index 0000000..4ba254e --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/highlights.scm @@ -0,0 +1 @@ +; inherits: yaml diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/indents.toml new file mode 100644 index 0000000..ddc3578 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/indents.toml @@ -0,0 +1,3 @@ +indent = [ + "block_mapping_pair", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/injections.scm new file mode 100644 index 0000000..b324302 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir-yaml/injections.scm @@ -0,0 +1,9 @@ +; inherits: yaml + +((document (block_node (block_scalar) @injection.content)) + (#set! injection.language "llvm")) + +((document (block_node (block_mapping (block_mapping_pair + key: (flow_node (plain_scalar (string_scalar))) ; "body" + value: (block_node (block_scalar) @injection.content))))) + (#set! injection.language "mir")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/highlights.scm new file mode 100644 index 0000000..7923461 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/highlights.scm @@ -0,0 +1,136 @@ +[ + (label) + (bb_ref) +] @label + +[ + (comment) + (multiline_comment) +] @comment + +[ + "(" + ")" + "[" + "]" + "{" + "}" + "<" + ">" +] @punctuation.bracket + +[ + "," + ":" + "|" + "*" +] @punctuation.delimiter + +[ + "=" + "x" +] @operator + +[ + "true" + "false" +] @constant.builtin.boolean + +[ + "null" + "_" + "unknown-address" +] @constant.builtin + +[ + (stack_object) + (constant_pool_index) + (jump_table_index) + (var) + (physical_register) + (ir_block) + (external_symbol) + (global_var) + (ir_local_var) + (metadata_ref) + (mnemonic) +] @variable + +(low_level_type) @type + +[ + (immediate_type) + (primitive_type) +] @type.builtin + +(number) @constant.numeric.integer +(float) @constant.numeric.float +(string) @string + +(instruction name: _ @keyword.operator) + +[ + "successors" + "liveins" + "pre-instr-symbol" + "post-instr-symbol" + "heap-alloc-marker" + "debug-instr-number" + "debug-location" + "mcsymbol" + "tied-def" + "target-flags" + "CustomRegMask" + "same_value" + "def_cfa_register" + "restore" + "undefined" + "offset" + "rel_offset" + "def_cfa" + "llvm_def_aspace_cfa" + "register" + "escape" + "remember_state" + "restore_state" + "window_save" + "negate_ra_sign_state" + "intpred" + "floatpred" + "shufflemask" + "liveout" + "target-index" + "blockaddress" + "intrinsic" + "load" + "store" + "unknown-size" + "on" + "from" + "into" + "align" + "basealign" + "addrspace" + "call-entry" + "custom" + "constant-pool" + "stack" + "got" + "jump-table" + "syncscope" + "address-taken" + "landing-pad" + "inlineasm-br-indirect-target" + "ehfunclet-entry" + "bbsections" + + (intpred) + (floatpred) + (memory_operand_flag) + (atomic_ordering) + (register_flag) + (instruction_flag) + (float_keyword) +] @keyword + +(ERROR) @error diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/indents.toml new file mode 100644 index 0000000..6a70e5a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/indents.toml @@ -0,0 +1,7 @@ +indent = [ + "basic_block", +] + +outdent = [ + "label", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/injections.scm new file mode 100644 index 0000000..0b476f8 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/injections.scm @@ -0,0 +1,2 @@ +([ (comment) (multiline_comment)] @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/textobjects.scm new file mode 100644 index 0000000..003ce59 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm-mir/textobjects.scm @@ -0,0 +1,12 @@ +(basic_block) @function.around + +(argument) @parameter.inside + +[ + (comment) + (multiline_comment) +] @comment.inside + +(comment)+ @comment.around + +(multiline_comment) @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm/highlights.scm new file mode 100644 index 0000000..cb70519 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm/highlights.scm @@ -0,0 +1,158 @@ +(type) @type +(type_keyword) @type.builtin + +(type [ + (local_var) + (global_var) + ] @type) + +(argument) @variable.parameter + +(_ inst_name: _ @keyword.operator) + +[ + "catch" + "filter" +] @keyword.operator + +[ + "to" + "nuw" + "nsw" + "exact" + "unwind" + "from" + "cleanup" + "swifterror" + "volatile" + "inbounds" + "inrange" + (icmp_cond) + (fcmp_cond) + (fast_math) +] @keyword.control + +(_ callee: _ @function) +(function_header name: _ @function) + +[ + "declare" + "define" + (calling_conv) +] @keyword.function + +[ + "target" + "triple" + "datalayout" + "source_filename" + "addrspace" + "blockaddress" + "align" + "syncscope" + "within" + "uselistorder" + "uselistorder_bb" + "module" + "asm" + "sideeffect" + "alignstack" + "inteldialect" + "unwind" + "type" + "global" + "constant" + "externally_initialized" + "alias" + "ifunc" + "section" + "comdat" + "thread_local" + "localdynamic" + "initialexec" + "localexec" + "any" + "exactmatch" + "largest" + "nodeduplicate" + "samesize" + "distinct" + "attributes" + "vscale" + "no_cfi" + (linkage_aux) + (dso_local) + (visibility) + (dll_storage_class) + (unnamed_addr) + (attribute_name) +] @keyword + + +(function_header [ + (linkage) + (calling_conv) + (unnamed_addr) + ] @keyword.function) + +[ + (string) + (cstring) +] @string + +(number) @constant.numeric.integer +(comment) @comment +(label) @label +(_ inst_name: "ret" @keyword.control.return) +(float) @constant.numeric.float + +[ + (local_var) + (global_var) +] @variable + +[ + (struct_value) + (array_value) + (vector_value) +] @constructor + +[ + "(" + ")" + "[" + "]" + "{" + "}" + "<" + ">" + "<{" + "}>" +] @punctuation.bracket + +[ + "," + ":" +] @punctuation.delimiter + +[ + "=" + "|" + "x" + "..." +] @operator + +[ + "true" + "false" +] @constant.builtin.boolean + +[ + "undef" + "poison" + "null" + "none" + "zeroinitializer" +] @constant.builtin + +(ERROR) @error diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/llvm/indents.toml new file mode 100644 index 0000000..8cd603c --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm/indents.toml @@ -0,0 +1,8 @@ +indent = [ + "function_body", + "instruction", +] + +outdent = [ + "}", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm/locals.scm new file mode 100644 index 0000000..1946c28 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm/locals.scm @@ -0,0 +1,14 @@ +; Scopes + +(function_body) @local.scope + +; Definitions + +(argument + (value (var (local_var) @local.definition))) + +(instruction + (local_var) @local.definition) + +; References +(local_var) @local.reference diff --git a/helix-22.03-x86_64-windows/runtime/queries/llvm/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/llvm/textobjects.scm new file mode 100644 index 0000000..dd15dc1 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/llvm/textobjects.scm @@ -0,0 +1,20 @@ +(define + body: (_) @function.inside) @function.around + +(struct_type + (struct_body) @class.inside) @class.around + +(packed_struct_type + (struct_body) @class.inside) @class.around + +(array_type + (array_vector_body) @class.inside) @class.around + +(vector_type + (array_vector_body) @class.inside) @class.around + +(argument) @parameter.inside + +(comment) @comment.inside + +(comment)+ @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/lua/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/lua/highlights.scm new file mode 100644 index 0000000..e73b32d --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/lua/highlights.scm @@ -0,0 +1,166 @@ +;;; Highlighting for lua + +;;; Builtins +(self) @variable.builtin + +;; Keywords + +(if_statement +[ + "if" + "then" + "end" +] @keyword.control.conditional) + +[ + "else" + "elseif" + "then" +] @keyword.control.conditional + +(for_statement +[ + "for" + "do" + "end" +] @keyword.control.repeat) + +(for_in_statement +[ + "for" + "do" + "end" +] @keyword.control.repeat) + +(while_statement +[ + "while" + "do" + "end" +] @keyword.control.repeat) + +(repeat_statement +[ + "repeat" + "until" +] @keyword.control.repeat) + +(do_statement +[ + "do" + "end" +] @keyword) + +[ + "in" + "local" + (break_statement) + "goto" + "return" +] @keyword + +;; Operators + +[ + "not" + "and" + "or" +] @operator + +[ +"=" +"~=" +"==" +"<=" +">=" +"<" +">" +"+" +"-" +"%" +"/" +"//" +"*" +"^" +"&" +"~" +"|" +">>" +"<<" +".." +"#" + ] @operator + +;; Punctuation +["," "." ":" ";"] @punctuation.delimiter + +;; Brackets +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +; ;; Constants +[ +(false) +(true) +] @constant.builtin.boolean +(nil) @constant.builtin +(spread) @constant ;; "..." +((identifier) @constant + (#match? @constant "^[A-Z][A-Z_0-9]*$")) + +;; Parameters +(parameters + (identifier) @variable.parameter) + +; ;; Functions +(function [(function_name) (identifier)] @function) +(function ["function" "end"] @keyword.function) + +(function + (function_name + (function_name_field + (property_identifier) @function .))) + +(local_function (identifier) @function) +(local_function ["function" "end"] @keyword.function) + +(variable_declaration + (variable_declarator (identifier) @function) (function_definition)) +(local_variable_declaration + (variable_declarator (identifier) @function) (function_definition)) + +(function_definition ["function" "end"] @keyword.function) + +(function_call + [ + ((identifier) @variable (method) @function.method) + ((_) (method) @function.method) + (identifier) @function + (field_expression (property_identifier) @function) + ] + . (arguments)) + +;; Nodes +(table ["{" "}"] @constructor) +(comment) @comment +(string) @string +(number) @constant.numeric.integer +(label_statement) @label +; A bit of a tricky one, this will only match field names +(field . (identifier) @variable.other.member (_)) +(shebang) @comment + +;; Property +(property_identifier) @variable.other.member + +;; Variable +(identifier) @variable + +;; Error +(ERROR) @error diff --git a/helix-22.03-x86_64-windows/runtime/queries/lua/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/lua/indents.toml new file mode 100644 index 0000000..df1a975 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/lua/indents.toml @@ -0,0 +1,24 @@ +indent = [ + "function_definition", + "variable_declaration", + "local_variable_declaration", + "field", + "local_function", + "function", + "if_statement", + "for_statement", + "for_in_statement", + "repeat_statement", + "return_statement", + "while_statement", + "table", + "arguments", + "do_statement", +] + +oudent = [ + "end", + "until", + "}", + ")", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/lua/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/lua/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/lua/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/make/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/make/highlights.scm new file mode 100644 index 0000000..50380ba --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/make/highlights.scm @@ -0,0 +1,170 @@ +[ + "(" + ")" + "{" + "}" +] @punctuation.bracket + +[ + ":" + "&:" + "::" + "|" + ";" + "\"" + "'" + "," +] @punctuation.delimiter + +[ + "$" + "$$" +] @punctuation.special + +(automatic_variable + [ "@" "%" "<" "?" "^" "+" "/" "*" "D" "F"] @punctuation.special) + +(automatic_variable + "/" @error . ["D" "F"]) + +[ + "=" + ":=" + "::=" + "?=" + "+=" + "!=" + "@" + "-" + "+" +] @operator + +[ + (text) + (string) + (raw_text) +] @string + +(variable_assignment (word) @string) + +[ + "ifeq" + "ifneq" + "ifdef" + "ifndef" + "else" + "endif" + "if" + "or" ; boolean functions are conditional in make grammar + "and" +] @keyword.control.conditional + +"foreach" @keyword.control.repeat + +[ + "define" + "endef" + "vpath" + "undefine" + "export" + "unexport" + "override" + "private" +; "load" +] @keyword + +[ + "include" + "sinclude" + "-include" +] @keyword.control.import + +[ + "subst" + "patsubst" + "strip" + "findstring" + "filter" + "filter-out" + "sort" + "word" + "words" + "wordlist" + "firstword" + "lastword" + "dir" + "notdir" + "suffix" + "basename" + "addsuffix" + "addprefix" + "join" + "wildcard" + "realpath" + "abspath" + "call" + "eval" + "file" + "value" + "shell" +] @keyword.function + +[ + "error" + "warning" + "info" +] @keyword.control.exception + +;; Variable +(variable_assignment + name: (word) @variable) + +(variable_reference + (word) @variable) + +(comment) @comment + +((word) @clean @string.regexp + (#match? @clean "[%\*\?]")) + +(function_call + function: "error" + (arguments (text) @error)) + +(function_call + function: "warning" + (arguments (text) @warning)) + +(function_call + function: "info" + (arguments (text) @info)) + +;; Install Command Categories +;; Others special variables +;; Variables Used by Implicit Rules +[ + "VPATH" + ".RECIPEPREFIX" +] @constant.builtin + +(variable_assignment + name: (word) @clean @constant.builtin + (#match? @clean "^(AR|AS|CC|CXX|CPP|FC|M2C|PC|CO|GET|LEX|YACC|LINT|MAKEINFO|TEX|TEXI2DVI|WEAVE|CWEAVE|TANGLE|CTANGLE|RM|ARFLAGS|ASFLAGS|CFLAGS|CXXFLAGS|COFLAGS|CPPFLAGS|FFLAGS|GFLAGS|LDFLAGS|LDLIBS|LFLAGS|YFLAGS|PFLAGS|RFLAGS|LINTFLAGS|PRE_INSTALL|POST_INSTALL|NORMAL_INSTALL|PRE_UNINSTALL|POST_UNINSTALL|NORMAL_UNINSTALL|MAKEFILE_LIST|MAKE_RESTARTS|MAKE_TERMOUT|MAKE_TERMERR|\.DEFAULT_GOAL|\.RECIPEPREFIX|\.EXTRA_PREREQS)$")) + +(variable_reference + (word) @clean @constant.builtin + (#match? @clean "^(AR|AS|CC|CXX|CPP|FC|M2C|PC|CO|GET|LEX|YACC|LINT|MAKEINFO|TEX|TEXI2DVI|WEAVE|CWEAVE|TANGLE|CTANGLE|RM|ARFLAGS|ASFLAGS|CFLAGS|CXXFLAGS|COFLAGS|CPPFLAGS|FFLAGS|GFLAGS|LDFLAGS|LDLIBS|LFLAGS|YFLAGS|PFLAGS|RFLAGS|LINTFLAGS|PRE_INSTALL|POST_INSTALL|NORMAL_INSTALL|PRE_UNINSTALL|POST_UNINSTALL|NORMAL_UNINSTALL|MAKEFILE_LIST|MAKE_RESTARTS|MAKE_TERMOUT|MAKE_TERMERR|\.DEFAULT_GOAL|\.RECIPEPREFIX|\.EXTRA_PREREQS\.VARIABLES|\.FEATURES|\.INCLUDE_DIRS|\.LOADED)$")) + +;; Standart targets +(targets + (word) @constant.macro + (#match? @constant.macro "^(all|install|install-html|install-dvi|install-pdf|install-ps|uninstall|install-strip|clean|distclean|mostlyclean|maintainer-clean|TAGS|info|dvi|html|pdf|ps|dist|check|installcheck|installdirs)$")) + +(targets + (word) @constant.macro + (#match? @constant.macro "^(all|install|install-html|install-dvi|install-pdf|install-ps|uninstall|install-strip|clean|distclean|mostlyclean|maintainer-clean|TAGS|info|dvi|html|pdf|ps|dist|check|installcheck|installdirs)$")) + +;; Builtin targets +(targets + (word) @constant.macro + (#match? @constant.macro "^\.(PHONY|SUFFIXES|DEFAULT|PRECIOUS|INTERMEDIATE|SECONDARY|SECONDEXPANSION|DELETE_ON_ERROR|IGNORE|LOW_RESOLUTION_TIME|SILENT|EXPORT_ALL_VARIABLES|NOTPARALLEL|ONESHELL|POSIX)$")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/make/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/make/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/make/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/markdown/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/markdown/highlights.scm new file mode 100644 index 0000000..ed22b80 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/markdown/highlights.scm @@ -0,0 +1,46 @@ +(setext_heading (heading_content) @markup.heading.1 (setext_h1_underline) @markup.heading.marker) +(setext_heading (heading_content) @markup.heading.2 (setext_h2_underline) @markup.heading.marker) + +(atx_heading (atx_h1_marker) @markup.heading.marker (heading_content) @markup.heading.1) +(atx_heading (atx_h2_marker) @markup.heading.marker (heading_content) @markup.heading.2) +(atx_heading (atx_h3_marker) @markup.heading.marker (heading_content) @markup.heading.3) +(atx_heading (atx_h4_marker) @markup.heading.marker (heading_content) @markup.heading.4) +(atx_heading (atx_h5_marker) @markup.heading.marker (heading_content) @markup.heading.5) +(atx_heading (atx_h6_marker) @markup.heading.marker (heading_content) @markup.heading.6) + +(code_fence_content) @none + +[ + (indented_code_block) + (fenced_code_block) +] @markup.raw.block + +(block_quote) @markup.quote + +(code_span) @markup.raw.inline + +(emphasis) @markup.italic + +(strong_emphasis) @markup.bold + +(link_destination) @markup.link.url +(link_label) @markup.link.label + +[ + (link_text) + (image_description) +] @markup.link.text + +[ + (list_marker_plus) + (list_marker_minus) + (list_marker_star) + (list_marker_dot) + (list_marker_parenthesis) +] @punctuation.special + +[ + (backslash_escape) + (hard_line_break) +] @string.character.escape + diff --git a/helix-22.03-x86_64-windows/runtime/queries/markdown/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/markdown/injections.scm new file mode 100644 index 0000000..10dcab0 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/markdown/injections.scm @@ -0,0 +1,9 @@ +(fenced_code_block + (info_string) @injection.language + (code_fence_content) @injection.content + (#set! injection.include-children)) + +((html_block) @injection.content + (#set! injection.language "html")) +((html_tag) @injection.content + (#set! injection.language "html")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/nix/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/nix/highlights.scm new file mode 100644 index 0000000..f668206 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/nix/highlights.scm @@ -0,0 +1,90 @@ +(comment) @comment + +[ + "if" + "then" + "else" + "let" + "inherit" + "in" + "rec" + "with" + "assert" +] @keyword + +((identifier) @variable.builtin + (#match? @variable.builtin "^(__currentSystem|__currentTime|__nixPath|__nixVersion|__storeDir|builtins)$") + (#is-not? local)) + +((identifier) @function.builtin + (#match? @function.builtin "^(__add|__addErrorContext|__all|__any|__appendContext|__attrNames|__attrValues|__bitAnd|__bitOr|__bitXor|__catAttrs|__compareVersions|__concatLists|__concatMap|__concatStringsSep|__deepSeq|__div|__elem|__elemAt|__fetchurl|__filter|__filterSource|__findFile|__foldl'|__fromJSON|__functionArgs|__genList|__genericClosure|__getAttr|__getContext|__getEnv|__hasAttr|__hasContext|__hashFile|__hashString|__head|__intersectAttrs|__isAttrs|__isBool|__isFloat|__isFunction|__isInt|__isList|__isPath|__isString|__langVersion|__length|__lessThan|__listToAttrs|__mapAttrs|__match|__mul|__parseDrvName|__partition|__path|__pathExists|__readDir|__readFile|__replaceStrings|__seq|__sort|__split|__splitVersion|__storePath|__stringLength|__sub|__substring|__tail|__toFile|__toJSON|__toPath|__toXML|__trace|__tryEval|__typeOf|__unsafeDiscardOutputDependency|__unsafeDiscardStringContext|__unsafeGetAttrPos|__valueSize|abort|baseNameOf|derivation|derivationStrict|dirOf|fetchGit|fetchMercurial|fetchTarball|fromTOML|import|isNull|map|placeholder|removeAttrs|scopedImport|throw|toString)$") + (#is-not? local)) + +[ + (string) + (indented_string) +] @string + +[ + (path) + (hpath) + (spath) +] @string.special.path + +(uri) @string.special.uri + +; boolean +((identifier) @constant.builtin.boolean (#match? @constant.builtin.boolean "^(true|false)$")) @constant.builtin.boolean +; null +((identifier) @constant.builtin (#eq? @constant.builtin "null")) @constant.builtin + +(integer) @constant.numeric.integer +(float) @constant.numeric.float + +(interpolation + "${" @punctuation.special + "}" @punctuation.special) @embedded + +(escape_sequence) @constant.character.escape + +(function + universal: (identifier) @variable.parameter +) + +(formal + name: (identifier) @variable.parameter + "?"? @punctuation.delimiter) + +(app + function: [ + (identifier) @function + (select + attrpath: (attrpath + attr: (attr_identifier) @function .))]) + + +(unary + operator: _ @operator) + +(binary + operator: _ @operator) + +(attr_identifier) @variable.other.member +(inherit attrs: (attrs_inherited (identifier) @variable.other.member) ) + +[ + ";" + "." + "," +] @punctuation.delimiter + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +(identifier) @variable diff --git a/helix-22.03-x86_64-windows/runtime/queries/nix/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/nix/indents.toml new file mode 100644 index 0000000..b92ab75 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/nix/indents.toml @@ -0,0 +1,18 @@ +indent = [ + # "function", + "bind", + "assert", + "with", + "let", + "if", + + "attrset", + "list", + "indented_string", + "parenthesized", +] + +outdent = [ + "}", + "]", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/ocaml-interface/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/ocaml-interface/highlights.scm new file mode 100644 index 0000000..6d3dfbc --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ocaml-interface/highlights.scm @@ -0,0 +1 @@ +; inherits: ocaml diff --git a/helix-22.03-x86_64-windows/runtime/queries/ocaml-interface/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/ocaml-interface/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ocaml-interface/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/ocaml/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/ocaml/highlights.scm new file mode 100644 index 0000000..a08b126 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ocaml/highlights.scm @@ -0,0 +1,160 @@ +; Modules +;-------- + +[(module_name) (module_type_name)] @namespace + +; Types +;------ + +[(class_name) (class_type_name) (type_constructor)] @type + +[(constructor_name) (tag)] @constructor + +; Functions +;---------- + +(let_binding + pattern: (value_name) @function + (parameter)) + +(let_binding + pattern: (value_name) @function + body: [(fun_expression) (function_expression)]) + +(value_specification (value_name) @function) + +(external (value_name) @function) + +(method_name) @function.method + +; Variables +;---------- + +(value_pattern) @variable.parameter + +; Application +;------------ + +(infix_expression + left: (value_path (value_name) @function) + (infix_operator) @operator + (#eq? @operator "@@")) + +(infix_expression + (infix_operator) @operator + right: (value_path (value_name) @function) + (#eq? @operator "|>")) + +(application_expression + function: (value_path (value_name) @function)) + +; Properties +;----------- + +[(label_name) (field_name) (instance_variable_name)] @variable.other.member + +; Constants +;---------- + +[(boolean) (unit)] @constant + +[(number) (signed_number)] @constant.numeric.integer + +(character) @constant.character + +(string) @string + +(quoted_string "{" @string "}" @string) @string + +(escape_sequence) @constant.character.escape + +[ + (conversion_specification) + (pretty_printing_indication) +] @punctuation.special + +; Keywords +;--------- + +[ + "and" "as" "assert" "begin" "class" "constraint" + "end" "external" "in" + "inherit" "initializer" "lazy" "let" "match" "method" "module" + "mutable" "new" "nonrec" "object" "of" "private" "rec" "sig" "struct" + "type" "val" "virtual" "when" "with" +] @keyword + +["fun" "function" "functor"] @keyword.function + +["if" "then" "else"] @keyword.control.conditional + +["exception" "try"] @keyword.control.exception + +["include" "open"] @keyword.control.import + +["for" "to" "downto" "while" "do" "done"] @keyword.control.repeat + +; Macros +;------- + +(attribute ["[@" "]"] @attribute) +(item_attribute ["[@@" "]"] @attribute) +(floating_attribute ["[@@@" "]"] @attribute) +(extension ["[%" "]"] @function.macro) +(item_extension ["[%%" "]"] @function.macro) +(quoted_extension ["{%" "}"] @function.macro) +(quoted_item_extension ["{%%" "}"] @function.macro) +"%" @function.macro + +["(" ")" "[" "]" "{" "}" "[|" "|]" "[<" "[>"] @punctuation.bracket + +(object_type ["<" ">"] @punctuation.bracket) + +[ + "," "." ";" ":" "=" "|" "~" "?" "+" "-" "!" ">" "&" + "->" ";;" ":>" "+=" ":=" ".." +] @punctuation.delimiter + +; Operators +;---------- + +[ + (prefix_operator) + (sign_operator) + (infix_operator) + (hash_operator) + (indexing_operator) + (let_operator) + (and_operator) + (match_operator) +] @operator + +(match_expression (match_operator) @keyword) + +(value_definition [(let_operator) (and_operator)] @keyword) + +;; TODO: this is an error now +;(prefix_operator "!" @operator) + +(infix_operator ["&" "+" "-" "=" ">" "|" "%"] @operator) + +(signed_number ["+" "-"] @operator) + +["*" "#" "::" "<-"] @operator + +; Attributes +;----------- + +(attribute_id) @variable.other.member + +; Comments +;--------- + +[(comment) (line_number_directive) (directive) (shebang)] @comment + +(ERROR) @error + +; Blanket highlights +; ------------------ + +[(value_name) (type_variable)] @variable diff --git a/helix-22.03-x86_64-windows/runtime/queries/ocaml/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/ocaml/indents.toml new file mode 100644 index 0000000..7586b83 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ocaml/indents.toml @@ -0,0 +1,13 @@ +indent = [ + "let_binding", + "type_binding", + "structure", + "signature", + "record_declaration", + "function_expression", + "match_case", +] + +outdent = [ + "}", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/ocaml/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/ocaml/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ocaml/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/ocaml/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/ocaml/locals.scm new file mode 100644 index 0000000..8f3f3fd --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ocaml/locals.scm @@ -0,0 +1,24 @@ +; Scopes +;------- + +[ + (let_binding) + (class_binding) + (class_function) + (method_definition) + (fun_expression) + (object_expression) + (for_expression) + (match_case) + (attribute_payload) +] @local.scope + +; Definitions +;------------ + +(value_pattern) @local.definition + +; References +;----------- + +(value_path . (value_name) @local.reference) diff --git a/helix-22.03-x86_64-windows/runtime/queries/org/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/org/highlights.scm new file mode 100644 index 0000000..db8329f --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/org/highlights.scm @@ -0,0 +1,24 @@ +(headline (stars) @markup.heading.marker (#eq? @markup.heading.marker "*")) @markup.heading.1 +(headline (stars) @markup.heading.marker (#eq? @markup.heading.marker "**")) @markup.heading.2 +(headline (stars) @markup.heading.marker (#eq? @markup.heading.marker "***")) @markup.heading.3 +(headline (stars) @markup.heading.marker (#eq? @markup.heading.marker "****")) @markup.heading.4 +(headline (stars) @markup.heading.marker (#eq? @markup.heading.marker "*****")) @markup.heading.5 +(headline (stars) @markup.heading.marker (#eq? @markup.heading.marker "******")) @markup.heading.6 + +(block) @markup.raw.block +(list) @markup.list.unnumbered +(directive) @markup.label +(property_drawer) @markup.label + + +((expr) @markup.bold + (#match? @markup.bold "\\*.*\\*")) + +((expr) @markup.italic + (#match? @markup.italic "/.*/")) +((expr) @markup.raw.inline + (#match? @markup.raw.inline "~.*~")) + +((expr) @markup.quote + (#match? @markup.quote "=.*=")) + diff --git a/helix-22.03-x86_64-windows/runtime/queries/org/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/org/injections.scm new file mode 100644 index 0000000..24d712d --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/org/injections.scm @@ -0,0 +1,4 @@ +(block parameter: (expr) @injection.language + (contents) @injection.content + (#set! injection.include-children)) + diff --git a/helix-22.03-x86_64-windows/runtime/queries/perl/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/perl/highlights.scm new file mode 100644 index 0000000..b6f0429 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/perl/highlights.scm @@ -0,0 +1,181 @@ +; Variables +(variable_declaration + . + (scope) @keyword) +[ +(single_var_declaration) +(scalar_variable) +(array_variable) +(hash_variable) +(hash_variable) +] @variable + + +[ +(package_name) +(special_scalar_variable) +(special_array_variable) +(special_hash_variable) +(special_literal) +(super) +] @constant + +( + [ + (package_name) + (super) + ] + . + ("::" @operator) +) + +(comments) @comment +(pod_statement) @comment.block.documentation + +[ +(use_no_statement) +(use_no_feature_statement) +(use_no_if_statement) +(use_no_version) +(use_constant_statement) +(use_parent_statement) +] @keyword + +(use_constant_statement + constant: (identifier) @constant) + +[ +"require" +] @keyword + +(method_invocation + . + (identifier) @variable) + +(method_invocation + (arrow_operator) + . + (identifier) @function) +(method_invocation + function_name: (identifier) @function) +(named_block_statement + function_name: (identifier) @function) + +(call_expression + function_name: (identifier) @function) +(function_definition + name: (identifier) @function) +[ +(function) +(map) +(grep) +(bless) +] @function + +[ +"return" +"sub" +"package" +"BEGIN" +"END" +] @keyword.function + +[ +"(" +")" +"[" +"]" +"{" +"}" +] @punctuation.bracket +(standard_input_to_variable) @punctuation.bracket + +[ +"=~" +"or" +"=" +"==" +"+" +"-" +"." +"//" +"||" +(arrow_operator) +(hash_arrow_operator) +(array_dereference) +(hash_dereference) +(to_reference) +(type_glob) +(hash_access_variable) +(ternary_expression) +(ternary_expression_in_hash) +] @operator + +[ +(regex_option) +(regex_option_for_substitution) +(regex_option_for_transliteration) +] @variable.parameter + +(type_glob + (identifier) @variable) +( + (scalar_variable) + . + ("->" @operator)) + +[ +(word_list_qw) +(command_qx_quoted) +(string_single_quoted) +(string_double_quoted) +(string_qq_quoted) +(bareword) +(transliteration_tr_or_y) +] @string + +[ +(regex_pattern_qr) +(patter_matcher_m) +(substitution_pattern_s) +] @string.regexp + +(escape_sequence) @string.special + +[ +"," +(semi_colon) +(start_delimiter) +(end_delimiter) +(ellipsis_statement) +] @punctuation.delimiter + +[ +(integer) +(floating_point) +(scientific_notation) +(hexadecimal) +] @constant.numeric + +[ +; (if_statement) +(unless_statement) +(if_simple_statement) +(unless_simple_statement) +] @keyword.control.conditional + +[ +"if" +"elsif" +"else" +] @keyword.control.conditional + +(foreach_statement) @keyword.control.repeat +(foreach_statement + . + (scope) @keyword) + +(function_attribute) @label + +(function_signature) @type + diff --git a/helix-22.03-x86_64-windows/runtime/queries/perl/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/perl/indents.toml new file mode 100644 index 0000000..365e066 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/perl/indents.toml @@ -0,0 +1,17 @@ +indent = [ + "function", + "identifier", + "method_invocation", + "if_statement", + "unless_statement", + "if_simple_statement", + "unless_simple_statement", + "variable_declaration", + "block", + "list_item", + "word_list_qw" +] + +outdent = [ + "}" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/perl/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/perl/injections.scm new file mode 100644 index 0000000..cab5f53 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/perl/injections.scm @@ -0,0 +1,2 @@ +((comments) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/perl/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/perl/textobjects.scm new file mode 100644 index 0000000..972b877 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/perl/textobjects.scm @@ -0,0 +1,17 @@ +(function_definition + (identifier) (_) @function.inside) @function.around + +(anonymous_function + (_) @function.inside) @function.around + +(argument + (_) @parameter.inside) + +[ + (comments) + (pod_statement) +] @comment.inside + +(comments)+ @comment.around + +(pod_statement) @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/php/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/php/highlights.scm new file mode 100644 index 0000000..5379fa1 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/php/highlights.scm @@ -0,0 +1,118 @@ +(php_tag) @tag +"?>" @tag + +; Types + +(primitive_type) @type.builtin +(cast_type) @type.builtin +(named_type (name) @type) @type +(named_type (qualified_name) @type) @type + +; Functions + +(array_creation_expression "array" @function.builtin) +(list_literal "list" @function.builtin) + +(method_declaration + name: (name) @function.method) + +(function_call_expression + function: (qualified_name (name)) @function) + +(scoped_call_expression + name: (name) @function) + +(member_call_expression + name: (name) @function.method) + +(function_definition + name: (name) @function) + +; Member + +(property_element + (variable_name) @variable.other.member) + +(member_access_expression + name: (variable_name (name)) @variable.other.member) +(member_access_expression + name: (name) @variable.other.member) + +; Variables + +(relative_scope) @variable.builtin + +((name) @constant + (#match? @constant "^_?[A-Z][A-Z\\d_]+$")) + +((name) @constructor + (#match? @constructor "^[A-Z]")) + +((name) @variable.builtin + (#eq? @variable.builtin "this")) + +(variable_name) @variable + +; Basic tokens + +(string) @string +(heredoc) @string +(boolean) @constant.builtin.boolean +(null) @constant.builtin +(integer) @constant.numeric.integer +(float) @constant.numeric.float +(comment) @comment + +"$" @operator + +; Keywords + +"abstract" @keyword +"as" @keyword +"break" @keyword +"case" @keyword +"catch" @keyword +"class" @keyword +"const" @keyword +"continue" @keyword +"declare" @keyword +"default" @keyword +"do" @keyword +"echo" @keyword +"else" @keyword +"elseif" @keyword +"enddeclare" @keyword +"endforeach" @keyword +"endif" @keyword +"endswitch" @keyword +"endwhile" @keyword +"enum" @keyword +"extends" @keyword +"final" @keyword +"finally" @keyword +"foreach" @keyword +"fn" @keyword +"function" @keyword +"global" @keyword +"if" @keyword +"implements" @keyword +"include_once" @keyword +"include" @keyword +"insteadof" @keyword +"interface" @keyword +"match" @keyword +"namespace" @keyword +"new" @keyword +"private" @keyword +"protected" @keyword +"public" @keyword +"require_once" @keyword +"require" @keyword +"return" @keyword +"static" @keyword +"switch" @keyword +"throw" @keyword +"trait" @keyword +"try" @keyword +"use" @keyword +"while" @keyword diff --git a/helix-22.03-x86_64-windows/runtime/queries/php/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/php/indents.toml new file mode 100644 index 0000000..85c104d --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/php/indents.toml @@ -0,0 +1,17 @@ +indent = [ + "array_creation_expression", + "arguments", + "formal_parameters", + "compound_statement", + "declaration_list", + "binary_expression", + "return_statement", + "expression_statement", + "switch_block", + "anonymous_function_use_clause", +] + +oudent = [ + "}", + ")", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/php/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/php/injections.scm new file mode 100644 index 0000000..614a385 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/php/injections.scm @@ -0,0 +1,6 @@ +((text) @injection.content + (#set! injection.language "html") + (#set! injection.combined)) + +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/php/tags.scm b/helix-22.03-x86_64-windows/runtime/queries/php/tags.scm new file mode 100644 index 0000000..ef889ce --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/php/tags.scm @@ -0,0 +1,26 @@ +(class_declaration + name: (name) @name) @definition.class + +(function_definition + name: (name) @name) @definition.function + +(method_declaration + name: (name) @name) @definition.function + +(object_creation_expression + [ + (qualified_name (name) @name) + (variable_name (name) @name) + ]) @reference.class + +(function_call_expression + function: [ + (qualified_name (name) @name) + (variable_name (name)) @name + ]) @reference.call + +(scoped_call_expression + name: (name) @name) @reference.call + +(member_call_expression + name: (name) @name) @reference.call diff --git a/helix-22.03-x86_64-windows/runtime/queries/php/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/php/textobjects.scm new file mode 100644 index 0000000..51abe5c --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/php/textobjects.scm @@ -0,0 +1,34 @@ +(class_declaration + body: (_) @class.inside) @class.around + +(interface_declaration + body: (_) @class.inside) @class.around + +(trait_declaration + body: (_) @class.inside) @class.around + +(enum_declaration + body: (_) @class.inside) @class.around + +(function_definition + body: (_) @function.inside) @function.around + +(method_declaration + body: (_) @function.inside) @function.around + +(arrow_function + body: (_) @function.inside) @function.around + +(anonymous_function_creation_expression + body: (_) @function.inside) @function.around + +(formal_parameters + [ + (simple_parameter) + (variadic_parameter) + (property_promotion_parameter) + ] @parameter.inside) + +(comment) @comment.inside + +(comment)+ @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/protobuf/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/protobuf/highlights.scm new file mode 100644 index 0000000..c35c430 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/protobuf/highlights.scm @@ -0,0 +1,58 @@ +[ + "syntax" + "package" + "option" + "import" + "service" + "rpc" + "returns" + "message" + "enum" + "oneof" + "repeated" + "reserved" + "to" + "stream" + "extend" + "optional" +] @keyword + +[ + (keyType) + (type) +] @type.builtin + +[ + (mapName) + (enumName) + (messageName) + (extendName) + (serviceName) + (rpcName) +] @type + +[ + (fieldName) + (optionName) +] @variable.other.member +(enumVariantName) @type.enum.variant + +(fullIdent) @namespace + +(intLit) @constant.numeric.integer +(floatLit) @constant.numeric.float +(boolLit) @constant.builtin.boolean +(strLit) @string + +(constant) @constant + +(comment) @comment + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket \ No newline at end of file diff --git a/helix-22.03-x86_64-windows/runtime/queries/protobuf/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/protobuf/indents.toml new file mode 100644 index 0000000..e655f8d --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/protobuf/indents.toml @@ -0,0 +1,12 @@ +indent = [ + "messageBody", + "enumBody", + "oneofBody", + "serviceBody", + "rpcBody", + "msgLit", +] + +outdent = [ + "}", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/protobuf/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/protobuf/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/protobuf/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/python/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/python/highlights.scm new file mode 100644 index 0000000..9131acc --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/python/highlights.scm @@ -0,0 +1,121 @@ +; Identifier naming conventions + +((identifier) @constructor + (#match? @constructor "^[A-Z]")) + +((identifier) @constant + (#match? @constant "^[A-Z][A-Z_]*$")) + +; Builtin functions + +((call + function: (identifier) @function.builtin) + (#match? + @function.builtin + "^(abs|all|any|ascii|bin|bool|breakpoint|bytearray|bytes|callable|chr|classmethod|compile|complex|delattr|dict|dir|divmod|enumerate|eval|exec|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|isinstance|issubclass|iter|len|list|locals|map|max|memoryview|min|next|object|oct|open|ord|pow|print|property|range|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|vars|zip|__import__)$")) + +; Function calls + +(decorator) @function + +(call + function: (attribute attribute: (identifier) @function.method)) +(call + function: (identifier) @function) + +; Function definitions + +(function_definition + name: (identifier) @function) + +(identifier) @variable +(attribute attribute: (identifier) @variable.other.member) +(type (identifier) @type) + +; Literals + +[ + (none) + (true) + (false) +] @constant.builtin + +(integer) @constant.numeric.integer +(float) @constant.numeric.float +(comment) @comment +(string) @string +(escape_sequence) @constant.character.escape + +(interpolation + "{" @punctuation.special + "}" @punctuation.special) @embedded + +[ + "-" + "-=" + "!=" + "*" + "**" + "**=" + "*=" + "/" + "//" + "//=" + "/=" + "&" + "%" + "%=" + "^" + "+" + "->" + "+=" + "<" + "<<" + "<=" + "<>" + "=" + ":=" + "==" + ">" + ">=" + ">>" + "|" + "~" + "and" + "in" + "is" + "not" + "or" +] @operator + +[ + "as" + "assert" + "async" + "await" + "break" + "class" + "continue" + "def" + "del" + "elif" + "else" + "except" + "exec" + "finally" + "for" + "from" + "global" + "if" + "import" + "lambda" + "nonlocal" + "pass" + "print" + "raise" + "return" + "try" + "while" + "with" + "yield" +] @keyword diff --git a/helix-22.03-x86_64-windows/runtime/queries/python/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/python/indents.toml new file mode 100644 index 0000000..6bc6848 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/python/indents.toml @@ -0,0 +1,39 @@ +indent = [ + "list", + "tuple", + "dictionary", + "set", + + "if_statement", + "for_statement", + "while_statement", + "with_statement", + "try_statement", + "import_from_statement", + + "parenthesized_expression", + "generator_expression", + "list_comprehension", + "set_comprehension", + "dictionary_comprehension", + + "tuple_pattern", + "list_pattern", + "argument_list", + "parameters", + "binary_operator", + + "function_definition", + "class_definition", +] + +outdent = [ + ")", + "]", + "}", + "return_statement", + "pass_statement", + "raise_statement", +] + +ignore = ["string"] diff --git a/helix-22.03-x86_64-windows/runtime/queries/python/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/python/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/python/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/python/tags.scm b/helix-22.03-x86_64-windows/runtime/queries/python/tags.scm new file mode 100644 index 0000000..c5ca827 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/python/tags.scm @@ -0,0 +1,12 @@ +(class_definition + name: (identifier) @name) @definition.class + +(function_definition + name: (identifier) @name) @definition.function + +(call + function: [ + (identifier) @name + (attribute + attribute: (identifier) @name) + ]) @reference.call diff --git a/helix-22.03-x86_64-windows/runtime/queries/python/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/python/textobjects.scm new file mode 100644 index 0000000..0ca2608 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/python/textobjects.scm @@ -0,0 +1,18 @@ +(function_definition + body: (block)? @function.inside) @function.around + +(class_definition + body: (block)? @class.inside) @class.around + +(parameters + (_) @parameter.inside) + +(lambda_parameters + (_) @parameter.inside) + +(argument_list + (_) @parameter.inside) + +(comment) @comment.inside + +(comment)+ @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/regex/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/regex/highlights.scm new file mode 100644 index 0000000..9376caa --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/regex/highlights.scm @@ -0,0 +1,53 @@ +; upstream: https://github.com/tree-sitter/tree-sitter-regex/blob/e1cfca3c79896ff79842f057ea13e529b66af636/queries/highlights.scm + +[ + "(" + ")" + "(?" + "(?:" + "(?<" + ">" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +[ + "*" + "+" + "|" + "=" + "<=" + "!" + "" + ">=" + "&&" + "||" + "=" + ":=" + "->" + "|>" + ":>" + (uncurry) +] @operator + +[ + "(" + ")" + "{" + "}" + "[" + "]" +] @punctuation.bracket + +(polyvar_type + [ + "[" + "[>" + "[<" + "]" + ] @punctuation.bracket) + +[ + "~" + "?" + "=>" + "..." +] @punctuation + +(ternary_expression ["?" ":"] @operator) diff --git a/helix-22.03-x86_64-windows/runtime/queries/rescript/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/rescript/injections.scm new file mode 100644 index 0000000..201cce7 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/rescript/injections.scm @@ -0,0 +1,8 @@ +((comment) @injection.content + (#set! injection.language "comment")) + +((raw_js) @injection.content + (#set! injection.language "javascript")) + +((raw_gql) @injection.content + (#set! injection.language "graphql")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/rescript/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/rescript/textobjects.scm new file mode 100644 index 0000000..fa1c4ff --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/rescript/textobjects.scm @@ -0,0 +1,16 @@ +; Classes (modules) +;------------------ + +(module_declaration definition: ((_) @class.inside)) @class.around + +; Functions +;---------- + +(function body: (_) @function.inside) @function.around + +; Comments +;--------- + +(comment) @comment.inside + +(comment)+ @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/ruby/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/ruby/highlights.scm new file mode 100644 index 0000000..898f8f7 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ruby/highlights.scm @@ -0,0 +1,146 @@ +; Keywords + +[ + "alias" + "and" + "begin" + "break" + "case" + "class" + "def" + "do" + "else" + "elsif" + "end" + "ensure" + "for" + "if" + "in" + "module" + "next" + "or" + "rescue" + "retry" + "return" + "then" + "unless" + "until" + "when" + "while" + "yield" +] @keyword + +((identifier) @keyword + (#match? @keyword "^(private|protected|public)$")) + +; Function calls + +((identifier) @function.method.builtin + (#eq? @function.method.builtin "require")) + +"defined?" @function.method.builtin + +(call + method: [(identifier) (constant)] @function.method) + +; Function definitions + +(alias (identifier) @function.method) +(setter (identifier) @function.method) +(method name: [(identifier) (constant)] @function.method) +(singleton_method name: [(identifier) (constant)] @function.method) + +; Identifiers + +[ + (class_variable) + (instance_variable) +] @variable.other.member + +((identifier) @constant.builtin + (#match? @constant.builtin "^__(FILE|LINE|ENCODING)__$")) + +((constant) @constant + (#match? @constant "^[A-Z\\d_]+$")) + +(constant) @constructor + +(self) @variable.builtin +(super) @variable.builtin + +(block_parameter (identifier) @variable.parameter) +(block_parameters (identifier) @variable.parameter) +(destructured_parameter (identifier) @variable.parameter) +(hash_splat_parameter (identifier) @variable.parameter) +(lambda_parameters (identifier) @variable.parameter) +(method_parameters (identifier) @variable.parameter) +(splat_parameter (identifier) @variable.parameter) + +(keyword_parameter name: (identifier) @variable.parameter) +(optional_parameter name: (identifier) @variable.parameter) + +((identifier) @function.method + (#is-not? local)) +(identifier) @variable + +; Literals + +[ + (string) + (bare_string) + (subshell) + (heredoc_body) + (heredoc_beginning) +] @string + +[ + (simple_symbol) + (delimited_symbol) + (hash_key_symbol) + (bare_symbol) +] @string.special.symbol + +(regex) @string.regexp +(escape_sequence) @constant.character.escape + +[ + (integer) + (float) +] @constant.numeric.integer + +[ + (nil) + (true) + (false) +]@constant.builtin + +(interpolation + "#{" @punctuation.special + "}" @punctuation.special) @embedded + +(comment) @comment + +; Operators + +[ +"=" +"=>" +"->" +] @operator + +[ + "," + ";" + "." +] @punctuation.delimiter + +[ + "(" + ")" + "[" + "]" + "{" + "}" + "%w(" + "%i(" +] @punctuation.bracket diff --git a/helix-22.03-x86_64-windows/runtime/queries/ruby/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/ruby/indents.toml new file mode 100644 index 0000000..b417751 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ruby/indents.toml @@ -0,0 +1,25 @@ +indent = [ + "argument_list", + "array", + "begin", + "block", + "call", + "class", + "case", + "do_block", + "elsif", + "if", + "hash", + "method", + "module", + "singleton_class", + "singleton_method", +] + +outdent = [ + ")", + "}", + "]", + "end", + "when", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/ruby/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/ruby/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ruby/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/ruby/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/ruby/locals.scm new file mode 100644 index 0000000..393caaf --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ruby/locals.scm @@ -0,0 +1,27 @@ +((method) @local.scope + (#set! local.scope-inherits false)) + +[ + (lambda) + (block) + (do_block) +] @local.scope + +(block_parameter (identifier) @local.definition) +(block_parameters (identifier) @local.definition) +(destructured_parameter (identifier) @local.definition) +(hash_splat_parameter (identifier) @local.definition) +(lambda_parameters (identifier) @local.definition) +(method_parameters (identifier) @local.definition) +(splat_parameter (identifier) @local.definition) + +(keyword_parameter name: (identifier) @local.definition) +(optional_parameter name: (identifier) @local.definition) + +(identifier) @local.reference + +(assignment left: (identifier) @local.definition) +(operator_assignment left: (identifier) @local.definition) +(left_assignment_list (identifier) @local.definition) +(rest_assignment (identifier) @local.definition) +(destructured_left_assignment (identifier) @local.definition) diff --git a/helix-22.03-x86_64-windows/runtime/queries/ruby/tags.scm b/helix-22.03-x86_64-windows/runtime/queries/ruby/tags.scm new file mode 100644 index 0000000..47ba1eb --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/ruby/tags.scm @@ -0,0 +1,64 @@ +; Method definitions + +( + (comment)* @doc + . + [ + (method + name: (_) @name) @definition.method + (singleton_method + name: (_) @name) @definition.method + ] + (#strip! @doc "^#\\s*") + (#select-adjacent! @doc @definition.method) +) + +(alias + name: (_) @name) @definition.method + +(setter + (identifier) @ignore) + +; Class definitions + +( + (comment)* @doc + . + [ + (class + name: [ + (constant) @name + (scope_resolution + name: (_) @name) + ]) @definition.class + (singleton_class + value: [ + (constant) @name + (scope_resolution + name: (_) @name) + ]) @definition.class + ] + (#strip! @doc "^#\\s*") + (#select-adjacent! @doc @definition.class) +) + +; Module definitions + +( + (module + name: [ + (constant) @name + (scope_resolution + name: (_) @name) + ]) @definition.module +) + +; Calls + +(call method: (identifier) @name) @reference.call + +( + [(identifier) (constant)] @name @reference.call + (#is-not? local) + (#not-match? @name "^(lambda|load|require|require_relative|__FILE__|__LINE__)$") +) diff --git a/helix-22.03-x86_64-windows/runtime/queries/rust/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/rust/highlights.scm new file mode 100644 index 0000000..26496c6 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/rust/highlights.scm @@ -0,0 +1,356 @@ +; ------- +; Tree-Sitter doesn't allow overrides in regards to captures, +; though it is possible to affect the child node of a captured +; node. Thus, the approach here is to flip the order so that +; overrides are unnecessary. +; ------- + + + +; ------- +; Types +; ------- + +; --- +; Primitives +; --- + +(escape_sequence) @constant.character.escape +(primitive_type) @type.builtin +(boolean_literal) @constant.builtin.boolean +(integer_literal) @constant.numeric.integer +(float_literal) @constant.numeric.float +(char_literal) @constant.character +[ + (string_literal) + (raw_string_literal) +] @string +[ + (line_comment) + (block_comment) +] @comment + +; --- +; Extraneous +; --- + +(self) @variable.builtin +(enum_variant (identifier) @type.enum.variant) + +(field_initializer + (field_identifier) @variable.other.member) +(shorthand_field_initializer + (identifier) @variable.other.member) +(shorthand_field_identifier) @variable.other.member + +(lifetime + "'" @label + (identifier) @label) +(loop_label + (identifier) @type) + +; --- +; Punctuation +; --- + +[ + "::" + "." + ";" +] @punctuation.delimiter + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket +(type_arguments + [ + "<" + ">" + ] @punctuation.bracket) +(type_parameters + [ + "<" + ">" + ] @punctuation.bracket) + +; --- +; Variables +; --- + +(let_declaration + pattern: [ + ((identifier) @variable) + ((tuple_pattern + (identifier) @variable)) + ]) + +; It needs to be anonymous to not conflict with `call_expression` further below. +(_ + value: (field_expression + value: (identifier)? @variable + field: (field_identifier) @variable.other.member)) + +(arguments + (identifier) @variable.parameter) +(parameter + pattern: (identifier) @variable.parameter) +(closure_parameters + (identifier) @variable.parameter) + + + +; ------- +; Keywords +; ------- + +(for_expression + "for" @keyword.control) +((identifier) @keyword.control + (#match? @keyword.control "^yield$")) +[ + "while" + "loop" + "in" + "break" + "continue" + + "match" + "if" + "else" + "return" + + "await" +] @keyword.control + +"use" @keyword.control.import +(mod_item "mod" @keyword.control.import !body) +(use_as_clause "as" @keyword.control.import) + +(type_cast_expression "as" @keyword.operator) + +[ + (crate) + (super) + "as" + "pub" + "mod" + "extern" + + "fn" + "struct" + "enum" + "impl" + "where" + "trait" + "for" + + "type" + "union" + "unsafe" + "default" + "macro_rules!" + + "let" + "ref" + "move" + + "dyn" + "static" + "const" + "async" +] @keyword + +(mutable_specifier) @keyword.mut + +; TODO: variable.mut to highlight mutable identifiers via locals.scm + +; ------- +; Guess Other Types +; ------- + +((identifier) @constant + (#match? @constant "^[A-Z][A-Z\\d_]+$")) + +; --- +; PascalCase identifiers in call_expressions (e.g. `Ok()`) +; are assumed to be enum constructors. +; --- + +(call_expression + function: [ + ((identifier) @type.variant + (#match? @type.variant "^[A-Z]")) + (scoped_identifier + name: ((identifier) @type.variant + (#match? @type.variant "^[A-Z]"))) + ]) + +; --- +; Assume that types in match arms are enums and not +; tuple structs. Same for `if let` expressions. +; --- + +(match_pattern + (scoped_identifier + name: (identifier) @constructor)) +(tuple_struct_pattern + type: [ + ((identifier) @constructor) + (scoped_identifier + name: (identifier) @constructor) + ]) +(struct_pattern + type: [ + ((type_identifier) @constructor) + (scoped_type_identifier + name: (type_identifier) @constructor) + ]) + +; --- +; Other PascalCase identifiers are assumed to be structs. +; --- + +((identifier) @type + (#match? @type "^[A-Z]")) + + + +; ------- +; Functions +; ------- + +(call_expression + function: [ + ((identifier) @function) + (scoped_identifier + name: (identifier) @function) + (field_expression + field: (field_identifier) @function) + ]) +(generic_function + function: [ + ((identifier) @function) + (scoped_identifier + name: (identifier) @function) + (field_expression + field: (field_identifier) @function.method) + ]) + +(function_item + name: (identifier) @function) + +; --- +; Macros +; --- +(meta_item + (identifier) @function.macro) + +(inner_attribute_item) @attribute + +(macro_definition + name: (identifier) @function.macro) +(macro_invocation + macro: [ + ((identifier) @function.macro) + (scoped_identifier + name: (identifier) @function.macro) + ] + "!" @function.macro) + +(metavariable) @variable.parameter +(fragment_specifier) @type + + + +; ------- +; Operators +; ------- + +[ + "*" + "'" + "->" + "=>" + "<=" + "=" + "==" + "!" + "!=" + "%" + "%=" + "&" + "&=" + "&&" + "|" + "|=" + "||" + "^" + "^=" + "*" + "*=" + "-" + "-=" + "+" + "+=" + "/" + "/=" + ">" + "<" + ">=" + ">>" + "<<" + ">>=" + "@" + ".." + "..=" + "'" +] @operator + + + +; ------- +; Paths +; ------- + +(use_declaration + argument: (identifier) @namespace) +(use_wildcard + (identifier) @namespace) +(extern_crate_declaration + name: (identifier) @namespace) +(mod_item + name: (identifier) @namespace) +(scoped_use_list + path: (identifier)? @namespace) +(use_list + (identifier) @namespace) +(use_as_clause + path: (identifier)? @namespace + alias: (identifier) @namespace) + +; --- +; Remaining Paths +; --- + +(scoped_identifier + path: (identifier)? @namespace + name: (identifier) @namespace) +(scoped_type_identifier + path: (identifier) @namespace) + + + +; ------- +; Remaining Identifiers +; ------- + +"?" @special + +(type_identifier) @type +(identifier) @variable +(field_identifier) @variable.other.member diff --git a/helix-22.03-x86_64-windows/runtime/queries/rust/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/rust/indents.toml new file mode 100644 index 0000000..51a0cee --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/rust/indents.toml @@ -0,0 +1,28 @@ +indent = [ + "use_list", + "block", + "match_block", + "arguments", + "parameters", + "declaration_list", + "field_declaration_list", + "field_initializer_list", + "struct_pattern", + "tuple_pattern", + "unit_expression", + "enum_variant_list", + "call_expression", + "binary_expression", + "field_expression", + "tuple_expression", + "array_expression", + "where_clause", + "macro_invocation" +] + +outdent = [ + "where", + "}", + "]", + ")" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/rust/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/rust/injections.scm new file mode 100644 index 0000000..77c7080 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/rust/injections.scm @@ -0,0 +1,26 @@ +([(line_comment) (block_comment)] @injection.content + (#set! injection.language "comment")) + +((macro_invocation + (token_tree) @injection.content) + (#set! injection.language "rust") + (#set! injection.include-children)) + +((macro_rule + (token_tree) @injection.content) + (#set! injection.language "rust") + (#set! injection.include-children)) + +(call_expression + function: (scoped_identifier + path: (identifier) @_regex (#eq? @_regex "Regex") + name: (identifier) @_new (#eq? @_new "new")) + arguments: (arguments (raw_string_literal) @injection.content) + (#set! injection.language "regex")) + +(call_expression + function: (scoped_identifier + path: (scoped_identifier (identifier) @_regex (#eq? @_regex "Regex") .) + name: (identifier) @_new (#eq? @_new "new")) + arguments: (arguments (raw_string_literal) @injection.content) + (#set! injection.language "regex")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/rust/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/rust/locals.scm new file mode 100644 index 0000000..6428f9b --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/rust/locals.scm @@ -0,0 +1,17 @@ +; Scopes + +(block) @local.scope + +; Definitions + +(parameter + (identifier) @local.definition) + +(let_declaration + pattern: (identifier) @local.definition) + +(closure_parameters (identifier)) @local.definition + +; References +(identifier) @local.reference + diff --git a/helix-22.03-x86_64-windows/runtime/queries/rust/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/rust/textobjects.scm new file mode 100644 index 0000000..086db67 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/rust/textobjects.scm @@ -0,0 +1,35 @@ +(function_item + body: (_) @function.inside) @function.around + +(struct_item + body: (_) @class.inside) @class.around + +(enum_item + body: (_) @class.inside) @class.around + +(union_item + body: (_) @class.inside) @class.around + +(trait_item + body: (_) @class.inside) @class.around + +(impl_item + body: (_) @class.inside) @class.around + +(parameters + (_) @parameter.inside) + +(closure_parameters + (_) @parameter.inside) + +(arguments + (_) @parameter.inside) + +[ + (line_comment) + (block_comment) +] @comment.inside + +(line_comment)+ @comment.around + +(block_comment) @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/scala/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/scala/highlights.scm new file mode 100644 index 0000000..50a6e18 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/scala/highlights.scm @@ -0,0 +1,203 @@ +; CREDITS @stumash (stuart.mashaal@gmail.com) + +;; variables + + +((identifier) @variable.builtin + (#match? @variable.builtin "^this$")) + +(interpolation) @none + +; Assume other uppercase names constants. +; NOTE: In order to distinguish constants we highlight +; all the identifiers that are uppercased. But this solution +; is not suitable for all occurrences e.g. it will highlight +; an uppercased method as a constant if used with no params. +; Introducing highlighting for those specific cases, is probably +; best way to resolve the issue. +((identifier) @constant (#match? @constant "^[A-Z]")) + +;; types + +(type_identifier) @type + +(class_definition + name: (identifier) @type) + +(object_definition + name: (identifier) @type) + +(trait_definition + name: (identifier) @type) + +(type_definition + name: (type_identifier) @type) + +; method definition + +(class_definition + body: (template_body + (function_definition + name: (identifier) @function.method))) +(object_definition + body: (template_body + (function_definition + name: (identifier) @function.method))) +(trait_definition + body: (template_body + (function_definition + name: (identifier) @function.method))) + +; imports + +(import_declaration + path: (identifier) @namespace) +((stable_identifier (identifier) @namespace)) + +((import_declaration + path: (identifier) @type) (#match? @type "^[A-Z]")) +((stable_identifier (identifier) @type) (#match? @type "^[A-Z]")) + +((import_selectors (identifier) @type) (#match? @type "^[A-Z]")) + +; method invocation + + +(call_expression + function: (identifier) @function) + +(call_expression + function: (field_expression + field: (identifier) @function.method)) + +((call_expression + function: (identifier) @variable.other.member) + (#match? @variable.other.member "^[A-Z]")) + +(generic_function + function: (identifier) @function) + +( + (identifier) @function.builtin + (#match? @function.builtin "^super$") +) + +; function definitions + +(function_definition + name: (identifier) @function) + +(parameter + name: (identifier) @variable.parameter) + +; expressions + + +(field_expression field: (identifier) @variable.other.member) +(field_expression value: (identifier) @type + (#match? @type "^[A-Z]")) + +(infix_expression operator: (identifier) @operator) +(infix_expression operator: (operator_identifier) @operator) +(infix_type operator: (operator_identifier) @operator) +(infix_type operator: (operator_identifier) @operator) + +; literals +(boolean_literal) @constant.builtin.boolean +(integer_literal) @constant.numeric.integer +(floating_point_literal) @constant.numeric.float + + +(symbol_literal) @string.special.symbol + +[ +(string) +(character_literal) +(interpolated_string_expression) +] @string + +(interpolation "$" @punctuation.special) + +;; keywords + +[ + "abstract" + "case" + "class" + "extends" + "final" + "finally" +;; `forSome` existential types not implemented yet + "implicit" + "lazy" +;; `macro` not implemented yet + "object" + "override" + "package" + "private" + "protected" + "sealed" + "trait" + "type" + "val" + "var" + "with" +] @keyword + +(null_literal) @constant.builtin +(wildcard) @keyword + +;; special keywords + +"new" @keyword.operator + +[ + "else" + "if" + "match" + "try" + "catch" + "throw" +] @keyword.control.conditional + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + +[ + "." + "," +] @punctuation.delimiter + +[ + "do" + "for" + "while" + "yield" +] @keyword.control.repeat + +"def" @keyword.function + +[ + "=>" + "<-" + "@" +] @keyword.operator + +"import" @keyword.control.import + +"return" @keyword.control.return + +(comment) @comment + +;; `case` is a conditional keyword in case_block + +(case_block + (case_clause ("case") @keyword.control.conditional)) + +(identifier) @variable \ No newline at end of file diff --git a/helix-22.03-x86_64-windows/runtime/queries/scala/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/scala/indents.toml new file mode 100644 index 0000000..6de5484 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/scala/indents.toml @@ -0,0 +1,23 @@ + +indent = [ + "block", + "arguments", + "parameter", + "class_definition", + "trait_definition", + "object_definition", + "function_definition", + "val_definition", + "import_declaration", + "while_expression", + "do_while_expression", + "for_expression", + "try_expression", + "match_expression" +] + +outdent = [ + "}", + "]", + ")" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/scala/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/scala/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/scala/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/solidity/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/solidity/highlights.scm new file mode 100644 index 0000000..61c89ac --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/solidity/highlights.scm @@ -0,0 +1,189 @@ +(comment) @comment + +; Pragma +(pragma_directive) @tag +(solidity_version_comparison_operator ">=" @tag) +(solidity_version_comparison_operator "<=" @tag) +(solidity_version_comparison_operator "=" @tag) +(solidity_version_comparison_operator "~" @tag) +(solidity_version_comparison_operator "^" @tag) + + +; Literals +[ + (string) + (hex_string_literal) + (unicode_string_literal) + (yul_string_literal) +] @string +[ + (number_literal) + (yul_decimal_number) + (yul_hex_number) +] @constant.numeric +[ + (true) + (false) +] @constant.builtin + + +; Type +(type_name) @type +(primitive_type) @type +(struct_declaration struct_name: (identifier) @type) +(enum_declaration enum_type_name: (identifier) @type) +; Color payable in payable address conversion as type and not as keyword +(payable_conversion_expression "payable" @type) +(emit_statement . (identifier) @type) +; Handles ContractA, ContractB in function foo() override(ContractA, contractB) {} +(override_specifier (identifier) @type) +; Ensures that delimiters in mapping( ... => .. ) are not colored like types +(type_name "(" @punctuation.bracket "=>" @punctuation.delimiter ")" @punctuation.bracket) + + + +; Functions and parameters + +(function_definition + function_name: (identifier) @function) +(modifier_definition + name: (identifier) @function) +(yul_evm_builtin) @function.builtin + +; Use contructor coloring for special functions +(constructor_definition "constructor" @constructor) +(fallback_receive_definition "receive" @constructor) +(fallback_receive_definition "fallback" @constructor) + +(modifier_invocation (identifier) @function) + +; Handles expressions like structVariable.g(); +(call_expression . (member_expression (property_identifier) @function.method)) + +; Handles expressions like g(); +(call_expression . (identifier) @function) + +; Function parameters +(event_paramater name: (identifier) @variable.parameter) +(function_definition + function_name: (identifier) @variable.parameter) + +; Yul functions +(yul_function_call function: (yul_identifier) @function) + +; Yul function parameters +(yul_function_definition . (yul_identifier) @function (yul_identifier) @variable.parameter) + +(meta_type_expression "type" @keyword) + +(member_expression (property_identifier) @variable.other.member) +(property_identifier) @variable.other.member +(struct_expression ((identifier) @variable.other.member . ":")) +(enum_value) @variable.other.member + + +; Keywords +[ + "pragma" + "import" + "contract" + "interface" + "library" + "is" + "struct" + "enum" + "event" + "using" + "assembly" + "switch" + "case" + "default" + "break" + "continue" + "if" + "else" + "for" + "while" + "do" + "try" + "catch" + "return" + "emit" + "public" + "internal" + "private" + "external" + "pure" + "view" + "payable" + "modifier" + "returns" + "memory" + "storage" + "calldata" + "function" + "var" + (constant) + (virtual) + (override_specifier) + (yul_leave) +] @keyword + +(import_directive "as" @keyword) +(import_directive "from" @keyword) +(event_paramater "indexed" @keyword) + +; Punctuation + +[ + "(" + ")" + "[" + "]" + "{" + "}" +] @punctuation.bracket + + +[ + "." + "," +] @punctuation.delimiter + + +; Operators + +[ + "&&" + "||" + ">>" + ">>>" + "<<" + "&" + "^" + "|" + "+" + "-" + "*" + "/" + "%" + "**" + "<" + "<=" + "==" + "!=" + "!==" + ">=" + ">" + "!" + "~" + "-" + "+" + "delete" + "new" + "++" + "--" +] @operator + +(identifier) @variable +(yul_identifier) @variable diff --git a/helix-22.03-x86_64-windows/runtime/queries/svelte/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/svelte/highlights.scm new file mode 100644 index 0000000..22b0c55 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/svelte/highlights.scm @@ -0,0 +1,68 @@ +; Special identifiers +;-------------------- + +; TODO: +((element (start_tag (tag_name) @_tag) (text) @markup.heading) + (#match? @_tag "^(h[0-9]|title)$")) + +((element (start_tag (tag_name) @_tag) (text) @markup.bold) + (#match? @_tag "^(strong|b)$")) + +((element (start_tag (tag_name) @_tag) (text) @markup.italic) + (#match? @_tag "^(em|i)$")) + +; ((element (start_tag (tag_name) @_tag) (text) @markup.strike) +; (#match? @_tag "^(s|del)$")) + +((element (start_tag (tag_name) @_tag) (text) @markup.underline) + (#eq? @_tag "u")) + +((element (start_tag (tag_name) @_tag) (text) @markup.inline) + (#match? @_tag "^(code|kbd)$")) + +((element (start_tag (tag_name) @_tag) (text) @markup.link.url) + (#eq? @_tag "a")) + +((attribute + (attribute_name) @_attr + (quoted_attribute_value (attribute_value) @markup.link.url)) + (#match? @_attr "^(href|src)$")) + +(tag_name) @tag +(attribute_name) @variable.other.member +(erroneous_end_tag_name) @error +(comment) @comment + +[ + (attribute_value) + (quoted_attribute_value) +] @string + +[ + (text) + (raw_text_expr) +] @none + +[ + (special_block_keyword) + (then) + (as) +] @keyword + +[ + "{" + "}" +] @punctuation.brackets + +"=" @operator + +[ + "<" + ">" + "" + "#" + ":" + "/" + "@" +] @punctuation.definition.tag diff --git a/helix-22.03-x86_64-windows/runtime/queries/svelte/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/svelte/indents.toml new file mode 100644 index 0000000..693db8e --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/svelte/indents.toml @@ -0,0 +1,18 @@ +indent = [ + "element" + "if_statement" + "each_statement" + "await_statement" +] + +outdent = [ + "end_tag" + "else_statement" + "if_end_expr" + "each_end_expr" + "await_end_expr" + ">" + "/>" +] + +ignore = "comment" diff --git a/helix-22.03-x86_64-windows/runtime/queries/svelte/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/svelte/injections.scm new file mode 100644 index 0000000..04e860c --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/svelte/injections.scm @@ -0,0 +1,30 @@ +; injections.scm +; -------------- +((style_element + (raw_text) @injection.content) + (#set! injection.language "css")) + +((attribute + (attribute_name) @_attr + (quoted_attribute_value (attribute_value) @css)) + (#eq? @_attr "style")) + +((script_element + (raw_text) @injection.content) + (#set! injection.language "javascript")) + +((raw_text_expr) @injection.content + (#set! injection.language "javascript")) + +( + (script_element + (start_tag + (attribute + (quoted_attribute_value (attribute_value) @_lang))) + (raw_text) @injection.content) + (#match? @_lang "(ts|typescript)") + (#set! injection.language "typescript") +) + +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/tablegen/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/tablegen/highlights.scm new file mode 100644 index 0000000..8ade5ba --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/tablegen/highlights.scm @@ -0,0 +1,90 @@ +[ + (comment) + (multiline_comment) +] @comment + +[ + "(" + ")" + "[" + "]" + "{" + "}" + "<" + ">" +] @punctuation.bracket + +[ + "," + ";" + "." +] @punctuation.delimiter + +[ + "#" + "-" + "..." + ":" +] @operator + +[ + "=" + "!cond" + (operator_keyword) +] @function + +[ + "true" + "false" +] @constant.builtin.boolean + +[ + "?" +] @constant.builtin + +(var) @variable + +(template_arg (identifier) @variable.parameter) + +(_ argument: (value (identifier) @variable.parameter)) + +(type) @type + +"code" @type.builtin + +(number) @constant.numeric.integer +[ + (string_string) + (code_string) +] @string + +(preprocessor) @keyword.directive + +[ + "class" + "field" + "let" + "defvar" + "def" + "defset" + "defvar" + "assert" +] @keyword + +[ + "let" + "in" + "foreach" + "if" + "then" + "else" +] @keyword.operator + +"include" @keyword.control.import + +[ + "multiclass" + "defm" +] @namespace + +(ERROR) @error diff --git a/helix-22.03-x86_64-windows/runtime/queries/tablegen/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/tablegen/indents.toml new file mode 100644 index 0000000..43532f4 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/tablegen/indents.toml @@ -0,0 +1,7 @@ +indent = [ + "statement", +] + +outdent = [ + "}", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/tablegen/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/tablegen/injections.scm new file mode 100644 index 0000000..0b476f8 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/tablegen/injections.scm @@ -0,0 +1,2 @@ +([ (comment) (multiline_comment)] @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/tablegen/textobjects.scm b/helix-22.03-x86_64-windows/runtime/queries/tablegen/textobjects.scm new file mode 100644 index 0000000..89645b3 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/tablegen/textobjects.scm @@ -0,0 +1,16 @@ +(class + body: (_) @class.inside) @class.around + +(multiclass + body: (_) @class.inside) @class.around + +(_ argument: _ @parameter.inside) + +[ + (comment) + (multiline_comment) +] @comment.inside + +(comment)+ @comment.around + +(multiline_comment) @comment.around diff --git a/helix-22.03-x86_64-windows/runtime/queries/toml/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/toml/highlights.scm new file mode 100644 index 0000000..2742b2b --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/toml/highlights.scm @@ -0,0 +1,33 @@ +; Properties +;----------- + +(bare_key) @variable.other.member +(quoted_key) @string + +; Literals +;--------- + +(boolean) @constant.builtin.boolean +(comment) @comment +(string) @string +(integer) @constant.numeric.integer +(float) @constant.numeric.float +(offset_date_time) @string.special +(local_date_time) @string.special +(local_date) @string.special +(local_time) @string.special + +; Punctuation +;------------ + +"." @punctuation.delimiter +"," @punctuation.delimiter + +"=" @operator + +"[" @punctuation.bracket +"]" @punctuation.bracket +"[[" @punctuation.bracket +"]]" @punctuation.bracket +"{" @punctuation.bracket +"}" @punctuation.bracket diff --git a/helix-22.03-x86_64-windows/runtime/queries/toml/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/toml/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/toml/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/tsq/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/tsq/highlights.scm new file mode 100644 index 0000000..549895c --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/tsq/highlights.scm @@ -0,0 +1,46 @@ +; mark the string passed #match? as a regex +(((predicate_name) @function + (capture) + (string) @string.regexp) + (#eq? @function "#match?")) + +; highlight inheritance comments +((query . (comment) @keyword.directive) + (#match? @keyword.directive "^;\ +inherits *:")) + +[ + "(" + ")" + "[" + "]" +] @punctuation.bracket + +":" @punctuation.delimiter + +[ + (one_or_more) + (zero_or_one) + (zero_or_more) +] @operator + +[ + (wildcard_node) + (anchor) +] @constant.builtin + +[ + (anonymous_leaf) + (string) +] @string + +(comment) @comment + +(field_name) @variable.other.member + +(capture) @label + +(predicate_name) @function + +(escape_sequence) @constant.character.escape + +(node_name) @variable diff --git a/helix-22.03-x86_64-windows/runtime/queries/tsq/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/tsq/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/tsq/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/tsx/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/tsx/highlights.scm new file mode 100644 index 0000000..1b61e36 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/tsx/highlights.scm @@ -0,0 +1 @@ +; inherits: typescript diff --git a/helix-22.03-x86_64-windows/runtime/queries/tsx/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/tsx/injections.scm new file mode 100644 index 0000000..1b61e36 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/tsx/injections.scm @@ -0,0 +1 @@ +; inherits: typescript diff --git a/helix-22.03-x86_64-windows/runtime/queries/twig/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/twig/highlights.scm new file mode 100644 index 0000000..2c95ab6 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/twig/highlights.scm @@ -0,0 +1,16 @@ +(comment_directive) @comment + +[ + "{%" + "{%-" + "{%~" + "%}" + "-%}" + "~%}" + "{{" + "{{-" + "{{~" + "}}" + "-}}" + "~}}" +] @keyword diff --git a/helix-22.03-x86_64-windows/runtime/queries/twig/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/twig/injections.scm new file mode 100644 index 0000000..f082273 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/twig/injections.scm @@ -0,0 +1,3 @@ +((content) @injection.content + (#set! injection.language "html") + (#set! injection.combined)) diff --git a/helix-22.03-x86_64-windows/runtime/queries/typescript/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/typescript/highlights.scm new file mode 100644 index 0000000..a3212a3 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/typescript/highlights.scm @@ -0,0 +1,36 @@ +; inherits: javascript + +; Types + +(type_identifier) @type +(predefined_type) @type.builtin + +((identifier) @type + (#match? @type "^[A-Z]")) + +(type_arguments + "<" @punctuation.bracket + ">" @punctuation.bracket) + +; Variables + +(required_parameter (identifier) @variable.parameter) +(optional_parameter (identifier) @variable.parameter) + +; Keywords + +[ + "abstract" + "declare" + "enum" + "export" + "implements" + "interface" + "keyof" + "namespace" + "private" + "protected" + "public" + "type" + "readonly" +] @keyword diff --git a/helix-22.03-x86_64-windows/runtime/queries/typescript/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/typescript/indents.toml new file mode 100644 index 0000000..9d711ab --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/typescript/indents.toml @@ -0,0 +1,28 @@ +indent = [ + "array", + "object", + "arguments", + "formal_parameters", + + "statement_block", + "object_pattern", + "class_body", + "named_imports", + + "binary_expression", + "return_statement", + "template_substitution", + # (expression_statement (call_expression)) + "export_clause", + + # typescript + "enum_declaration", + "interface_declaration", + "object_type", +] + +outdent = [ + "}", + "]", + ")" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/typescript/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/typescript/injections.scm new file mode 100644 index 0000000..ff0ddfa --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/typescript/injections.scm @@ -0,0 +1 @@ +; inherits: javascript diff --git a/helix-22.03-x86_64-windows/runtime/queries/typescript/locals.scm b/helix-22.03-x86_64-windows/runtime/queries/typescript/locals.scm new file mode 100644 index 0000000..aa6d6ff --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/typescript/locals.scm @@ -0,0 +1,2 @@ +(required_parameter (identifier) @local.definition) +(optional_parameter (identifier) @local.definition) diff --git a/helix-22.03-x86_64-windows/runtime/queries/typescript/tags.scm b/helix-22.03-x86_64-windows/runtime/queries/typescript/tags.scm new file mode 100644 index 0000000..ccae934 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/typescript/tags.scm @@ -0,0 +1,23 @@ +(function_signature + name: (identifier) @name) @definition.function + +(method_signature + name: (property_identifier) @name) @definition.method + +(abstract_method_signature + name: (property_identifier) @name) @definition.method + +(abstract_class_declaration + name: (type_identifier) @name) @definition.class + +(module + name: (identifier) @name) @definition.module + +(interface_declaration + name: (type_identifier) @name) @definition.interface + +(type_annotation + (type_identifier) @name) @reference.type + +(new_expression + constructor: (identifier) @name) @reference.class diff --git a/helix-22.03-x86_64-windows/runtime/queries/vue/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/vue/highlights.scm new file mode 100644 index 0000000..f90ae42 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/vue/highlights.scm @@ -0,0 +1,21 @@ +(tag_name) @tag +(end_tag) @tag + +(directive_name) @keyword +(directive_argument) @constant + +(attribute + (attribute_name) @attribute + (quoted_attribute_value + (attribute_value) @string) +) + +(comment) @comment + +[ + "<" + ">" + "" + ">=" + ">>" + "<" + "<=" + "<<" + "%" + "-" + "+" + "|" + "||" + "*" + "~" + "^" +] @operator + +(attribute + (identifier) @variable.other.member) + +(comment) @comment + +(ERROR) @error diff --git a/helix-22.03-x86_64-windows/runtime/queries/wgsl/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/wgsl/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/wgsl/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/yaml/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/yaml/highlights.scm new file mode 100644 index 0000000..e4fed27 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/yaml/highlights.scm @@ -0,0 +1,43 @@ +(block_mapping_pair + key: (flow_node [(double_quote_scalar) (single_quote_scalar)] @variable.other.member)) +(block_mapping_pair + key: (flow_node (plain_scalar (string_scalar) @variable.other.member))) + +(flow_mapping + (_ key: (flow_node [(double_quote_scalar) (single_quote_scalar)] @variable.other.member))) +(flow_mapping + (_ key: (flow_node (plain_scalar (string_scalar) @variable.other.member)))) + +(boolean_scalar) @constant.builtin.boolean +(null_scalar) @constant.builtin +(double_quote_scalar) @string +(single_quote_scalar) @string +(block_scalar) @string +(string_scalar) @string +(escape_sequence) @constant.character.escape +(integer_scalar) @constant.numeric.integer +(float_scalar) @constant.numeric.float +(comment) @comment +(anchor_name) @type +(alias_name) @type +(tag) @type +(yaml_directive) @keyword +(ERROR) @error + +[ +"," +"-" +":" +">" +"?" +"|" +] @punctuation.delimiter + +[ +"[" +"]" +"{" +"}" +] @punctuation.bracket + +["*" "&" "---" "..."] @punctuation.special diff --git a/helix-22.03-x86_64-windows/runtime/queries/yaml/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/yaml/indents.toml new file mode 100644 index 0000000..ddc3578 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/yaml/indents.toml @@ -0,0 +1,3 @@ +indent = [ + "block_mapping_pair", +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/yaml/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/yaml/injections.scm new file mode 100644 index 0000000..321c90a --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/yaml/injections.scm @@ -0,0 +1,2 @@ +((comment) @injection.content + (#set! injection.language "comment")) diff --git a/helix-22.03-x86_64-windows/runtime/queries/zig/highlights.scm b/helix-22.03-x86_64-windows/runtime/queries/zig/highlights.scm new file mode 100644 index 0000000..62c99ac --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/zig/highlights.scm @@ -0,0 +1,234 @@ +[ + (container_doc_comment) + (doc_comment) + (line_comment) +] @comment + +[ + variable: (IDENTIFIER) + variable_type_function: (IDENTIFIER) +] @variable + +parameter: (IDENTIFIER) @variable.parameter + +[ + field_member: (IDENTIFIER) + field_access: (IDENTIFIER) +] @variable.other.member + +;; assume TitleCase is a type +( + [ + variable_type_function: (IDENTIFIER) + field_access: (IDENTIFIER) + parameter: (IDENTIFIER) + ] @type + (#match? @type "^[A-Z]([a-z]+[A-Za-z0-9]*)*$") +) +;; assume camelCase is a function +( + [ + variable_type_function: (IDENTIFIER) + field_access: (IDENTIFIER) + parameter: (IDENTIFIER) + ] @function + (#match? @function "^[a-z]+([A-Z][a-z0-9]*)+$") +) + +;; assume all CAPS_1 is a constant +( + [ + variable_type_function: (IDENTIFIER) + field_access: (IDENTIFIER) + ] @constant + (#match? @constant "^[A-Z][A-Z_0-9]+$") +) + +[ + function_call: (IDENTIFIER) + function: (IDENTIFIER) +] @function + +exception: "!" @function.macro + +( + (IDENTIFIER) @variable.builtin + (#eq? @variable.builtin "_") +) + +(PtrTypeStart "c" @variable.builtin) + +( + (ContainerDeclType + [ + (ErrorUnionExpr) + "enum" + ] + ) + (ContainerField (IDENTIFIER) @constant) +) + +field_constant: (IDENTIFIER) @constant + +(BUILTINIDENTIFIER) @function.builtin + +((BUILTINIDENTIFIER) @keyword.control.import + (#any-of? @keyword.control.import "@import" "@cImport")) + +(INTEGER) @constant.numeric.integer + +(FLOAT) @constant.numeric.float + +[ + (LINESTRING) + (STRINGLITERALSINGLE) +] @string + +(CHAR_LITERAL) @constant.character +(EscapeSequence) @constant.character.escape +(FormatSequence) @string.special + +[ + "allowzero" + "volatile" + "anytype" + "anyframe" + (BuildinTypeExpr) +] @type.builtin + +(BreakLabel (IDENTIFIER) @label) +(BlockLabel (IDENTIFIER) @label) + +[ + "true" + "false" +] @constant.builtin.boolean + +[ + "undefined" + "unreachable" + "null" +] @constant.builtin + +[ + "else" + "if" + "switch" +] @keyword.control.conditional + +[ + "for" + "while" +] @keyword.control.repeat + +[ + "or" + "and" + "orelse" +] @operator + +[ + "struct" + "enum" + "union" + "error" + "packed" + "opaque" +] @keyword + +[ + "try" + "error" + "catch" +] @function.macro + +; VarDecl +[ + "threadlocal" + "fn" +] @keyword.function + +[ + "const" + "var" + "test" + "pub" + "usingnamespace" +] @keyword + +[ + "return" + "break" + "continue" +] @keyword.control + +; Macro +[ + "defer" + "errdefer" + "async" + "nosuspend" + "await" + "suspend" + "resume" + "export" + "extern" +] @function.macro + +; PrecProc +[ + "comptime" + "inline" + "noinline" + "asm" + "callconv" + "noalias" +] @keyword.directive + +[ + "linksection" + "align" +] @function.builtin + +[ + (CompareOp) + (BitwiseOp) + (BitShiftOp) + (AdditionOp) + (AssignOp) + (MultiplyOp) + (PrefixOp) + "*" + "**" + "->" + ".?" + ".*" + "?" +] @operator + +[ + ";" + "." + "," + ":" +] @punctuation.delimiter + +[ + ".." + "..." +] @punctuation.special + +[ + "[" + "]" + "(" + ")" + "{" + "}" + (Payload "|") + (PtrPayload "|") + (PtrIndexPayload "|") +] @punctuation.bracket + +; Error +(ERROR) @keyword diff --git a/helix-22.03-x86_64-windows/runtime/queries/zig/indents.toml b/helix-22.03-x86_64-windows/runtime/queries/zig/indents.toml new file mode 100644 index 0000000..36ba8e5 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/zig/indents.toml @@ -0,0 +1,16 @@ +indent = [ + "Block", + "BlockExpr", + "ContainerDecl", + "SwitchExpr", + "AssignExpr", + "ErrorUnionExpr", + "Statement", + "InitList" +] + +outdent = [ + "}", + "]", + ")" +] diff --git a/helix-22.03-x86_64-windows/runtime/queries/zig/injections.scm b/helix-22.03-x86_64-windows/runtime/queries/zig/injections.scm new file mode 100644 index 0000000..3df9589 --- /dev/null +++ b/helix-22.03-x86_64-windows/runtime/queries/zig/injections.scm @@ -0,0 +1,2 @@ +([(line_comment) (doc_comment)] @injection.content + (#set! injection.language "comment")) -- cgit v1.2.3