_private: (),
}
-pub type Cancelable<T> = Result<T, Canceled>;
-
impl Canceled {
pub(crate) fn new() -> Canceled {
Canceled { _private: () }
use ra_syntax::{TextUnit, TextRange, SourceFile, TreeArc};
pub use crate::{
- cancellation::{Canceled, Cancelable},
+ cancellation::Canceled,
syntax_ptr::LocalSyntaxPtr,
input::{
FilesDatabase, FileId, CrateId, SourceRoot, SourceRootId, CrateGraph, Dependency,
use std::cmp::{max, min};
-use ra_db::{SyntaxDatabase, Cancelable};
+use ra_db::SyntaxDatabase;
use ra_syntax::{
AstNode, SyntaxNode, TextUnit, TextRange,
SyntaxKind::FN_DEF,
use crate::{FilePosition, CallInfo, db::RootDatabase};
/// Computes parameter information for the given call expression.
-pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Cancelable<Option<CallInfo>> {
+pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
let file = db.source_file(position.file_id);
let syntax = file.syntax();
// Find the calling expression and it's NameRef
- let calling_node = ctry!(FnCallNode::with_node(syntax, position.offset));
- let name_ref = ctry!(calling_node.name_ref());
+ let calling_node = FnCallNode::with_node(syntax, position.offset)?;
+ let name_ref = calling_node.name_ref()?;
// Resolve the function's NameRef (NOTE: this isn't entirely accurate).
let file_symbols = db.index_resolve(name_ref);
- let symbol = ctry!(file_symbols.into_iter().find(|it| it.ptr.kind() == FN_DEF));
+ let symbol = file_symbols
+ .into_iter()
+ .find(|it| it.ptr.kind() == FN_DEF)?;
let fn_file = db.source_file(symbol.file_id);
let fn_def = symbol.ptr.resolve(&fn_file);
let fn_def = ast::FnDef::cast(&fn_def).unwrap();
- let mut call_info = ctry!(CallInfo::new(fn_def));
+ let mut call_info = CallInfo::new(fn_def)?;
// If we have a calling expression let's find which argument we are on
let num_params = call_info.parameters.len();
let has_self = fn_def.param_list().and_then(|l| l.self_param()).is_some();
}
}
- Ok(Some(call_info))
+ Some(call_info)
}
enum FnCallNode<'a> {
-use ra_db::{FileId, Cancelable, SyntaxDatabase};
+use ra_db::{FileId, SyntaxDatabase};
use ra_syntax::{
AstNode, ast,
algo::find_node_at_offset,
pub(crate) fn goto_definition(
db: &RootDatabase,
position: FilePosition,
-) -> Cancelable<Option<RangeInfo<Vec<NavigationTarget>>>> {
+) -> Option<RangeInfo<Vec<NavigationTarget>>> {
let file = db.source_file(position.file_id);
let syntax = file.syntax();
if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
- let navs = reference_definition(db, position.file_id, name_ref)?.to_vec();
- return Ok(Some(RangeInfo::new(
- name_ref.syntax().range(),
- navs.to_vec(),
- )));
+ let navs = reference_definition(db, position.file_id, name_ref).to_vec();
+ return Some(RangeInfo::new(name_ref.syntax().range(), navs.to_vec()));
}
if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
- let navs = ctry!(name_definition(db, position.file_id, name)?);
- return Ok(Some(RangeInfo::new(name.syntax().range(), navs)));
+ let navs = name_definition(db, position.file_id, name)?;
+ return Some(RangeInfo::new(name.syntax().range(), navs));
}
- Ok(None)
+ None
}
pub(crate) enum ReferenceResult {
db: &RootDatabase,
file_id: FileId,
name_ref: &ast::NameRef,
-) -> Cancelable<ReferenceResult> {
+) -> ReferenceResult {
use self::ReferenceResult::*;
if let Some(function) =
hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax())
// First try to resolve the symbol locally
if let Some(entry) = scope.resolve_local_name(name_ref) {
let nav = NavigationTarget::from_scope_entry(file_id, &entry);
- return Ok(Exact(nav));
+ return Exact(nav);
};
// Next check if it is a method
.and_then(|it| infer_result.method_resolution(it))
{
if let Some(target) = NavigationTarget::from_def(db, def_id.resolve(db)) {
- return Ok(Exact(target));
+ return Exact(target);
}
};
}
let resolved = module.resolve_path(db, &path);
if let Some(def_id) = resolved.take_types().or(resolved.take_values()) {
if let Some(target) = NavigationTarget::from_def(db, def_id.resolve(db)) {
- return Ok(Exact(target));
+ return Exact(target);
}
}
}
.into_iter()
.map(NavigationTarget::from_symbol)
.collect();
- Ok(Approximate(navs))
+ Approximate(navs)
}
fn name_definition(
db: &RootDatabase,
file_id: FileId,
name: &ast::Name,
-) -> Cancelable<Option<Vec<NavigationTarget>>> {
+) -> Option<Vec<NavigationTarget>> {
if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
if module.has_semi() {
if let Some(child_module) =
hir::source_binder::module_from_declaration(db, file_id, module)
{
let nav = NavigationTarget::from_module(db, child_module);
- return Ok(Some(vec![nav]));
+ return Some(vec![nav]);
}
}
}
- Ok(None)
+ None
}
#[cfg(test)]
-use ra_db::{Cancelable, SyntaxDatabase};
+use ra_db::{SyntaxDatabase};
use ra_syntax::{
AstNode, SyntaxNode, TreeArc,
ast::self,
use crate::{db::RootDatabase, RangeInfo, FilePosition, FileRange, NavigationTarget};
-pub(crate) fn hover(
- db: &RootDatabase,
- position: FilePosition,
-) -> Cancelable<Option<RangeInfo<String>>> {
+pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<String>> {
let file = db.source_file(position.file_id);
let mut res = Vec::new();
let mut range = None;
if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
use crate::goto_definition::{ReferenceResult::*, reference_definition};
- let ref_result = reference_definition(db, position.file_id, name_ref)?;
+ let ref_result = reference_definition(db, position.file_id, name_ref);
match ref_result {
- Exact(nav) => res.extend(doc_text_for(db, nav)?),
+ Exact(nav) => res.extend(doc_text_for(db, nav)),
Approximate(navs) => {
let mut msg = String::from("Failed to exactly resolve the symbol. This is probably because rust_analyzer does not yet support glob imports or traits.");
if !navs.is_empty() {
}
res.push(msg);
for nav in navs {
- res.extend(doc_text_for(db, nav)?)
+ res.extend(doc_text_for(db, nav))
}
}
}
let node = find_leaf_at_offset(file.syntax(), position.offset).find_map(|leaf| {
leaf.ancestors()
.find(|n| ast::Expr::cast(*n).is_some() || ast::Pat::cast(*n).is_some())
- });
- let node = ctry!(node);
+ })?;
let frange = FileRange {
file_id: position.file_id,
range: node.range(),
};
- res.extend(type_of(db, frange)?.map(Into::into));
+ res.extend(type_of(db, frange).map(Into::into));
range = Some(node.range());
};
- let range = ctry!(range);
+ let range = range?;
if res.is_empty() {
- return Ok(None);
+ return None;
}
let res = RangeInfo::new(range, res.join("\n\n---\n"));
- Ok(Some(res))
+ Some(res)
}
-pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Cancelable<Option<String>> {
+pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
let file = db.source_file(frange.file_id);
let syntax = file.syntax();
let leaf_node = find_covering_node(syntax, frange.range);
.take_while(|it| it.range() == leaf_node.range())
.find(|&it| ast::Expr::cast(it).is_some() || ast::Pat::cast(it).is_some())
.unwrap_or(leaf_node);
- let parent_fn = ctry!(node.ancestors().find_map(ast::FnDef::cast));
- let function = ctry!(hir::source_binder::function_from_source(
- db,
- frange.file_id,
- parent_fn
- ));
+ let parent_fn = node.ancestors().find_map(ast::FnDef::cast)?;
+ let function = hir::source_binder::function_from_source(db, frange.file_id, parent_fn)?;
let infer = function.infer(db);
let syntax_mapping = function.body_syntax_mapping(db);
if let Some(expr) = ast::Expr::cast(node).and_then(|e| syntax_mapping.node_expr(e)) {
- Ok(Some(infer[expr].to_string()))
+ Some(infer[expr].to_string())
} else if let Some(pat) = ast::Pat::cast(node).and_then(|p| syntax_mapping.node_pat(p)) {
- Ok(Some(infer[pat].to_string()))
+ Some(infer[pat].to_string())
} else {
- Ok(None)
+ None
}
}
// FIXME: this should not really use navigation target. Rather, approximatelly
// resovled symbol should return a `DefId`.
-fn doc_text_for(db: &RootDatabase, nav: NavigationTarget) -> Cancelable<Option<String>> {
- let result = match (nav.description(db), nav.docs(db)) {
+fn doc_text_for(db: &RootDatabase, nav: NavigationTarget) -> Option<String> {
+ match (nav.description(db), nav.docs(db)) {
(Some(desc), Some(docs)) => Some("```rust\n".to_string() + &*desc + "\n```\n\n" + &*docs),
(Some(desc), None) => Some("```rust\n".to_string() + &*desc + "\n```"),
(None, Some(docs)) => Some(docs),
_ => None,
- };
-
- Ok(result)
+ }
}
impl NavigationTarget {
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)>,
position: FilePosition,
) -> Cancelable<Option<RangeInfo<Vec<NavigationTarget>>>> {
self.db
- .catch_canceled(|db| goto_definition::goto_definition(db, position))?
+ .catch_canceled(|db| goto_definition::goto_definition(db, position))
}
/// Finds all usages of the reference at point.
/// 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))?
+ .catch_canceled(|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| parent_module::parent_module(db, position))?
+ self.with_db(|db| parent_module::parent_module(db, position))
}
/// Returns crates this file belongs too.
/// 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))?
+ .catch_canceled(|db| runnables::runnables(db, file_id))
}
/// Computes syntax highlighting for the given file.
/// 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
-use ra_db::{Cancelable, FilePosition};
+use ra_db::FilePosition;
use crate::{NavigationTarget, db::RootDatabase};
/// This returns `Vec` because a module may be included from several places. We
/// don't handle this case yet though, so the Vec has length at most one.
-pub(crate) fn parent_module(
- db: &RootDatabase,
- position: FilePosition,
-) -> Cancelable<Vec<NavigationTarget>> {
+pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
let module = match hir::source_binder::module_from_position(db, position) {
- None => return Ok(Vec::new()),
+ None => return Vec::new(),
Some(it) => it,
};
let nav = NavigationTarget::from_module_to_decl(db, module);
- Ok(vec![nav])
+ vec![nav]
}
#[cfg(test)]
TextRange, SyntaxNode,
ast::{self, AstNode, NameOwner, ModuleItemOwner},
};
-use ra_db::{Cancelable, SyntaxDatabase};
+use ra_db::SyntaxDatabase;
use crate::{db::RootDatabase, FileId};
Bin,
}
-pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<Runnable>> {
+pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
let source_file = db.source_file(file_id);
- let res = source_file
+ source_file
.syntax()
.descendants()
.filter_map(|i| runnable(db, file_id, i))
- .collect();
- Ok(res)
+ .collect()
}
fn runnable(db: &RootDatabase, file_id: FileId, item: &SyntaxNode) -> Option<Runnable> {
projects / rust.git / commitdiff