db.body_syntax_mapping(self.def_id)
}
- pub fn scopes(&self, db: &impl HirDatabase) -> Cancelable<ScopesWithSyntaxMapping> {
- let scopes = db.fn_scopes(self.def_id)?;
+ pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSyntaxMapping {
+ let scopes = db.fn_scopes(self.def_id);
let syntax_mapping = db.body_syntax_mapping(self.def_id);
- Ok(ScopesWithSyntaxMapping {
+ ScopesWithSyntaxMapping {
scopes,
syntax_mapping,
- })
+ }
}
pub fn signature(&self, db: &impl HirDatabase) -> Arc<FnSignature> {
use fn crate::macros::expand_macro_invocation;
}
- fn fn_scopes(def_id: DefId) -> Cancelable<Arc<FnScopes>> {
+ fn fn_scopes(def_id: DefId) -> Arc<FnScopes> {
type FnScopesQuery;
use fn query_definitions::fn_scopes;
}
nameres::{InputModuleItems, ItemMap, Resolver},
};
-pub(super) fn fn_scopes(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<FnScopes>> {
+pub(super) fn fn_scopes(db: &impl HirDatabase, def_id: DefId) -> Arc<FnScopes> {
let body = db.body_hir(def_id);
let res = FnScopes::new(body);
- Ok(Arc::new(res))
+ Arc::new(res)
}
pub(super) fn file_items(db: &impl HirDatabase, file_id: HirFileId) -> Arc<SourceFileItems> {
db.check_canceled();
let function = Function::new(def_id); // TODO: consts also need inference
let body = function.body(db);
- let scopes = db.fn_scopes(def_id)?;
+ let scopes = db.fn_scopes(def_id);
let module = function.module(db)?;
let impl_block = function.impl_block(db)?;
let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block);
{
let func = source_binder::function_from_source(&db, file_id, fn_def).unwrap();
let inference_result = func.infer(&db).unwrap();
- let body_syntax_mapping = func.body_syntax_mapping(&db).unwrap();
+ let body_syntax_mapping = func.body_syntax_mapping(&db);
let mut types = Vec::new();
for (pat, ty) in inference_result.type_of_pat.iter() {
let syntax_ptr = match body_syntax_mapping.pat_syntax(pat) {
None => return Ok(()),
};
if let Some(function) = &ctx.function {
- let scopes = function.scopes(ctx.db)?;
+ let scopes = function.scopes(ctx.db);
complete_fn(acc, &scopes, ctx.offset);
}
if let Some(function) =
hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax())
{
- let scope = function.scopes(db)?;
+ let scope = function.scopes(db);
// 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);
.collect::<Vec<_>>();
ret.extend(
descr
- .scopes(self)?
+ .scopes(self)
.find_all_refs(binding)
.into_iter()
.map(|ref_desc| (position.file_id, ref_desc.range)),
position.file_id,
name_ref.syntax(),
));
- let scope = descr.scopes(db)?;
+ let scope = descr.scopes(db);
let resolved = ctry!(scope.resolve_local_name(name_ref));
let resolved = resolved.ptr().resolve(source_file);
let binding = ctry!(find_node_at_offset::<ast::BindPat>(