From 7ea4bce1b292d455c313f914b3aa3051293c502b Mon Sep 17 00:00:00 2001
From: Florian Diebold <florian.diebold@freiheit.com>
Date: Fri, 24 Jan 2020 15:22:00 +0100
Subject: Add impl trait lowering mode
---
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 +++++++++++++++++++++++++++++++-------
4 files changed, 132 insertions(+), 32 deletions(-)
(limited to 'crates/ra_hir_ty')
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<TraitEnvironment> {
- let predicates = ctx
- .resolver
+ pub fn lower(db: &impl HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> {
+ 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::<Vec<_>>();
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::<Vec<_>>();
- 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::<Vec<_>>();
+ 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::<Vec<_>>();
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::<Vec<_>>();
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<TraitRef> {
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