//! Assorted functions shared by several assists. pub(crate) mod insert_use; pub(crate) mod import_assets; use std::ops; use hir::{Crate, Enum, Module, ScopeDef, Semantics, Trait}; use ide_db::RootDatabase; use itertools::Itertools; use syntax::{ ast::{self, make, ArgListOwner}, AstNode, Direction, SyntaxKind::*, SyntaxNode, TextSize, T, }; use crate::assist_config::SnippetCap; pub use insert_use::MergeBehaviour; pub(crate) use insert_use::{insert_use, ImportScope}; pub fn mod_path_to_ast(path: &hir::ModPath) -> ast::Path { let mut segments = Vec::new(); let mut is_abs = false; match path.kind { hir::PathKind::Plain => {} hir::PathKind::Super(0) => segments.push(make::path_segment_self()), hir::PathKind::Super(n) => segments.extend((0..n).map(|_| make::path_segment_super())), hir::PathKind::DollarCrate(_) | hir::PathKind::Crate => { segments.push(make::path_segment_crate()) } hir::PathKind::Abs => is_abs = true, } segments.extend( path.segments .iter() .map(|segment| make::path_segment(make::name_ref(&segment.to_string()))), ); make::path_from_segments(segments, is_abs) } pub(crate) fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr { extract_trivial_expression(&block) .filter(|expr| !expr.syntax().text().contains_char('\n')) .unwrap_or_else(|| block.into()) } pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> { let has_anything_else = |thing: &SyntaxNode| -> bool { let mut non_trivial_children = block.syntax().children_with_tokens().filter(|it| match it.kind() { WHITESPACE | T!['{'] | T!['}'] => false, _ => it.as_node() != Some(thing), }); non_trivial_children.next().is_some() }; if let Some(expr) = block.expr() { if has_anything_else(expr.syntax()) { return None; } return Some(expr); } // Unwrap `{ continue; }` let (stmt,) = block.statements().next_tuple()?; if let ast::Stmt::ExprStmt(expr_stmt) = stmt { if has_anything_else(expr_stmt.syntax()) { return None; } let expr = expr_stmt.expr()?; match expr.syntax().kind() { CONTINUE_EXPR | BREAK_EXPR | RETURN_EXPR => return Some(expr), _ => (), } } None } #[derive(Clone, Copy, Debug)] pub(crate) enum Cursor<'a> { Replace(&'a SyntaxNode), Before(&'a SyntaxNode), } impl<'a> Cursor<'a> { fn node(self) -> &'a SyntaxNode { match self { Cursor::Replace(node) | Cursor::Before(node) => node, } } } pub(crate) fn render_snippet(_cap: SnippetCap, node: &SyntaxNode, cursor: Cursor) -> String { assert!(cursor.node().ancestors().any(|it| it == *node)); let range = cursor.node().text_range() - node.text_range().start(); let range: ops::Range<usize> = range.into(); let mut placeholder = cursor.node().to_string(); escape(&mut placeholder); let tab_stop = match cursor { Cursor::Replace(placeholder) => format!("${{0:{}}}", placeholder), Cursor::Before(placeholder) => format!("$0{}", placeholder), }; let mut buf = node.to_string(); buf.replace_range(range, &tab_stop); return buf; fn escape(buf: &mut String) { stdx::replace(buf, '{', r"\{"); stdx::replace(buf, '}', r"\}"); stdx::replace(buf, '$', r"\$"); } } pub(crate) fn vis_offset(node: &SyntaxNode) -> TextSize { node.children_with_tokens() .find(|it| !matches!(it.kind(), WHITESPACE | COMMENT | ATTR)) .map(|it| it.text_range().start()) .unwrap_or_else(|| node.text_range().start()) } pub(crate) fn invert_boolean_expression(expr: ast::Expr) -> ast::Expr { if let Some(expr) = invert_special_case(&expr) { return expr; } make::expr_prefix(T![!], expr) } fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> { match expr { ast::Expr::BinExpr(bin) => match bin.op_kind()? { ast::BinOp::NegatedEqualityTest => bin.replace_op(T![==]).map(|it| it.into()), ast::BinOp::EqualityTest => bin.replace_op(T![!=]).map(|it| it.into()), _ => None, }, ast::Expr::MethodCallExpr(mce) => { let receiver = mce.receiver()?; let method = mce.name_ref()?; let arg_list = mce.arg_list()?; let method = match method.text().as_str() { "is_some" => "is_none", "is_none" => "is_some", "is_ok" => "is_err", "is_err" => "is_ok", _ => return None, }; Some(make::expr_method_call(receiver, method, arg_list)) } ast::Expr::PrefixExpr(pe) if pe.op_kind()? == ast::PrefixOp::Not => pe.expr(), // FIXME: // ast::Expr::Literal(true | false ) _ => None, } } /// Helps with finding well-know things inside the standard library. This is /// somewhat similar to the known paths infra inside hir, but it different; We /// want to make sure that IDE specific paths don't become interesting inside /// the compiler itself as well. pub struct FamousDefs<'a, 'b>(pub &'a Semantics<'b, RootDatabase>, pub Option<Crate>); #[allow(non_snake_case)] impl FamousDefs<'_, '_> { pub const FIXTURE: &'static str = r#"//- /libcore.rs crate:core pub mod convert { pub trait From<T> { fn from(t: T) -> Self; } } pub mod iter { pub use self::traits::{collect::IntoIterator, iterator::Iterator}; mod traits { pub(crate) mod iterator { use crate::option::Option; pub trait Iterator { type Item; fn next(&mut self) -> Option<Self::Item>; fn by_ref(&mut self) -> &mut Self { self } fn take(self, n: usize) -> crate::iter::Take<Self> { crate::iter::Take { inner: self } } } impl<I: Iterator> Iterator for &mut I { type Item = I::Item; fn next(&mut self) -> Option<I::Item> { (**self).next() } } } pub(crate) mod collect { pub trait IntoIterator { type Item; } } } pub use self::sources::*; pub(crate) mod sources { use super::Iterator; use crate::option::Option::{self, *}; pub struct Repeat<A> { element: A, } pub fn repeat<T>(elt: T) -> Repeat<T> { Repeat { element: elt } } impl<A> Iterator for Repeat<A> { type Item = A; fn next(&mut self) -> Option<A> { None } } } pub use self::adapters::*; pub(crate) mod adapters { use super::Iterator; use crate::option::Option::{self, *}; pub struct Take<I> { pub(crate) inner: I } impl<I> Iterator for Take<I> where I: Iterator { type Item = <I as Iterator>::Item; fn next(&mut self) -> Option<<I as Iterator>::Item> { None } } } } pub mod option { pub enum Option<T> { None, Some(T)} } pub mod prelude { pub use crate::{convert::From, iter::{IntoIterator, Iterator}, option::Option::{self, *}}; } #[prelude_import] pub use prelude::*; "#; pub fn core(&self) -> Option<Crate> { self.find_crate("core") } pub(crate) fn core_convert_From(&self) -> Option<Trait> { self.find_trait("core:convert:From") } pub(crate) fn core_option_Option(&self) -> Option<Enum> { self.find_enum("core:option:Option") } pub fn core_iter_Iterator(&self) -> Option<Trait> { self.find_trait("core:iter:traits:iterator:Iterator") } pub fn core_iter(&self) -> Option<Module> { self.find_module("core:iter") } fn find_trait(&self, path: &str) -> Option<Trait> { match self.find_def(path)? { hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it), _ => None, } } fn find_enum(&self, path: &str) -> Option<Enum> { match self.find_def(path)? { hir::ScopeDef::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(it))) => Some(it), _ => None, } } fn find_module(&self, path: &str) -> Option<Module> { match self.find_def(path)? { hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(it)) => Some(it), _ => None, } } fn find_crate(&self, name: &str) -> Option<Crate> { let krate = self.1?; let db = self.0.db; let res = krate.dependencies(db).into_iter().find(|dep| dep.name.to_string() == name)?.krate; Some(res) } fn find_def(&self, path: &str) -> Option<ScopeDef> { let db = self.0.db; let mut path = path.split(':'); let trait_ = path.next_back()?; let std_crate = path.next()?; let std_crate = self.find_crate(std_crate)?; let mut module = std_crate.root_module(db); for segment in path { module = module.children(db).find_map(|child| { let name = child.name(db)?; if name.to_string() == segment { Some(child) } else { None } })?; } let def = module.scope(db, None).into_iter().find(|(name, _def)| name.to_string() == trait_)?.1; Some(def) } } pub(crate) fn next_prev() -> impl Iterator<Item = Direction> { [Direction::Next, Direction::Prev].iter().copied() }