From 7ea4bce1b292d455c313f914b3aa3051293c502b Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Fri, 24 Jan 2020 15:22:00 +0100 Subject: Add impl trait lowering mode --- crates/ra_hir/src/code_model.rs | 14 +++--- crates/ra_hir/src/source_analyzer.rs | 3 +- crates/ra_hir_ty/src/infer.rs | 33 +++++++++--- crates/ra_hir_ty/src/infer/path.rs | 29 +++++++++-- crates/ra_hir_ty/src/lib.rs | 4 +- crates/ra_hir_ty/src/lower.rs | 98 +++++++++++++++++++++++++++++------- 6 files changed, 141 insertions(+), 40 deletions(-) (limited to 'crates') diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index 837a3ed6d..fda31d517 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -733,8 +733,7 @@ impl Local { let ty = infer[self.pat_id].clone(); let resolver = def.resolver(db); let krate = def.module(db).krate; - let ctx = hir_ty::TyLoweringContext { db, resolver: &resolver }; - let environment = TraitEnvironment::lower(&ctx); + let environment = TraitEnvironment::lower(db, &resolver); Type { krate, ty: InEnvironment { value: ty, environment } } } @@ -790,8 +789,12 @@ impl ImplBlock { pub fn target_ty(&self, db: &impl HirDatabase) -> Type { let impl_data = db.impl_data(self.id); let resolver = self.id.resolver(db); - let ctx = hir_ty::TyLoweringContext { db, resolver: &resolver }; - let environment = TraitEnvironment::lower(&ctx); + let ctx = hir_ty::TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: hir_ty::ImplTraitLoweringMode::Disallowed, + }; + let environment = TraitEnvironment::lower(db, &resolver); let ty = Ty::from_hir(&ctx, &impl_data.target_type); Type { krate: self.id.lookup(db).container.module(db).krate, @@ -846,8 +849,7 @@ pub struct Type { impl Type { fn new(db: &impl HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type { let resolver = lexical_env.resolver(db); - let ctx = hir_ty::TyLoweringContext { db, resolver: &resolver }; - let environment = TraitEnvironment::lower(&ctx); + let environment = TraitEnvironment::lower(db, &resolver); Type { krate, ty: InEnvironment { value: ty, environment } } } diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs index 9cfd52856..bb9a35c5d 100644 --- a/crates/ra_hir/src/source_analyzer.rs +++ b/crates/ra_hir/src/source_analyzer.rs @@ -179,8 +179,7 @@ impl SourceAnalyzer { } fn trait_env(&self, db: &impl HirDatabase) -> Arc { - let ctx = hir_ty::TyLoweringContext { db, resolver: &self.resolver }; - TraitEnvironment::lower(&ctx) + TraitEnvironment::lower(db, &self.resolver) } pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option { diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs index e27ce6e91..b4a3e1675 100644 --- a/crates/ra_hir_ty/src/infer.rs +++ b/crates/ra_hir_ty/src/infer.rs @@ -42,7 +42,9 @@ use super::{ ApplicationTy, GenericPredicate, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor, TypeWalk, Uncertain, }; -use crate::{db::HirDatabase, infer::diagnostics::InferenceDiagnostic}; +use crate::{ + db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode, +}; pub(crate) use unify::unify; @@ -215,13 +217,12 @@ struct InferenceContext<'a, D: HirDatabase> { impl<'a, D: HirDatabase> InferenceContext<'a, D> { fn new(db: &'a D, owner: DefWithBodyId, resolver: Resolver) -> Self { - let ctx = crate::lower::TyLoweringContext { db, resolver: &resolver }; InferenceContext { result: InferenceResult::default(), table: unify::InferenceTable::new(), obligations: Vec::default(), return_ty: Ty::Unknown, // set in collect_fn_signature - trait_env: TraitEnvironment::lower(&ctx), + trait_env: TraitEnvironment::lower(db, &resolver), coerce_unsized_map: Self::init_coerce_unsized_map(db, &resolver), db, owner, @@ -272,14 +273,26 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { self.result.diagnostics.push(diagnostic); } - fn make_ty(&mut self, type_ref: &TypeRef) -> Ty { + fn make_ty_with_mode( + &mut self, + type_ref: &TypeRef, + impl_trait_mode: ImplTraitLoweringMode, + ) -> Ty { // FIXME use right resolver for block - let ctx = crate::lower::TyLoweringContext { db: self.db, resolver: &self.resolver }; + let ctx = crate::lower::TyLoweringContext { + db: self.db, + resolver: &self.resolver, + impl_trait_mode, + }; let ty = Ty::from_hir(&ctx, type_ref); let ty = self.insert_type_vars(ty); self.normalize_associated_types_in(ty) } + fn make_ty(&mut self, type_ref: &TypeRef) -> Ty { + self.make_ty_with_mode(type_ref, ImplTraitLoweringMode::Disallowed) + } + /// Replaces `impl Trait` in `ty` by type variables and obligations for /// those variables. This is done for function arguments when calling a /// function, and for return types when inside the function body, i.e. in @@ -444,7 +457,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { None => return (Ty::Unknown, None), }; let resolver = &self.resolver; - let ctx = crate::lower::TyLoweringContext { db: self.db, resolver: &self.resolver }; + let ctx = crate::lower::TyLoweringContext { + db: self.db, + resolver: &self.resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; // FIXME: this should resolve assoc items as well, see this example: // https://play.rust-lang.org/?gist=087992e9e22495446c01c0d4e2d69521 match resolver.resolve_path_in_type_ns_fully(self.db, path.mod_path()) { @@ -471,11 +488,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { fn collect_fn(&mut self, data: &FunctionData) { let body = Arc::clone(&self.body); // avoid borrow checker problem for (type_ref, pat) in data.params.iter().zip(body.params.iter()) { - let ty = self.make_ty(type_ref); + let ty = self.make_ty_with_mode(type_ref, ImplTraitLoweringMode::Opaque); self.infer_pat(*pat, &ty, BindingMode::default()); } - let return_ty = self.make_ty(&data.ret_type); + let return_ty = self.make_ty_with_mode(&data.ret_type, ImplTraitLoweringMode::Placeholder); self.return_ty = self.insert_vars_for_impl_trait(return_ty); } diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs index 132f3d6f2..02fc99288 100644 --- a/crates/ra_hir_ty/src/infer/path.rs +++ b/crates/ra_hir_ty/src/infer/path.rs @@ -9,7 +9,10 @@ use hir_def::{ }; use hir_expand::name::Name; -use crate::{db::HirDatabase, method_resolution, Substs, Ty, TypeWalk, ValueTyDefId}; +use crate::{ + db::HirDatabase, lower::ImplTraitLoweringMode, method_resolution, Substs, Ty, TypeWalk, + ValueTyDefId, +}; use super::{ExprOrPatId, InferenceContext, TraitRef}; @@ -39,7 +42,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { } let ty = self.make_ty(type_ref); let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1); - let ctx = crate::lower::TyLoweringContext { db: self.db, resolver: &resolver }; + let ctx = crate::lower::TyLoweringContext { + db: self.db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let ty = Ty::from_type_relative_path(&ctx, ty, remaining_segments_for_ty); self.resolve_ty_assoc_item( ty, @@ -74,7 +81,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { if let Some(self_subst) = self_subst { ty = ty.subst(&self_subst); } - let ctx = crate::lower::TyLoweringContext { db: self.db, resolver: &self.resolver }; + let ctx = crate::lower::TyLoweringContext { + db: self.db, + resolver: &self.resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let substs = Ty::substs_from_path(&ctx, path, typable); let ty = ty.subst(&substs); Some(ty) @@ -100,7 +111,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { (TypeNs::TraitId(trait_), true) => { let segment = remaining_segments.last().expect("there should be at least one segment here"); - let ctx = crate::lower::TyLoweringContext { db: self.db, resolver: &self.resolver }; + let ctx = crate::lower::TyLoweringContext { + db: self.db, + resolver: &self.resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let trait_ref = TraitRef::from_resolved_path(&ctx, trait_.into(), resolved_segment, None); self.resolve_trait_assoc_item(trait_ref, segment, id) @@ -112,7 +127,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { // as Iterator>::Item::default`) let remaining_segments_for_ty = remaining_segments.take(remaining_segments.len() - 1); - let ctx = crate::lower::TyLoweringContext { db: self.db, resolver: &self.resolver }; + let ctx = crate::lower::TyLoweringContext { + db: self.db, + resolver: &self.resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let ty = Ty::from_partly_resolved_hir_path( &ctx, def, diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs index 6f0e8b481..c64b81f98 100644 --- a/crates/ra_hir_ty/src/lib.rs +++ b/crates/ra_hir_ty/src/lib.rs @@ -60,7 +60,9 @@ use display::{HirDisplay, HirFormatter}; pub use autoderef::autoderef; pub use infer::{do_infer_query, InferTy, InferenceResult}; pub use lower::CallableDef; -pub use lower::{callable_item_sig, TyDefId, TyLoweringContext, ValueTyDefId}; +pub use lower::{ + callable_item_sig, ImplTraitLoweringMode, TyDefId, TyLoweringContext, ValueTyDefId, +}; pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment}; /// A type constructor or type name: this might be something like the primitive diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs index 87c984e3f..3d2421223 100644 --- a/crates/ra_hir_ty/src/lower.rs +++ b/crates/ra_hir_ty/src/lower.rs @@ -35,6 +35,14 @@ use crate::{ pub struct TyLoweringContext<'a, DB: HirDatabase> { pub db: &'a DB, pub resolver: &'a Resolver, + pub impl_trait_mode: ImplTraitLoweringMode, +} + +#[derive(Clone, Debug)] +pub enum ImplTraitLoweringMode { + Opaque, + Placeholder, + Disallowed, } impl Ty { @@ -484,7 +492,11 @@ pub(crate) fn field_types_query( VariantId::EnumVariantId(it) => it.parent.resolver(db), }; let mut res = ArenaMap::default(); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; for (field_id, field_data) in var_data.fields().iter() { res.insert(field_id, Ty::from_hir(&ctx, &field_data.type_ref)) } @@ -505,7 +517,11 @@ pub(crate) fn generic_predicates_for_param_query( param_idx: u32, ) -> Arc<[GenericPredicate]> { let resolver = def.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; resolver .where_predicates_in_scope() // we have to filter out all other predicates *first*, before attempting to lower them @@ -524,11 +540,12 @@ pub(crate) fn generic_predicates_for_param_recover( } impl TraitEnvironment { - pub fn lower(ctx: &TyLoweringContext<'_, impl HirDatabase>) -> Arc { - let predicates = ctx - .resolver + pub fn lower(db: &impl HirDatabase, resolver: &Resolver) -> Arc { + let ctx = + TyLoweringContext { db, resolver, impl_trait_mode: ImplTraitLoweringMode::Disallowed }; + let predicates = resolver .where_predicates_in_scope() - .flat_map(|pred| GenericPredicate::from_where_predicate(ctx, pred)) + .flat_map(|pred| GenericPredicate::from_where_predicate(&ctx, pred)) .collect::>(); Arc::new(TraitEnvironment { predicates }) @@ -541,7 +558,11 @@ pub(crate) fn generic_predicates_query( def: GenericDefId, ) -> Arc<[GenericPredicate]> { let resolver = def.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; resolver .where_predicates_in_scope() .flat_map(|pred| GenericPredicate::from_where_predicate(&ctx, pred)) @@ -551,7 +572,11 @@ pub(crate) fn generic_predicates_query( /// Resolve the default type params from generics pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDefId) -> Substs { let resolver = def.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let generic_params = generics(db, def.into()); let defaults = generic_params @@ -565,9 +590,18 @@ pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDefId) - fn fn_sig_for_fn(db: &impl HirDatabase, def: FunctionId) -> FnSig { let data = db.function_data(def); let resolver = def.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; - let params = data.params.iter().map(|tr| Ty::from_hir(&ctx, tr)).collect::>(); - let ret = Ty::from_hir(&ctx, &data.ret_type); + let ctx_params = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Placeholder, + }; + let params = data.params.iter().map(|tr| Ty::from_hir(&ctx_params, tr)).collect::>(); + let ctx_ret = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Opaque, + }; + let ret = Ty::from_hir(&ctx_ret, &data.ret_type); FnSig::from_params_and_return(params, ret) } @@ -583,7 +617,11 @@ fn type_for_fn(db: &impl HirDatabase, def: FunctionId) -> Ty { fn type_for_const(db: &impl HirDatabase, def: ConstId) -> Ty { let data = db.const_data(def); let resolver = def.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; Ty::from_hir(&ctx, &data.type_ref) } @@ -592,7 +630,11 @@ fn type_for_const(db: &impl HirDatabase, def: ConstId) -> Ty { fn type_for_static(db: &impl HirDatabase, def: StaticId) -> Ty { let data = db.static_data(def); let resolver = def.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; Ty::from_hir(&ctx, &data.type_ref) } @@ -612,7 +654,11 @@ fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> FnSig let struct_data = db.struct_data(def.into()); let fields = struct_data.variant_data.fields(); let resolver = def.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let params = fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::>(); let ret = type_for_adt(db, def.into()); @@ -635,7 +681,11 @@ fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId let var_data = &enum_data.variants[def.local_id]; let fields = var_data.variant_data.fields(); let resolver = def.parent.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let params = fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::>(); let generics = generics(db, def.parent.into()); @@ -664,7 +714,11 @@ fn type_for_adt(db: &impl HirDatabase, adt: AdtId) -> Ty { fn type_for_type_alias(db: &impl HirDatabase, t: TypeAliasId) -> Ty { let generics = generics(db, t.into()); let resolver = t.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let type_ref = &db.type_alias_data(t).type_ref; let substs = Substs::identity(&generics); let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error)); @@ -747,7 +801,11 @@ pub(crate) fn value_ty_query(db: &impl HirDatabase, def: ValueTyDefId) -> Ty { pub(crate) fn impl_self_ty_query(db: &impl HirDatabase, impl_id: ImplId) -> Ty { let impl_data = db.impl_data(impl_id); let resolver = impl_id.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; Ty::from_hir(&ctx, &impl_data.target_type) } @@ -762,7 +820,11 @@ pub(crate) fn impl_self_ty_recover( pub(crate) fn impl_trait_query(db: &impl HirDatabase, impl_id: ImplId) -> Option { let impl_data = db.impl_data(impl_id); let resolver = impl_id.resolver(db); - let ctx = TyLoweringContext { db, resolver: &resolver }; + let ctx = TyLoweringContext { + db, + resolver: &resolver, + impl_trait_mode: ImplTraitLoweringMode::Disallowed, + }; let self_ty = db.impl_self_ty(impl_id); let target_trait = impl_data.target_trait.as_ref()?; TraitRef::from_hir(&ctx, target_trait, Some(self_ty.clone())) -- cgit v1.2.3