Add language support for D

Implement support in difftastic for the D programming language
using the treesitter grammar provided in https://github.com/gdamore/tree-sitter-d

Author: baruch

build.rs

@@ -87,6 +87,11 @@ fn main() {
             src_dir: "vendored_parsers/tree-sitter-commonlisp-src",
             extra_files: vec![],
         },
+        TreeSitterParser {
+            name: "tree-sitter-d",
+            src_dir: "vendored_parsers/tree-sitter-d-src",
+            extra_files: vec!["scanner.c"],
+        },
         TreeSitterParser {
             name: "tree-sitter-dart",
             src_dir: "vendored_parsers/tree-sitter-dart-src",

src/parse/guess_language.rs

@@ -28,6 +28,7 @@ pub(crate) enum Language {
     CPlusPlus,
     CSharp,
     Css,
+    D,
     Dart,
     DeviceTree,
     Elixir,
@@ -122,6 +123,7 @@ pub(crate) fn language_name(language: Language) -> &'static str {
         CPlusPlus => "C++",
         CSharp => "C#",
         Css => "CSS",
+        D => "D",
         Dart => "Dart",
         DeviceTree => "Device Tree",
         Elixir => "Elixir",
@@ -252,6 +254,7 @@ pub(crate) fn language_globs(language: Language) -> Vec<glob::Pattern> {
         ],
         CSharp => &["*.cs"],
         Css => &["*.css"],
+        D => &["*.d", "*.di"],
         Dart => &["*.dart"],
         DeviceTree => &["*.dts", "*.dtsi", "*.dtso", "*.its"],
         Elm => &["*.elm"],

src/parse/tree_sitter_parser.rs

@@ -74,6 +74,7 @@ extern "C" {
     fn tree_sitter_clojure() -> ts::Language;
     fn tree_sitter_cmake() -> ts::Language;
     fn tree_sitter_commonlisp() -> ts::Language;
+    fn tree_sitter_d() -> ts::Language;
     fn tree_sitter_dart() -> ts::Language;
     fn tree_sitter_devicetree() -> ts::Language;
     fn tree_sitter_elisp() -> ts::Language;
@@ -278,6 +279,20 @@ pub(crate) fn from_language(language: guess::Language) -> TreeSitterConfig {
                 sub_languages: vec![],
             }
         }
+        D => {
+            let language = unsafe { tree_sitter_d() };
+            TreeSitterConfig {
+                language: language.clone(),
+                atom_nodes: ["string_literal", "char_literal"].into_iter().collect(),
+                delimiter_tokens: vec![("(", ")"), ("{", "}"), ("[", "]")],
+                highlight_query: ts::Query::new(
+                    &language,
+                    include_str!("../../vendored_parsers/highlights/d.scm"),
+                )
+                .unwrap(),
+                sub_languages: vec![],
+            }
+        }
         Dart => {
             let language = unsafe { tree_sitter_dart() };
             TreeSitterConfig {

vendored_parsers/highlights/d.scm

@@ -0,0 +1,259 @@
+; highlights.scm
+;
+; Highlighting queries for D code for use by Tree-Sitter.
+;
+; Copyright 2024 Garrett D'Amore
+;
+; Distributed under the MIT License.
+; (See accompanying file LICENSE.txt or https://opensource.org/licenses/MIT)
+; SPDX-License-Identifier: MIT
+
+(string_literal) @string
+(int_literal) @number
+(float_literal) @number
+(char_literal) @number
+(identifier) @variable
+(at_attribute) @property
+(htmlentity) @string.special
+(escape_sequence) @string.escape
+
+[
+	(lazy)
+	(align)
+	(extern)
+	(static)
+	(abstract)
+	(final)
+	(override)
+	(synchronized)
+	(auto)
+	(scope)
+	(gshared)
+	(ref)
+	(deprecated)
+	(nothrow)
+	(pure)
+	(type_ctor)
+] @keyword.storage
+
+(parameter_attribute (return) @keyword.storage)
+(parameter_attribute (in) @keyword.storage)
+(parameter_attribute (out) @keyword.storage)
+
+(function_declaration (identifier) @function)
+
+(call_expression (identifier) @function)
+(call_expression (type (template_instance (identifier) @function)))
+(template_arguments (identifier) @variable.parameter)
+
+(named_argument (identifier) @variable.parameter)
+
+[
+    (abstract)
+    (alias)
+    (align)
+    (asm)
+    (assert)
+    (auto)
+    (cast)
+    (class)
+    (const)
+    (debug)
+    (delegate)
+    (delete)
+    (deprecated)
+    (enum)
+    (export)
+    (extern)
+    (final)
+    (function)
+    (immutable)
+    (import)
+    (in)
+    (inout)
+    (interface)
+    (invariant)
+    (is)
+    (lazy)
+    ; "macro" - obsolete
+    (mixin)
+    (module)
+    (new)
+    (nothrow)
+    (out)
+    (override)
+    (package)
+    (pragma)
+    (private)
+    (protected)
+    (public)
+    (pure)
+    (ref)
+    (scope)
+    (shared)
+    (static)
+    (struct)
+    (super)
+    (synchronized)
+    (template)
+    (this)
+    (throw)
+    (typeid)
+    (typeof)
+    (union)
+    (unittest)
+    (version)
+    (with)
+    (gshared)
+    (traits)
+    (vector)
+    (parameters_)
+] @keyword
+
+[
+    (break)
+    (case)
+    (catch)
+    (continue)
+    (do)
+    (default)
+    (finally)
+    (else)
+    (for)
+    (foreach)
+    (foreach_reverse)
+    (goto)
+    (if)
+    (switch)
+    (try)
+    (return)
+    (while)
+] @keyword.control
+
+[
+    (not_in)
+    (not_is)
+    "/="
+    "/"
+    ".."
+    "..."
+    "&"
+    "&="
+    "&&"
+    "|"
+    "|="
+    "||"
+    "-"
+    "-="
+    "--"
+    "+"
+    "+="
+    "++"
+    "<"
+    "<="
+    "<<"
+    "<<="
+    ">"
+    ">="
+    ">>="
+    ">>>="
+    ">>"
+    ">>>"
+    "!"
+    "!="
+    "?"
+    "$"
+    "="
+    "=="
+    "*"
+    "*="
+    "%"
+    "%="
+    "^"
+    "^="
+    "^^"
+    "^^="
+    "~"
+    "~="
+    "@"
+    "=>"
+] @operator
+
+[
+    ";"
+    "."
+    ":"
+    ","
+] @punctuation.delimiter
+
+[
+    "("
+    ")"
+    "["
+    "["
+    "{"
+    "}"
+] @punctuation.bracket
+
+[
+    (null)
+    (true)
+    (false)
+] @constant.language
+
+(special_keyword) @constant.language
+
+(directive) @keyword.directive
+(shebang) @keyword.directive
+
+(comment) @comment
+
+[
+    (void)
+    (bool)
+    (byte)
+    (ubyte)
+    (char)
+    (short)
+    (ushort)
+    (wchar)
+    (dchar)
+    (int)
+    (uint)
+    (long)
+    (ulong)
+    (real)
+    (double)
+    (float)
+    (size_t)
+    (ptrdiff_t)
+    (string)
+    (cstring)
+    (wstring)
+    (noreturn)
+] @type.builtin
+
+[
+    (cent)
+    (ucent)
+    (ireal)
+    (idouble)
+    (ifloat)
+    (creal)
+    (double)
+    (cfloat)
+] @type.deprecated
+
+(label (identifier) @label)
+(goto_statement (goto) @keyword.control (identifier) @label)
+
+; this covers other cases where the identifier can only
+; be a type (such as in an is-expression on a constraint)
+(type (identifier) @type)
+
+; these are listed last, because they override keyword queries
+(identity_expression (in) @operator)
+(identity_expression (is) @operator)
+
+; everything after __EOF_ is plain text
+(end_file) @text

vendored_parsers/tree-sitter-d-src

@@ -0,0 +1 @@
+tree-sitter-d/src