Add impl trait lowering mode

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(db, &resolver);
-        let environment = TraitEnvironment::lower(&ctx);
         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 ctx = hir_ty::TyLoweringContext {
-        let environment = TraitEnvironment::lower(&ctx);
+            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(db, &resolver);
-        let environment = TraitEnvironment::lower(&ctx);
         Type { krate, ty: InEnvironment { value: ty, environment } }
     }
 

crates/ra_hir/src/source_analyzer.rs

@@ -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(db, &self.resolver)
-        TraitEnvironment::lower(&ctx)
     }
 
     pub fn type_of(&self, db: &impl HirDatabase, expr: &ast::Expr) -> Option<Type> {

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

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,

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

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> {
+    pub fn lower(db: &impl HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> {
-        let predicates = ctx
+        let ctx =
-            .resolver
+            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 ctx_params = TyLoweringContext {
-    let params = data.params.iter().map(|tr| Ty::from_hir(&ctx, tr)).collect::<Vec<_>>();
+        db,
-    let ret = Ty::from_hir(&ctx, &data.ret_type);
+        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()))