The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
//! Syntax for the plugin's own languages (highlighting, structure view,
//! folding) when the IDE has no grammar for them. Implement [`SyntaxProvider`]
//! and register with `register_plugin!(MyPlugin, syntax)`.
//!
//! The IDE calls these with the whole document on the editing path, so keep
//! them fast (a hand-written lexer is typical). Offsets are UTF-8 byte offsets
//! into `text`; lines are 0-based.
use std::ops::Range;
/// Highlight categories; the theme decides the colours.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Highlight {
Keyword,
String,
StringSpecial,
Escape,
Regexp,
Atom,
Number,
Constant,
Comment,
DocComment,
Function,
FunctionCall,
Builtin,
Type,
Namespace,
Variable,
SelfVariable,
Property,
Attribute,
Macro,
Label,
Tag,
Operator,
Punctuation,
}
impl Highlight {
pub fn name(self) -> &'static str {
match self {
Self::Keyword => "keyword",
Self::String => "string",
Self::StringSpecial => "string-special",
Self::Escape => "escape",
Self::Regexp => "regexp",
Self::Atom => "atom",
Self::Number => "number",
Self::Constant => "constant",
Self::Comment => "comment",
Self::DocComment => "doc-comment",
Self::Function => "function",
Self::FunctionCall => "function-call",
Self::Builtin => "builtin",
Self::Type => "type",
Self::Namespace => "namespace",
Self::Variable => "variable",
Self::SelfVariable => "self-variable",
Self::Property => "property",
Self::Attribute => "attribute",
Self::Macro => "macro",
Self::Label => "label",
Self::Tag => "tag",
Self::Operator => "operator",
Self::Punctuation => "punctuation",
}
}
}
/// A highlighted range. Tokens must not overlap; the IDE sorts them.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Token {
pub range: Range<usize>,
pub kind: Highlight,
}
/// Kinds of structure-view symbols.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SymbolKind {
Module,
Namespace,
Package,
Class,
Interface,
Struct,
Enum,
EnumMember,
Trait,
Function,
Method,
Constructor,
Field,
Property,
Variable,
Constant,
TypeParameter,
TypeAlias,
Macro,
Event,
Operator,
Key,
}
impl SymbolKind {
pub fn name(self) -> &'static str {
match self {
Self::Module => "module",
Self::Namespace => "namespace",
Self::Package => "package",
Self::Class => "class",
Self::Interface => "interface",
Self::Struct => "struct",
Self::Enum => "enum",
Self::EnumMember => "enum-member",
Self::Trait => "trait",
Self::Function => "function",
Self::Method => "method",
Self::Constructor => "constructor",
Self::Field => "field",
Self::Property => "property",
Self::Variable => "variable",
Self::Constant => "constant",
Self::TypeParameter => "type-parameter",
Self::TypeAlias => "type-alias",
Self::Macro => "macro",
Self::Event => "event",
Self::Operator => "operator",
Self::Key => "key",
}
}
}
/// A symbol of the structure view. `parent` is the index of the enclosing
/// symbol in the same list, which must come before it.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Symbol {
pub name: String,
pub detail: Option<String>,
pub kind: SymbolKind,
/// The whole declaration.
pub range: Range<usize>,
/// The name; where navigation lands.
pub name_range: Range<usize>,
pub parent: Option<usize>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FoldKind {
Region,
Comment,
Imports,
}
/// A foldable range of lines (the first stays visible).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Fold {
pub start_line: u32,
pub end_line: u32,
pub kind: FoldKind,
}
/// Syntax of the languages the plugin contributes. `language` is the
/// language id from the plugin's definition.
pub trait SyntaxProvider {
fn highlights(&mut self, language: &str, text: &str) -> Vec<Token>;
fn outline(&mut self, _language: &str, _text: &str) -> Vec<Symbol> {
Vec::new()
}
fn folding(&mut self, _language: &str, _text: &str) -> Vec<Fold> {
Vec::new()
}
}
/// Folds for every multi-line `open` … `close` pair (braces, brackets),
/// skipping the ones inside the given non-code ranges (strings, comments).
pub fn bracket_folds(text: &str, open: u8, close: u8, skip: &[Range<usize>]) -> Vec<Fold> {
let mut folds = Vec::new();
let mut stack: Vec<u32> = Vec::new();
let mut line = 0u32;
let mut skip = skip.iter().peekable();
for (i, b) in text.bytes().enumerate() {
while skip.peek().is_some_and(|r| r.end <= i) {
skip.next();
}
if b == b'\n' {
line += 1;
continue;
}
if skip.peek().is_some_and(|r| r.start <= i) {
continue;
}
if b == open {
stack.push(line);
} else if b == close
&& let Some(start) = stack.pop()
&& line > start
{
folds.push(Fold { start_line: start, end_line: line, kind: FoldKind::Region });
}
}
folds
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bracket_folds_skip_strings() {
let text = "a {\n \"{\"\n b {\n }\n}\n";
let s = text.find('"').unwrap();
let folds = bracket_folds(text, b'{', b'}', std::slice::from_ref(&(s..s + 3)));
assert_eq!(
folds,
[
Fold { start_line: 2, end_line: 3, kind: FoldKind::Region },
Fold { start_line: 0, end_line: 4, kind: FoldKind::Region },
]
);
}
}