language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-02 14:51:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

remove Cancelable from Ty

Browse source
This commit is contained in:
Aleksey Kladov 2019-01-15 20:43:37 +03:00
parent 05ed6c548a
commit b871062e32
6 changed files with 57 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

5
crates/ra_hir/src/adt.rs
View file

@ -1,6 +1,5 @@
use std::sync::Arc; use std::sync::Arc;
use ra_db::Cancelable;
use ra_syntax::{ use ra_syntax::{
SyntaxNode, SyntaxNode,
ast::{self, NameOwner, StructFlavor, AstNode} ast::{self, NameOwner, StructFlavor, AstNode}
@ -18,8 +17,8 @@ impl Struct {
Struct { def_id } Struct { def_id }
} }
pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Cancelable<Arc<VariantData>> { pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Arc<VariantData> {
Ok(db.struct_data(self.def_id).variant_data.clone()) db.struct_data(self.def_id).variant_data.clone()
} }
} }

2
crates/ra_hir/src/code_model_api.rs
View file

@ -160,7 +160,7 @@ impl StructField {
pub fn name(&self) -> &Name { pub fn name(&self) -> &Name {
&self.name &self.name
} }
pub fn ty(&self, db: &impl HirDatabase) -> Cancelable<Option<Ty>> { pub fn ty(&self, db: &impl HirDatabase) -> Option<Ty> {
db.type_for_field(self.struct_.def_id, self.name.clone()) db.type_for_field(self.struct_.def_id, self.name.clone())
} }
} }

4
crates/ra_hir/src/db.rs
View file

@ -57,12 +57,12 @@ pub trait HirDatabase: SyntaxDatabase
use fn crate::ty::infer; use fn crate::ty::infer;
} }
fn type_for_def(def_id: DefId) -> Cancelable<Ty> { fn type_for_def(def_id: DefId) -> Ty {
type TypeForDefQuery; type TypeForDefQuery;
use fn crate::ty::type_for_def; use fn crate::ty::type_for_def;
} }
fn type_for_field(def_id: DefId, field: Name) -> Cancelable<Option<Ty>> { fn type_for_field(def_id: DefId, field: Name) -> Option<Ty> {
type TypeForFieldQuery; type TypeForFieldQuery;
use fn crate::ty::type_for_field; use fn crate::ty::type_for_field;
} }

108
crates/ra_hir/src/ty.rs
View file

@ -271,28 +271,28 @@ impl Ty {
module: &Module, module: &Module,
impl_block: Option<&ImplBlock>, impl_block: Option<&ImplBlock>,
type_ref: &TypeRef, type_ref: &TypeRef,
) -> Cancelable<Self> { ) -> Self {
Ok(match type_ref { match type_ref {
TypeRef::Never => Ty::Never, TypeRef::Never => Ty::Never,
TypeRef::Tuple(inner) => { TypeRef::Tuple(inner) => {
let inner_tys = inner let inner_tys = inner
.iter() .iter()
.map(|tr| Ty::from_hir(db, module, impl_block, tr)) .map(|tr| Ty::from_hir(db, module, impl_block, tr))
.collect::<Cancelable<Vec<_>>>()?; .collect::<Vec<_>>();
Ty::Tuple(inner_tys.into()) 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) => { 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) Ty::RawPtr(Arc::new(inner_ty), *mutability)
} }
TypeRef::Array(_inner) => Ty::Unknown, // TODO TypeRef::Array(_inner) => Ty::Unknown, // TODO
TypeRef::Slice(inner) => { 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)) Ty::Slice(Arc::new(inner_ty))
} }
TypeRef::Reference(inner, mutability) => { 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) Ty::Ref(Arc::new(inner_ty), *mutability)
} }
TypeRef::Placeholder => Ty::Unknown, TypeRef::Placeholder => Ty::Unknown,
@ -300,7 +300,7 @@ impl Ty {
let mut inner_tys = params let mut inner_tys = params
.iter() .iter()
.map(|tr| Ty::from_hir(db, module, impl_block, tr)) .map(|tr| Ty::from_hir(db, module, impl_block, tr))
.collect::<Cancelable<Vec<_>>>()?; .collect::<Vec<_>>();
let return_ty = inner_tys let return_ty = inner_tys
.pop() .pop()
.expect("TypeRef::Fn should always have at least return type"); .expect("TypeRef::Fn should always have at least return type");
@ -311,7 +311,7 @@ impl Ty {
Ty::FnPtr(Arc::new(sig)) Ty::FnPtr(Arc::new(sig))
} }
TypeRef::Error => Ty::Unknown, TypeRef::Error => Ty::Unknown,
}) }
} }
pub(crate) fn from_hir_opt( pub(crate) fn from_hir_opt(
@ -319,10 +319,8 @@ impl Ty {
module: &Module, module: &Module,
impl_block: Option<&ImplBlock>, impl_block: Option<&ImplBlock>,
type_ref: Option<&TypeRef>, type_ref: Option<&TypeRef>,
) -> Cancelable<Self> { ) -> Self {
type_ref type_ref.map_or(Ty::Unknown, |t| Ty::from_hir(db, module, impl_block, t))
.map(|t| Ty::from_hir(db, module, impl_block, t))
.unwrap_or(Ok(Ty::Unknown))
} }
pub(crate) fn from_hir_path( pub(crate) fn from_hir_path(
@ -330,19 +328,19 @@ impl Ty {
module: &Module, module: &Module,
impl_block: Option<&ImplBlock>, impl_block: Option<&ImplBlock>,
path: &Path, path: &Path,
) -> Cancelable<Self> { ) -> Self {
if let Some(name) = path.as_ident() { if let Some(name) = path.as_ident() {
if let Some(int_ty) = primitive::UncertainIntTy::from_name(name) { 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) { } 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) { } else if name.as_known_name() == Some(KnownName::SelfType) {
return Ty::from_hir_opt(db, module, None, impl_block.map(|i| i.target_type())); return Ty::from_hir_opt(db, module, None, impl_block.map(|i| i.target_type()));
} else if let Some(known) = name.as_known_name() { } else if let Some(known) = name.as_known_name() {
match known { match known {
KnownName::Bool => return Ok(Ty::Bool), KnownName::Bool => return Ty::Bool,
KnownName::Char => return Ok(Ty::Char), KnownName::Char => return Ty::Char,
KnownName::Str => return Ok(Ty::Str), KnownName::Str => return Ty::Str,
_ => {} _ => {}
} }
} }
@ -352,10 +350,9 @@ impl Ty {
let resolved = if let Some(r) = module.resolve_path(db, path).take_types() { let resolved = if let Some(r) = module.resolve_path(db, path).take_types() {
r r
} else { } else {
return Ok(Ty::Unknown); return Ty::Unknown;
}; };
let ty = db.type_for_def(resolved)?; db.type_for_def(resolved)
Ok(ty)
} }
pub fn unit() -> Self { 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 /// Compute the declared type of a function. This should not need to look at the
/// function body. /// function body.
fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> { fn type_for_fn(db: &impl HirDatabase, f: Function) -> Ty {
let signature = f.signature(db); let signature = f.signature(db);
let module = f.module(db); let module = f.module(db);
let impl_block = f.impl_block(db); let impl_block = f.impl_block(db);
@ -454,38 +451,38 @@ fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
.params() .params()
.iter() .iter()
.map(|tr| Ty::from_hir(db, &module, impl_block.as_ref(), tr)) .map(|tr| Ty::from_hir(db, &module, impl_block.as_ref(), tr))
.collect::<Cancelable<Vec<_>>>()?; .collect::<Vec<_>>();
let output = Ty::from_hir(db, &module, impl_block.as_ref(), signature.ret_type())?; let output = Ty::from_hir(db, &module, impl_block.as_ref(), signature.ret_type());
let sig = FnSig { input, output }; 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<Ty> { fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
Ok(Ty::Adt { Ty::Adt {
def_id: s.def_id(), def_id: s.def_id(),
name: s.name(db).unwrap_or_else(Name::missing), name: s.name(db).unwrap_or_else(Name::missing),
}) }
} }
pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Cancelable<Ty> { pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
Ok(Ty::Adt { Ty::Adt {
def_id: s.def_id(), def_id: s.def_id(),
name: s.name(db).unwrap_or_else(Name::missing), name: s.name(db).unwrap_or_else(Name::missing),
}) }
} }
pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> Cancelable<Ty> { pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> Ty {
let enum_parent = ev.parent_enum(db); let enum_parent = ev.parent_enum(db);
type_for_enum(db, enum_parent) type_for_enum(db, enum_parent)
} }
pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ty> { pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Ty {
let def = def_id.resolve(db); let def = def_id.resolve(db);
match def { match def {
Def::Module(..) => { Def::Module(..) => {
log::debug!("trying to get type for module {:?}", def_id); log::debug!("trying to get type for module {:?}", def_id);
Ok(Ty::Unknown) Ty::Unknown
} }
Def::Function(f) => type_for_fn(db, f), Def::Function(f) => type_for_fn(db, f),
Def::Struct(s) => type_for_struct(db, s), 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<T
def_id, def_id,
def def
); );
Ok(Ty::Unknown) Ty::Unknown
} }
} }
} }
pub(super) fn type_for_field( pub(super) fn type_for_field(db: &impl HirDatabase, def_id: DefId, field: Name) -> Option<Ty> {
db: &impl HirDatabase,
def_id: DefId,
field: Name,
) -> Cancelable<Option<Ty>> {
let def = def_id.resolve(db); let def = def_id.resolve(db);
let variant_data = match def { 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), Def::EnumVariant(ev) => ev.variant_data(db),
// TODO: unions // TODO: unions
_ => panic!( _ => panic!(
@ -519,13 +512,8 @@ pub(super) fn type_for_field(
}; };
let module = def_id.module(db); let module = def_id.module(db);
let impl_block = def_id.impl_block(db); let impl_block = def_id.impl_block(db);
let type_ref = ctry!(variant_data.get_field_type_ref(&field)); let type_ref = variant_data.get_field_type_ref(&field)?;
Ok(Some(Ty::from_hir( Some(Ty::from_hir(db, &module, impl_block.as_ref(), &type_ref))
db,
&module,
impl_block.as_ref(),
&type_ref,
)?))
} }
/// The result of type inference: A mapping from expressions and patterns to types. /// 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); self.type_of_pat.insert(pat, ty);
} }
fn make_ty(&self, type_ref: &TypeRef) -> Cancelable<Ty> { fn make_ty(&self, type_ref: &TypeRef) -> 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)
} }
@ -861,7 +849,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
// resolve in module // resolve in module
let resolved = ctry!(self.module.resolve_path(self.db, &path).take_values()); 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); let ty = self.insert_type_vars(ty);
Ok(Some(ty)) Ok(Some(ty))
} }
@ -879,11 +867,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
}; };
Ok(match def_id.resolve(self.db) { Ok(match def_id.resolve(self.db) {
Def::Struct(s) => { Def::Struct(s) => {
let ty = type_for_struct(self.db, s)?; let ty = type_for_struct(self.db, s);
(ty, Some(def_id)) (ty, Some(def_id))
} }
Def::EnumVariant(ev) => { 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, Some(def_id))
} }
_ => (Ty::Unknown, None), _ => (Ty::Unknown, None),
@ -964,7 +952,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
let method_ty = match resolved { let method_ty = match resolved {
Some(def_id) => { Some(def_id) => {
self.write_method_resolution(expr, 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, None => Ty::Unknown,
}; };
@ -1024,7 +1012,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
for field in fields { for field in fields {
let field_ty = if let Some(def_id) = def_id { let field_ty = if let Some(def_id) = def_id {
self.db self.db
.type_for_field(def_id, field.name.clone())? .type_for_field(def_id, field.name.clone())
.unwrap_or(Ty::Unknown) .unwrap_or(Ty::Unknown)
} else { } else {
Ty::Unknown Ty::Unknown
@ -1047,7 +1035,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
i.and_then(|i| fields.get(i).cloned()).map(Ok) i.and_then(|i| fields.get(i).cloned()).map(Ok)
} }
Ty::Adt { def_id, .. } => { 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, _ => None,
}) })
@ -1061,7 +1049,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
Expr::Cast { expr, type_ref } => { Expr::Cast { expr, type_ref } => {
let _inner_ty = self.infer_expr(*expr, &Expectation::none())?; let _inner_ty = self.infer_expr(*expr, &Expectation::none())?;
let cast_ty = 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); let cast_ty = self.insert_type_vars(cast_ty);
// TODO check the cast... // TODO check the cast...
cast_ty cast_ty
@ -1154,7 +1142,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
&self.module, &self.module,
self.impl_block.as_ref(), self.impl_block.as_ref(),
type_ref.as_ref(), type_ref.as_ref(),
)?; );
let decl_ty = self.insert_type_vars(decl_ty); let decl_ty = self.insert_type_vars(decl_ty);
let ty = if let Some(expr) = initializer { let ty = if let Some(expr) = initializer {
let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty))?; 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<()> { fn collect_fn_signature(&mut self, signature: &FnSignature) -> Cancelable<()> {
let body = Arc::clone(&self.body); // avoid borrow checker problem let body = Arc::clone(&self.body); // avoid borrow checker problem
for (type_ref, pat) in signature.params().iter().zip(body.params()) { 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); let ty = self.insert_type_vars(ty);
self.write_pat_ty(*pat, ty); self.write_pat_ty(*pat, ty);
} }
self.return_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); let ty = self.insert_type_vars(ty);
ty ty
}; };

2
crates/ra_hir/src/ty/method_resolution.rs
View file

@ -65,7 +65,7 @@ impl CrateImplBlocks {
// ignore for now // ignore for now
} else { } else {
let target_ty = 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) { if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
self.impls self.impls
.entry(target_ty_fp) .entry(target_ty_fp)

7
crates/ra_ide_api/src/completion/complete_dot.rs
View file

@ -17,13 +17,13 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) -> Ca
}; };
let receiver_ty = infer_result[expr].clone(); let receiver_ty = infer_result[expr].clone();
if !ctx.is_call { if !ctx.is_call {
complete_fields(acc, ctx, receiver_ty.clone())?; complete_fields(acc, ctx, receiver_ty.clone());
} }
complete_methods(acc, ctx, receiver_ty)?; complete_methods(acc, ctx, receiver_ty)?;
Ok(()) 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) { for receiver in receiver.autoderef(ctx.db) {
match receiver { match receiver {
Ty::Adt { def_id, .. } => { Ty::Adt { def_id, .. } => {
@ -35,7 +35,7 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty)
field.name().to_string(), field.name().to_string(),
) )
.kind(CompletionItemKind::Field) .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); .add_to(acc);
} }
} }
@ -53,7 +53,6 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty)
_ => {} _ => {}
}; };
} }
Ok(())
} }
fn complete_methods( fn complete_methods(