From b871062e329301683083a1a2ff5eb476e6c397c7 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 15 Jan 2019 20:43:37 +0300 Subject: remove Cancelable from Ty --- crates/ra_hir/src/adt.rs | 5 +- crates/ra_hir/src/code_model_api.rs | 2 +- crates/ra_hir/src/db.rs | 4 +- crates/ra_hir/src/ty.rs | 108 ++++++++++------------- crates/ra_hir/src/ty/method_resolution.rs | 2 +- crates/ra_ide_api/src/completion/complete_dot.rs | 7 +- 6 files changed, 57 insertions(+), 71 deletions(-) diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs index 57d112f74..d87fe7049 100644 --- a/crates/ra_hir/src/adt.rs +++ b/crates/ra_hir/src/adt.rs @@ -1,6 +1,5 @@ use std::sync::Arc; -use ra_db::Cancelable; use ra_syntax::{ SyntaxNode, ast::{self, NameOwner, StructFlavor, AstNode} @@ -18,8 +17,8 @@ impl Struct { Struct { def_id } } - pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Cancelable> { - Ok(db.struct_data(self.def_id).variant_data.clone()) + pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Arc { + db.struct_data(self.def_id).variant_data.clone() } } diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 7ccd29e2f..d0c455d0a 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -160,7 +160,7 @@ impl StructField { pub fn name(&self) -> &Name { &self.name } - pub fn ty(&self, db: &impl HirDatabase) -> Cancelable> { + pub fn ty(&self, db: &impl HirDatabase) -> Option { db.type_for_field(self.struct_.def_id, self.name.clone()) } } diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 161a5e714..4a2b0b3dc 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -57,12 +57,12 @@ pub trait HirDatabase: SyntaxDatabase use fn crate::ty::infer; } - fn type_for_def(def_id: DefId) -> Cancelable { + fn type_for_def(def_id: DefId) -> Ty { type TypeForDefQuery; use fn crate::ty::type_for_def; } - fn type_for_field(def_id: DefId, field: Name) -> Cancelable> { + fn type_for_field(def_id: DefId, field: Name) -> Option { type TypeForFieldQuery; use fn crate::ty::type_for_field; } diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index e5f8ffc2e..37fc8643a 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -271,28 +271,28 @@ impl Ty { module: &Module, impl_block: Option<&ImplBlock>, type_ref: &TypeRef, - ) -> Cancelable { - Ok(match type_ref { + ) -> Self { + match type_ref { TypeRef::Never => Ty::Never, TypeRef::Tuple(inner) => { let inner_tys = inner .iter() .map(|tr| Ty::from_hir(db, module, impl_block, tr)) - .collect::>>()?; + .collect::>(); Ty::Tuple(inner_tys.into()) } - TypeRef::Path(path) => Ty::from_hir_path(db, module, impl_block, path)?, + TypeRef::Path(path) => Ty::from_hir_path(db, module, impl_block, path), TypeRef::RawPtr(inner, mutability) => { - let inner_ty = Ty::from_hir(db, module, impl_block, inner)?; + let inner_ty = Ty::from_hir(db, module, impl_block, inner); Ty::RawPtr(Arc::new(inner_ty), *mutability) } TypeRef::Array(_inner) => Ty::Unknown, // TODO TypeRef::Slice(inner) => { - let inner_ty = Ty::from_hir(db, module, impl_block, inner)?; + let inner_ty = Ty::from_hir(db, module, impl_block, inner); Ty::Slice(Arc::new(inner_ty)) } TypeRef::Reference(inner, mutability) => { - let inner_ty = Ty::from_hir(db, module, impl_block, inner)?; + let inner_ty = Ty::from_hir(db, module, impl_block, inner); Ty::Ref(Arc::new(inner_ty), *mutability) } TypeRef::Placeholder => Ty::Unknown, @@ -300,7 +300,7 @@ impl Ty { let mut inner_tys = params .iter() .map(|tr| Ty::from_hir(db, module, impl_block, tr)) - .collect::>>()?; + .collect::>(); let return_ty = inner_tys .pop() .expect("TypeRef::Fn should always have at least return type"); @@ -311,7 +311,7 @@ impl Ty { Ty::FnPtr(Arc::new(sig)) } TypeRef::Error => Ty::Unknown, - }) + } } pub(crate) fn from_hir_opt( @@ -319,10 +319,8 @@ impl Ty { module: &Module, impl_block: Option<&ImplBlock>, type_ref: Option<&TypeRef>, - ) -> Cancelable { - type_ref - .map(|t| Ty::from_hir(db, module, impl_block, t)) - .unwrap_or(Ok(Ty::Unknown)) + ) -> Self { + type_ref.map_or(Ty::Unknown, |t| Ty::from_hir(db, module, impl_block, t)) } pub(crate) fn from_hir_path( @@ -330,19 +328,19 @@ impl Ty { module: &Module, impl_block: Option<&ImplBlock>, path: &Path, - ) -> Cancelable { + ) -> Self { if let Some(name) = path.as_ident() { if let Some(int_ty) = primitive::UncertainIntTy::from_name(name) { - return Ok(Ty::Int(int_ty)); + return Ty::Int(int_ty); } else if let Some(float_ty) = primitive::UncertainFloatTy::from_name(name) { - return Ok(Ty::Float(float_ty)); + return Ty::Float(float_ty); } else if name.as_known_name() == Some(KnownName::SelfType) { return Ty::from_hir_opt(db, module, None, impl_block.map(|i| i.target_type())); } else if let Some(known) = name.as_known_name() { match known { - KnownName::Bool => return Ok(Ty::Bool), - KnownName::Char => return Ok(Ty::Char), - KnownName::Str => return Ok(Ty::Str), + KnownName::Bool => return Ty::Bool, + KnownName::Char => return Ty::Char, + KnownName::Str => return Ty::Str, _ => {} } } @@ -352,10 +350,9 @@ impl Ty { let resolved = if let Some(r) = module.resolve_path(db, path).take_types() { r } else { - return Ok(Ty::Unknown); + return Ty::Unknown; }; - let ty = db.type_for_def(resolved)?; - Ok(ty) + db.type_for_def(resolved) } pub fn unit() -> Self { @@ -445,7 +442,7 @@ impl fmt::Display for Ty { /// Compute the declared type of a function. This should not need to look at the /// function body. -fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable { +fn type_for_fn(db: &impl HirDatabase, f: Function) -> Ty { let signature = f.signature(db); let module = f.module(db); let impl_block = f.impl_block(db); @@ -454,38 +451,38 @@ fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable { .params() .iter() .map(|tr| Ty::from_hir(db, &module, impl_block.as_ref(), tr)) - .collect::>>()?; - let output = Ty::from_hir(db, &module, impl_block.as_ref(), signature.ret_type())?; + .collect::>(); + let output = Ty::from_hir(db, &module, impl_block.as_ref(), signature.ret_type()); let sig = FnSig { input, output }; - Ok(Ty::FnPtr(Arc::new(sig))) + Ty::FnPtr(Arc::new(sig)) } -fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Cancelable { - Ok(Ty::Adt { +fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { + Ty::Adt { def_id: s.def_id(), name: s.name(db).unwrap_or_else(Name::missing), - }) + } } -pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Cancelable { - Ok(Ty::Adt { +pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty { + Ty::Adt { def_id: s.def_id(), name: s.name(db).unwrap_or_else(Name::missing), - }) + } } -pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> Cancelable { +pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> Ty { let enum_parent = ev.parent_enum(db); type_for_enum(db, enum_parent) } -pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable { +pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Ty { let def = def_id.resolve(db); match def { Def::Module(..) => { log::debug!("trying to get type for module {:?}", def_id); - Ok(Ty::Unknown) + Ty::Unknown } Def::Function(f) => type_for_fn(db, f), Def::Struct(s) => type_for_struct(db, s), @@ -497,19 +494,15 @@ pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable Cancelable> { +pub(super) fn type_for_field(db: &impl HirDatabase, def_id: DefId, field: Name) -> Option { let def = def_id.resolve(db); let variant_data = match def { - Def::Struct(s) => s.variant_data(db)?, + Def::Struct(s) => s.variant_data(db), Def::EnumVariant(ev) => ev.variant_data(db), // TODO: unions _ => panic!( @@ -519,13 +512,8 @@ pub(super) fn type_for_field( }; let module = def_id.module(db); let impl_block = def_id.impl_block(db); - let type_ref = ctry!(variant_data.get_field_type_ref(&field)); - Ok(Some(Ty::from_hir( - db, - &module, - impl_block.as_ref(), - &type_ref, - )?)) + let type_ref = variant_data.get_field_type_ref(&field)?; + Some(Ty::from_hir(db, &module, impl_block.as_ref(), &type_ref)) } /// The result of type inference: A mapping from expressions and patterns to types. @@ -702,7 +690,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { self.type_of_pat.insert(pat, ty); } - fn make_ty(&self, type_ref: &TypeRef) -> Cancelable { + fn make_ty(&self, type_ref: &TypeRef) -> Ty { Ty::from_hir(self.db, &self.module, self.impl_block.as_ref(), type_ref) } @@ -861,7 +849,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { // resolve in module let resolved = ctry!(self.module.resolve_path(self.db, &path).take_values()); - let ty = self.db.type_for_def(resolved)?; + let ty = self.db.type_for_def(resolved); let ty = self.insert_type_vars(ty); Ok(Some(ty)) } @@ -879,11 +867,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { }; Ok(match def_id.resolve(self.db) { Def::Struct(s) => { - let ty = type_for_struct(self.db, s)?; + let ty = type_for_struct(self.db, s); (ty, Some(def_id)) } Def::EnumVariant(ev) => { - let ty = type_for_enum_variant(self.db, ev)?; + let ty = type_for_enum_variant(self.db, ev); (ty, Some(def_id)) } _ => (Ty::Unknown, None), @@ -964,7 +952,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let method_ty = match resolved { Some(def_id) => { self.write_method_resolution(expr, def_id); - self.db.type_for_def(def_id)? + self.db.type_for_def(def_id) } None => Ty::Unknown, }; @@ -1024,7 +1012,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { for field in fields { let field_ty = if let Some(def_id) = def_id { self.db - .type_for_field(def_id, field.name.clone())? + .type_for_field(def_id, field.name.clone()) .unwrap_or(Ty::Unknown) } else { Ty::Unknown @@ -1047,7 +1035,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { i.and_then(|i| fields.get(i).cloned()).map(Ok) } Ty::Adt { def_id, .. } => { - transpose(self.db.type_for_field(def_id, name.clone())) + transpose(Ok(self.db.type_for_field(def_id, name.clone()))) } _ => None, }) @@ -1061,7 +1049,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { Expr::Cast { expr, type_ref } => { let _inner_ty = self.infer_expr(*expr, &Expectation::none())?; let cast_ty = - Ty::from_hir(self.db, &self.module, self.impl_block.as_ref(), type_ref)?; + Ty::from_hir(self.db, &self.module, self.impl_block.as_ref(), type_ref); let cast_ty = self.insert_type_vars(cast_ty); // TODO check the cast... cast_ty @@ -1154,7 +1142,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { &self.module, self.impl_block.as_ref(), type_ref.as_ref(), - )?; + ); let decl_ty = self.insert_type_vars(decl_ty); let ty = if let Some(expr) = initializer { let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty))?; @@ -1181,12 +1169,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { fn collect_fn_signature(&mut self, signature: &FnSignature) -> Cancelable<()> { let body = Arc::clone(&self.body); // avoid borrow checker problem for (type_ref, pat) in signature.params().iter().zip(body.params()) { - let ty = self.make_ty(type_ref)?; + let ty = self.make_ty(type_ref); let ty = self.insert_type_vars(ty); self.write_pat_ty(*pat, ty); } self.return_ty = { - let ty = self.make_ty(signature.ret_type())?; + let ty = self.make_ty(signature.ret_type()); let ty = self.insert_type_vars(ty); ty }; diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs index 94c5124a9..0676a989d 100644 --- a/crates/ra_hir/src/ty/method_resolution.rs +++ b/crates/ra_hir/src/ty/method_resolution.rs @@ -65,7 +65,7 @@ impl CrateImplBlocks { // ignore for now } else { let target_ty = - Ty::from_hir(db, &module, Some(&impl_block), impl_data.target_type())?; + Ty::from_hir(db, &module, Some(&impl_block), impl_data.target_type()); if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) { self.impls .entry(target_ty_fp) diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs index cb86ba9a3..30a0a3924 100644 --- a/crates/ra_ide_api/src/completion/complete_dot.rs +++ b/crates/ra_ide_api/src/completion/complete_dot.rs @@ -17,13 +17,13 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) -> Ca }; let receiver_ty = infer_result[expr].clone(); if !ctx.is_call { - complete_fields(acc, ctx, receiver_ty.clone())?; + complete_fields(acc, ctx, receiver_ty.clone()); } complete_methods(acc, ctx, receiver_ty)?; Ok(()) } -fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) -> Cancelable<()> { +fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) { for receiver in receiver.autoderef(ctx.db) { match receiver { Ty::Adt { def_id, .. } => { @@ -35,7 +35,7 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) field.name().to_string(), ) .kind(CompletionItemKind::Field) - .set_detail(field.ty(ctx.db)?.map(|ty| ty.to_string())) + .set_detail(field.ty(ctx.db).map(|ty| ty.to_string())) .add_to(acc); } } @@ -53,7 +53,6 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) _ => {} }; } - Ok(()) } fn complete_methods( -- cgit v1.2.3