//!
//! The sibling `ra_ide_api_light` handles thouse bits of IDE functionality
//! which are restricted to a single file and need only syntax.
-macro_rules! ctry {
- ($expr:expr) => {
- match $expr {
- None => return Ok(None),
- Some(it) => it,
- }
- };
-}
-
-mod completion;
mod db;
-mod goto_definition;
mod imp;
pub mod mock_analysis;
-mod runnables;
mod symbol_index;
+mod navigation_target;
+mod status;
+mod completion;
+mod runnables;
+mod goto_definition;
mod extend_selection;
mod hover;
mod call_info;
mod syntax_highlighting;
+mod parent_module;
+mod rename;
+
+#[cfg(test)]
+mod marks;
use std::{fmt, sync::Arc};
-use hir::{Def, ModuleSource, Name};
-use ra_syntax::{SmolStr, SourceFile, TreePtr, SyntaxKind, SyntaxNode, TextRange, TextUnit, AstNode};
+use ra_syntax::{SourceFile, TreeArc, TextRange, TextUnit};
use ra_text_edit::TextEdit;
-use ra_db::{SyntaxDatabase, FilesDatabase, LocalSyntaxPtr, BaseDatabase};
+use ra_db::{
+ SourceDatabase, CheckCanceled,
+ salsa::{self, ParallelDatabase},
+};
use rayon::prelude::*;
use relative_path::RelativePathBuf;
use rustc_hash::FxHashMap;
-use salsa::ParallelDatabase;
use crate::{
symbol_index::{FileSymbol, SymbolIndex},
};
pub use crate::{
- completion::{CompletionItem, CompletionItemKind, InsertText},
+ completion::{CompletionItem, CompletionItemKind, InsertTextFormat},
runnables::{Runnable, RunnableKind},
+ navigation_target::NavigationTarget,
};
pub use ra_ide_api_light::{
Fold, FoldKind, HighlightedRange, Severity, StructureNode,
LineIndex, LineCol, translate_offset_with_edit,
};
pub use ra_db::{
- Cancelable, Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId
+ Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId
};
+pub type Cancelable<T> = Result<T, Canceled>;
+
#[derive(Default)]
pub struct AnalysisChange {
new_roots: Vec<(SourceRootId, bool)>,
}
}
-/// `NavigationTarget` represents and element in the editor's UI whihc you can
-/// click on to navigate to a particular piece of code.
-///
-/// Typically, a `NavigationTarget` corresponds to some element in the source
-/// code, like a function or a struct, but this is not strictly required.
-#[derive(Debug, Clone)]
-pub struct NavigationTarget {
- file_id: FileId,
- name: SmolStr,
- kind: SyntaxKind,
- range: TextRange,
- // Should be DefId ideally
- ptr: Option<LocalSyntaxPtr>,
-}
-
-impl NavigationTarget {
- fn from_symbol(symbol: FileSymbol) -> NavigationTarget {
- NavigationTarget {
- file_id: symbol.file_id,
- name: symbol.name.clone(),
- kind: symbol.ptr.kind(),
- range: symbol.ptr.range(),
- ptr: Some(symbol.ptr.clone()),
- }
- }
-
- fn from_syntax(name: Option<Name>, file_id: FileId, node: &SyntaxNode) -> NavigationTarget {
- NavigationTarget {
- file_id,
- name: name.map(|n| n.to_string().into()).unwrap_or("".into()),
- kind: node.kind(),
- range: node.range(),
- ptr: Some(LocalSyntaxPtr::new(node)),
- }
- }
- // TODO once Def::Item is gone, this should be able to always return a NavigationTarget
- fn from_def(db: &db::RootDatabase, def: Def) -> Cancelable<Option<NavigationTarget>> {
- Ok(match def {
- Def::Struct(s) => {
- let (file_id, node) = s.source(db)?;
- Some(NavigationTarget::from_syntax(
- s.name(db)?,
- file_id.original_file(db),
- node.syntax(),
- ))
- }
- Def::Enum(e) => {
- let (file_id, node) = e.source(db)?;
- Some(NavigationTarget::from_syntax(
- e.name(db)?,
- file_id.original_file(db),
- node.syntax(),
- ))
- }
- Def::EnumVariant(ev) => {
- let (file_id, node) = ev.source(db)?;
- Some(NavigationTarget::from_syntax(
- ev.name(db)?,
- file_id.original_file(db),
- node.syntax(),
- ))
- }
- Def::Function(f) => {
- let (file_id, node) = f.source(db)?;
- let name = f.signature(db).name().clone();
- Some(NavigationTarget::from_syntax(
- Some(name),
- file_id.original_file(db),
- node.syntax(),
- ))
- }
- Def::Module(m) => {
- let (file_id, source) = m.definition_source(db)?;
- let name = m.name(db)?;
- match source {
- ModuleSource::SourceFile(node) => {
- Some(NavigationTarget::from_syntax(name, file_id, node.syntax()))
- }
- ModuleSource::Module(node) => {
- Some(NavigationTarget::from_syntax(name, file_id, node.syntax()))
- }
- }
- }
- Def::Item => None,
- })
- }
-
- pub fn name(&self) -> &SmolStr {
- &self.name
- }
-
- pub fn kind(&self) -> SyntaxKind {
- self.kind
- }
-
- pub fn file_id(&self) -> FileId {
- self.file_id
- }
-
- pub fn range(&self) -> TextRange {
- self.range
- }
-}
-
#[derive(Debug)]
pub struct RangeInfo<T> {
pub range: TextRange,
}
impl<T> RangeInfo<T> {
- fn new(range: TextRange, info: T) -> RangeInfo<T> {
+ pub fn new(range: TextRange, info: T) -> RangeInfo<T> {
RangeInfo { range, info }
}
}
pub fn apply_change(&mut self, change: AnalysisChange) {
self.db.apply_change(change)
}
+
+ pub fn maybe_collect_garbage(&mut self) {
+ self.db.maybe_collect_garbage();
+ }
+
+ pub fn collect_garbage(&mut self) {
+ self.db.collect_garbage();
+ }
}
/// Analysis is a snapshot of a world state at a moment in time. It is the main
}
impl Analysis {
+ /// Debug info about the current state of the analysis
+ pub fn status(&self) -> String {
+ status::status(&*self.db)
+ }
+
/// Gets the text of the source file.
pub fn file_text(&self, file_id: FileId) -> Arc<String> {
self.db.file_text(file_id)
}
/// Gets the syntax tree of the file.
- pub fn file_syntax(&self, file_id: FileId) -> TreePtr<SourceFile> {
- self.db.source_file(file_id).clone()
+ pub fn parse(&self, file_id: FileId) -> TreeArc<SourceFile> {
+ self.db.parse(file_id).clone()
}
/// Gets the file's `LineIndex`: data structure to convert between absolute
}
/// Selects the next syntactic nodes encopasing the range.
- pub fn extend_selection(&self, frange: FileRange) -> TextRange {
- extend_selection::extend_selection(&self.db, frange)
+ pub fn extend_selection(&self, frange: FileRange) -> Cancelable<TextRange> {
+ self.with_db(|db| extend_selection::extend_selection(db, frange))
}
/// Returns position of the mathcing brace (all types of braces are
/// supported).
- pub fn matching_brace(&self, file: &SourceFile, offset: TextUnit) -> Option<TextUnit> {
- ra_ide_api_light::matching_brace(file, offset)
+ pub fn matching_brace(&self, position: FilePosition) -> Option<TextUnit> {
+ let file = self.db.parse(position.file_id);
+ ra_ide_api_light::matching_brace(&file, position.offset)
}
/// Returns a syntax tree represented as `String`, for debug purposes.
// FIXME: use a better name here.
pub fn syntax_tree(&self, file_id: FileId) -> String {
- let file = self.db.source_file(file_id);
+ let file = self.db.parse(file_id);
ra_ide_api_light::syntax_tree(&file)
}
/// Returns an edit to remove all newlines in the range, cleaning up minor
/// stuff like trailing commas.
pub fn join_lines(&self, frange: FileRange) -> SourceChange {
- let file = self.db.source_file(frange.file_id);
+ let file = self.db.parse(frange.file_id);
SourceChange::from_local_edit(
frange.file_id,
ra_ide_api_light::join_lines(&file, frange.range),
/// Returns an edit which should be applied when opening a new line, fixing
/// up minor stuff like continuing the comment.
pub fn on_enter(&self, position: FilePosition) -> Option<SourceChange> {
- let file = self.db.source_file(position.file_id);
+ let file = self.db.parse(position.file_id);
let edit = ra_ide_api_light::on_enter(&file, position.offset)?;
Some(SourceChange::from_local_edit(position.file_id, edit))
}
/// this works when adding `let =`.
// FIXME: use a snippet completion instead of this hack here.
pub fn on_eq_typed(&self, position: FilePosition) -> Option<SourceChange> {
- let file = self.db.source_file(position.file_id);
+ let file = self.db.parse(position.file_id);
let edit = ra_ide_api_light::on_eq_typed(&file, position.offset)?;
Some(SourceChange::from_local_edit(position.file_id, edit))
}
/// Returns an edit which should be applied when a dot ('.') is typed on a blank line, indenting the line appropriately.
pub fn on_dot_typed(&self, position: FilePosition) -> Option<SourceChange> {
- let file = self.db.source_file(position.file_id);
+ let file = self.db.parse(position.file_id);
let edit = ra_ide_api_light::on_dot_typed(&file, position.offset)?;
Some(SourceChange::from_local_edit(position.file_id, edit))
}
/// Returns a tree representation of symbols in the file. Useful to draw a
/// file outline.
pub fn file_structure(&self, file_id: FileId) -> Vec<StructureNode> {
- let file = self.db.source_file(file_id);
+ let file = self.db.parse(file_id);
ra_ide_api_light::file_structure(&file)
}
/// Returns the set of folding ranges.
pub fn folding_ranges(&self, file_id: FileId) -> Vec<Fold> {
- let file = self.db.source_file(file_id);
+ let file = self.db.parse(file_id);
ra_ide_api_light::folding_ranges(&file)
}
/// Fuzzy searches for a symbol.
pub fn symbol_search(&self, query: Query) -> Cancelable<Vec<NavigationTarget>> {
self.with_db(|db| {
- let res = symbol_index::world_symbols(db, query)?
+ symbol_index::world_symbols(db, query)
.into_iter()
.map(NavigationTarget::from_symbol)
- .collect::<Vec<_>>();
- Ok(res)
- })?
+ .collect::<Vec<_>>()
+ })
}
pub fn goto_definition(
&self,
position: FilePosition,
- ) -> Cancelable<Option<Vec<NavigationTarget>>> {
- self.db
- .catch_canceled(|db| goto_definition::goto_definition(db, position))?
+ ) -> Cancelable<Option<RangeInfo<Vec<NavigationTarget>>>> {
+ self.with_db(|db| goto_definition::goto_definition(db, position))
}
/// Finds all usages of the reference at point.
pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
- self.with_db(|db| db.find_all_refs(position))?
+ self.with_db(|db| db.find_all_refs(position))
}
/// Returns a short text descrbing element at position.
pub fn hover(&self, position: FilePosition) -> Cancelable<Option<RangeInfo<String>>> {
- self.with_db(|db| hover::hover(db, position))?
+ self.with_db(|db| hover::hover(db, position))
}
/// Computes parameter information for the given call expression.
pub fn call_info(&self, position: FilePosition) -> Cancelable<Option<CallInfo>> {
- self.db
- .catch_canceled(|db| call_info::call_info(db, position))?
+ self.with_db(|db| call_info::call_info(db, position))
}
/// Returns a `mod name;` declaration which created the current module.
pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<NavigationTarget>> {
- self.with_db(|db| db.parent_module(position))?
+ self.with_db(|db| parent_module::parent_module(db, position))
}
/// Returns crates this file belongs too.
pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
- self.with_db(|db| db.crate_for(file_id))?
+ self.with_db(|db| db.crate_for(file_id))
}
/// Returns the root file of the given crate.
pub fn crate_root(&self, crate_id: CrateId) -> Cancelable<FileId> {
- Ok(self.db.crate_graph().crate_root(crate_id))
+ self.with_db(|db| db.crate_graph().crate_root(crate_id))
}
/// Returns the set of possible targets to run for the current file.
pub fn runnables(&self, file_id: FileId) -> Cancelable<Vec<Runnable>> {
- self.db
- .catch_canceled(|db| runnables::runnables(db, file_id))?
+ self.with_db(|db| runnables::runnables(db, file_id))
}
/// Computes syntax highlighting for the given file.
pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
- self.db
- .catch_canceled(|db| syntax_highlighting::highlight(db, file_id))?
+ self.with_db(|db| syntax_highlighting::highlight(db, file_id))
}
/// Computes completions at the given position.
pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
- let completions = self
- .db
- .catch_canceled(|db| completion::completions(db, position))??;
- Ok(completions.map(|it| it.into()))
+ self.with_db(|db| completion::completions(db, position).map(Into::into))
}
/// Computes assists (aks code actons aka intentions) for the given
/// position.
pub fn assists(&self, frange: FileRange) -> Cancelable<Vec<SourceChange>> {
- Ok(self.db.assists(frange))
+ self.with_db(|db| db.assists(frange))
}
/// Computes the set of diagnostics for the given file.
pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
- self.with_db(|db| db.diagnostics(file_id))?
+ self.with_db(|db| db.diagnostics(file_id))
}
/// Computes the type of the expression at the given position.
pub fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
- self.with_db(|db| hover::type_of(db, frange))?
+ self.with_db(|db| hover::type_of(db, frange))
}
/// Returns the edit required to rename reference at the position to the new
&self,
position: FilePosition,
new_name: &str,
- ) -> Cancelable<Vec<SourceFileEdit>> {
- self.with_db(|db| db.rename(position, new_name))?
+ ) -> Cancelable<Option<SourceChange>> {
+ self.with_db(|db| rename::rename(db, position, new_name))
}
fn with_db<F: FnOnce(&db::RootDatabase) -> T + std::panic::UnwindSafe, T>(
projects / rust.git / blobdiff