- [Adding indent queries](./guides/indent.md)

- [Adding injection queries](./guides/injection.md)

- [Adding tags queries](./guides/tags.md)

| `end-of-line-diagnostics` | Minimum severity of diagnostics to render at the end of the line. Set to `disable` to disable entirely. Refer to the setting about `inline-diagnostics` for more details | "disable"

| `clipboard-provider` | Which API to use for clipboard interaction. One of `pasteboard` (MacOS), `wayland`, `x-clip`, `x-sel`, `win-32-yank`, `termux`, `tmux`, `windows`, `termcode`, `none`, or a custom command set. | Platform and environment specific. |

| `editor-config` | Whether to read settings from [EditorConfig](https://editorconfig.org) files | `true` |

### `[editor.clipboard-provider]` Section

# Guides

This section contains guides for adding new language server configurations,

| `word-completion` | Overrides the [`editor.word-completion`](./editor.md#editorword-completion-section) configuration for the language. |

| `workspace-lsp-roots` | Directories relative to the workspace root that are treated as LSP roots. Should only be set in `.helix/config.toml`. Overwrites the setting of the same name in `config.toml` if set. |

| `persistent-diagnostic-sources` | An array of LSP diagnostic sources assumed unchanged when the language server resends the same set of diagnostics. Helix can track the position for these diagnostics internally instead. Useful for diagnostics that are recomputed on save.

### File-type detection and the `file-types` key

berry = "#2A2A4D"

```

### Scopes

The following is a list of scopes available to use for styling:

use anyhow::{Context, Result};

use arc_swap::{ArcSwap, Guard};

use config::{Configuration, FileType, LanguageConfiguration, LanguageServerConfiguration};

use helix_loader::grammar::get_language;

use helix_stdx::rope::RopeSliceExt as _;

use once_cell::sync::OnceCell;

query_iter::QueryIter,

tree_sitter::{

query::{InvalidPredicateError, UserPredicate},

},

Error, InjectionLanguageMarker, LanguageConfig as SyntaxConfig, Layer,

};

indent_query: OnceCell<Option<IndentQuery>>,

textobject_query: OnceCell<Option<TextObjectQuery>>,

tag_query: OnceCell<Option<TagQuery>>,

}

impl LanguageData {

indent_query: OnceCell::new(),

textobject_query: OnceCell::new(),

tag_query: OnceCell::new(),

}

}

.as_ref()

}

fn reconfigure(&self, scopes: &[String]) {

if let Some(Some(config)) = self.syntax.get() {

reconfigure_highlights(config, scopes);

self.language(lang).tag_query(self)

}

pub fn language_server_configs(&self) -> &HashMap<String, LanguageServerConfiguration> {

&self.language_server_configs

}

range,

)

}

}

pub type Highlighter<'a> = highlighter::Highlighter<'a, 'a, Loader>;

Ok(())

}

#[cfg(test)]

mod test {

use once_cell::sync::Lazy;

pub workspace_lsp_roots: Option<Vec<PathBuf>>,

#[serde(default)]

pub persistent_diagnostic_sources: Vec<String>,

}

impl LanguageConfiguration {

TextObject,

AutoIndent,

Tags,

}

impl TsFeature {

Self::TextObject,

Self::AutoIndent,

Self::Tags,

]

}

Self::TextObject => "textobjects.scm",

Self::AutoIndent => "indents.scm",

Self::Tags => "tags.scm",

}

}

Self::TextObject => "Treesitter Textobjects",

Self::AutoIndent => "Auto Indent",

Self::Tags => "Code Navigation Tags",

}

}

Self::TextObject => "Textobject",

Self::AutoIndent => "Indent",

Self::Tags => "Tags",

}

}

}

&text_annotations,

));

Self::doc_diagnostics_highlights_into(doc, theme, &mut overlays);

if is_focused {

text_annotations.collect_overlay_highlights(range)

}

/// Get highlight spans for document diagnostics

pub fn doc_diagnostics_highlights_into(

doc: &Document,

/// Whether to read settings from [EditorConfig](https://editorconfig.org) files. Defaults to

/// `true`.

pub editor_config: bool,

}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, Eq, PartialOrd, Ord)]

end_of_line_diagnostics: DiagnosticFilter::Enable(Severity::Hint),

clipboard_provider: ClipboardProvider::default(),

editor_config: true,

}

}

}

// tree-sitter highlight styles are stored in a Vec to optimize lookups

scopes: Vec<String>,

highlights: Vec<Style>,

}

impl From<Value> for Theme {

}

}

fn build_theme_values(

mut values: Map<String, Value>,

let mut styles = HashMap::new();

let mut scopes = Vec::new();

let mut highlights = Vec::new();

let mut warnings = Vec::new();

styles.reserve(values.len());

scopes.reserve(values.len());

highlights.reserve(values.len());

for (name, style_value) in values {

let mut style = Style::default();

if let Err(err) = palette.parse_style(&mut style, style_value) {

highlights.push(style);

}

}

impl Theme {

/// To allow `Highlight` to represent arbitrary RGB colors without turning it into an enum,

/// we interpret the last 256^3 numbers as RGB.

})

}

fn from_toml(value: Value) -> (Self, Vec<String>) {

if let Value::Table(table) = value {

Theme::from_keys(table)

}

fn from_keys(toml_keys: Map<String, Value>) -> (Self, Vec<String>) {

let theme = Self {

styles,

scopes,

highlights,

..Default::default()

};

(theme, load_errors)

}

Ok(())

}

}

impl TryFrom<Value> for ThemePalette {

LanguageData::compile_indent_query(grammar, config)?;

LanguageData::compile_textobject_query(grammar, config)?;

LanguageData::compile_tag_query(grammar, config)?;

}

println!("Query check succeeded");