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

Add impl trait lowering mode

Browse source
This commit is contained in:
Florian Diebold 2020-01-24 15:22:00 +01:00
parent 22a65b11b3
commit 7ea4bce1b2
6 changed files with 141 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

14
crates/ra_hir/src/code_model.rs
View file

@ -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 } }
}

3
crates/ra_hir/src/source_analyzer.rs
View file

@ -179,8 +179,7 @@ impl SourceAnalyzer {
}
fn trait_env(&self, db: &impl HirDatabase) -> Arc<TraitEnvironment> {
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<Type> {

33
crates/ra_hir_ty/src/infer.rs
View file

@ -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);
}

29
crates/ra_hir_ty/src/infer/path.rs
View file

@ -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,

4
crates/ra_hir_ty/src/lib.rs
View file

@ -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

98
crates/ra_hir_ty/src/lower.rs
View file

@ -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()))