feat: Add injection.parent-layer property

[nik-rev]

This was originally brought up in helix-editor/helix#13116 (review)

When injecting markdown into the documentation comments of a language, we want the default code block to be the same as the language itself.

So in this Gleam file, with /// being documentation comments we want the default value of the code block to also have the Gleam language injection, as opposed to usually when there would not be any injection at all if there is no info string:

/// Markdown is injected into these comments
/// ```
/// fn foo()
/// ```
fn foo()

It's possible to do this by introducing a bunch of markdown languages that ; inherits markdown scopes, but instead of doing that this PR allows for a more generic way of doing this.

It introduces the injection.parent-layer property which can be set like this:

(#set! injection.language injection.parent-layer)

This will set the injection language to be whatever is the parent layer of this language, if it's injected.

Using the #any-of? injection.parent-layer predicate you are also able to only allow this for specific languages:

(#set! injection.language injection.parent-layer)
(#any-of? injection.parent-layer "gleam" "zig")

The above will have this injection effect only for the "gleam" and "zig" language. This is necessary as we want to control which languages have this power. Without it, we would see the default injection for code block without info strings in Markdown be the Markdown language itself, which we want to avoid.

---

To test this in Helix, add this query at the start of the file (before the (info_string (language)) injection) in runtime/queries/markdown/injections.scm:

(fenced_code_block
  (fenced_code_block_delimiter)
  (block_continuation)
  (code_fence_content) @injection.content
  (fenced_code_block_delimiter)
  (#set! injection.language injection.parent-layer)
  (#set! injection.include-unnamed-children)
  (#any-of? injection.parent-layer "gleam"))

Example file for testing:

/// *Inline markdown*
///
/// ````javascript
/// function main() {}
/// ````
///
/// ``````
/// fn main() {}
/// /// *Inline markdown*
/// ///
/// /// `````
/// /// /// *Inline markdown*
/// /// ///
/// /// /// ````javascript
/// /// /// function main() {}
/// /// /// ````
/// /// ///
/// /// /// ````
/// /// /// fn main() {}
/// /// /// /// *Inline markdown*
/// /// /// ///
/// /// /// /// ```
/// /// /// /// fn main() {}
/// /// /// /// ```
/// /// /// fn main() {}
/// /// /// ````
/// /// fn main() {}
/// /// `````
/// fn main() {}
/// ``````
fn main() {}

Note: Immediately this will be useful for Gleam in helix, and also Zig soon. Rust won't make use of this because it requires a custom language (such as injecting the rust language into markdown code block when the (info_string) is edition2024)

[the-mikedavis]

For this feature - which I do think we should add - I'm thinking a few things:

• For naming probably injection.parent-language is clearer. You can think of it as a variable which expands to the language name.
• Along those lines you should be able to use other predicates like #eq? and #match? on the injection.parent-language variable. This requires refactors to the predicate types. I think we should allow either QueryStrs or captures in these with an enum - the current type seems a bit too strict.

This is something that would be good to align on with Neovim folks. I will drop a message in the tree-sitter-dev matrix channel and tag a few to see what they are thinking - ideally they would implement this feature as well.