use ide_db::imports::import_assets::LocatedImport;
use itertools::Itertools;
use syntax::{ast, AstNode, GreenNode, SyntaxNode};
use crate::context::CompletionContext;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SnippetScope {
Item,
Expr,
Type,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Snippet {
pub postfix_triggers: Box<[Box<str>]>,
pub prefix_triggers: Box<[Box<str>]>,
pub scope: SnippetScope,
pub description: Option<Box<str>>,
snippet: String,
requires: Box<[GreenNode]>,
}
impl Snippet {
pub fn new(
prefix_triggers: &[String],
postfix_triggers: &[String],
snippet: &[String],
description: &str,
requires: &[String],
scope: SnippetScope,
) -> Option<Self> {
if prefix_triggers.is_empty() && postfix_triggers.is_empty() {
return None;
}
let (requires, snippet, description) = validate_snippet(snippet, description, requires)?;
Some(Snippet {
postfix_triggers: postfix_triggers.iter().map(String::as_str).map(Into::into).collect(),
prefix_triggers: prefix_triggers.iter().map(String::as_str).map(Into::into).collect(),
scope,
snippet,
description,
requires,
})
}
pub(crate) fn imports(&self, ctx: &CompletionContext<'_>) -> Option<Vec<LocatedImport>> {
import_edits(ctx, &self.requires)
}
pub fn snippet(&self) -> String {
self.snippet.replace("${receiver}", "$0")
}
pub fn postfix_snippet(&self, receiver: &str) -> String {
self.snippet.replace("${receiver}", receiver)
}
}
fn import_edits(ctx: &CompletionContext<'_>, requires: &[GreenNode]) -> Option<Vec<LocatedImport>> {
let resolve = |import: &GreenNode| {
let path = ast::Path::cast(SyntaxNode::new_root(import.clone()))?;
let item = match ctx.scope.speculative_resolve(&path)? {
hir::PathResolution::Def(def) => def.into(),
_ => return None,
};
let path = ctx.module.find_use_path_prefixed(
ctx.db,
item,
ctx.config.insert_use.prefix_kind,
ctx.config.prefer_no_std,
)?;
Some((path.len() > 1).then(|| LocatedImport::new(path.clone(), item, item, None)))
};
let mut res = Vec::with_capacity(requires.len());
for import in requires {
match resolve(import) {
Some(first) => res.extend(first),
None => return None,
}
}
Some(res)
}
fn validate_snippet(
snippet: &[String],
description: &str,
requires: &[String],
) -> Option<(Box<[GreenNode]>, String, Option<Box<str>>)> {
let mut imports = Vec::with_capacity(requires.len());
for path in requires.iter() {
let use_path = ast::SourceFile::parse(&format!("use {path};"))
.syntax_node()
.descendants()
.find_map(ast::Path::cast)?;
if use_path.syntax().text() != path.as_str() {
return None;
}
let green = use_path.syntax().green().into_owned();
imports.push(green);
}
let snippet = snippet.iter().join("\n");
let description = (!description.is_empty())
.then(|| description.split_once('\n').map_or(description, |(it, _)| it))
.map(ToOwned::to_owned)
.map(Into::into);
Some((imports.into_boxed_slice(), snippet, description))
}