Language features

engines.openidea = "^1.3"
wasm = "dist/plugin.wasm"

[[contributes.providers]]
kinds = ["completion", "hover"]
languages = ["markdown"]          # editor language ids; "*" for any (1–64 entries)

use openidea_plugin::hover::{Hover, HoverProvider};
use openidea_plugin::providers::{CompletionItem, CompletionKind, Document, Providers};
use openidea_plugin::{Error, Invocation, Plugin, Position, register_plugin, text};

#[derive(Default)]
struct Todos;

impl Plugin for Todos {
    fn run_command(&mut self, id: &str, _ctx: &Invocation, _arg: Option<&str>) -> Result<Option<String>, Error> {
        Err(Error::NotFound(id.into()))
    }
}

impl Providers for Todos {
    fn completion(&mut self, _doc: &Document, _at: Position, _trigger: Option<&str>) -> Vec<CompletionItem> {
        let mut item = CompletionItem::new("todo", CompletionKind::Snippet);
        item.insert_text = "TODO(${1:owner}): $0".into();
        item.snippet = true;
        item.detail = Some("TODO comment".into());
        vec![item]
    }
}

impl HoverProvider for Todos {
    fn hover(&mut self, doc: &Document, at: Position) -> Option<Hover> {
        let offset = text::offset(&doc.text, at)?;
        doc.text[offset..].starts_with("TODO").then(|| Hover::new("**TODO**: tracked work"))
    }
}

register_plugin!(Todos, providers, hover);

use openidea_plugin::providers::{Document, LineMarker, Providers};

impl Providers for Mapper {
    fn line_markers(&mut self, doc: &Document) -> Vec<LineMarker> {
        self.links(doc)
            .into_iter()
            .map(|(line, target)| LineMarker {
                line,
                icon: Some("implemented".into()),
                tooltip: "Go to the XML statement".into(),
                target: Some(target),
            })
            .collect()
    }
}

[[contributes.markerIcons]]
id = "resource"
icon = "icons/resource.svg"
iconDark = "icons/resource_dark.svg"   # optional

use openidea_plugin::semantic_tokens::{Document, SemanticToken, SemanticTokens, TokenKind, TokenModifier};
use openidea_plugin::{Range, text};

impl SemanticTokens for MyPlugin {
    fn semantic_tokens(&mut self, doc: &Document) -> Vec<SemanticToken> {
        let (start, end) = (text::position(&doc.text, 10), text::position(&doc.text, 14));
        vec![SemanticToken::new(Range { start, end }, TokenKind::Method).modifier(TokenModifier::Static)]
    }
}

use openidea_plugin::inlay_hints::{Document, InlayHint, InlayHints, InlayKind};
use openidea_plugin::Range;

impl InlayHints for MyPlugin {
    fn inlay_hints(&mut self, _doc: &Document, range: Range) -> Vec<InlayHint> {
        vec![InlayHint::new(range.start, ": string").kind(InlayKind::Type).tooltip("returns string")]
    }
}

use openidea_plugin::language_features::{CodeLens, Document, LanguageFeatures};
use openidea_plugin::Range;

impl LanguageFeatures for BlameAnnotations {
    fn code_lenses(&mut self, _doc: &Document) -> Vec<CodeLens> {
        vec![CodeLens {
            range: Range::default(),
            title: "Show blame annotations".into(),
            command: "annotate".into(),   // a command this plugin declares
            argument: None,
        }]
    }
}
register_plugin!(BlameAnnotations, language_features);

use openidea_plugin::language_features::{Document, Injection, Injections};
use openidea_plugin::text;

impl Injections for MyPlugin {
    fn injections(&mut self, doc: &Document) -> Vec<Injection> {
        let Some(start) = doc.text.find("[[") else { return vec![] };
        let Some(len) = doc.text[start + 2..].find("]]") else { return vec![] };
        vec![Injection {
            range: openidea_plugin::Range {
                start: text::position(&doc.text, start + 2),
                end: text::position(&doc.text, start + 2 + len),
            },
            language: "sql".into(),
        }]
    }
}

use openidea_plugin::syntax::{Fold, Highlight, Symbol, SyntaxProvider, Token};

impl SyntaxProvider for Solidity {
    fn highlights(&mut self, _language: &str, text: &str) -> Vec<Token> {
        lex(text).map(|(range, keyword)| Token { range, kind: if keyword { Highlight::Keyword } else { Highlight::Variable } }).collect()
    }
    fn outline(&mut self, _language: &str, text: &str) -> Vec<Symbol> { outline(text) }   // optional
    fn folding(&mut self, _language: &str, text: &str) -> Vec<Fold> {                     // optional
        openidea_plugin::syntax::bracket_folds(text, b'{', b'}', &[])
    }
}
register_plugin!(Solidity, syntax);

[[contributes.languages]]
path = "languages/solidity.toml"

id = "solidity"
name = "Solidity"
extensions = ["sol"]
line-comment = "//"
block-comment = ["/*", "*/"]
indent = { tab-size = 4, insert-spaces = true }

[[language-servers]]
name = "solidity-language-server"
command = "nomicfoundation-solidity-language-server"
args = ["--stdio"]
root-markers = ["hardhat.config.ts", "foundry.toml", "package.json"]
install-hint = "npm install -g @nomicfoundation/solidity-language-server"

[[contributes.snippets]]           # API 1.4
language = "sql"
path = "snippets/sql.json"

{
  "Select rows": {
    "prefix": ["sel", "select"],
    "body": ["SELECT ${1:column}", "FROM ${2:table}$0"],
    "description": "Select rows from a table"
  }
}