};

chalk_ir::Binders::new(binders, bound)

}

crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => {

if let Some((future_trait, future_output)) = self

.db

data.substitute(Interner, &subst).into_value_and_skipped_binders().0

})

}

}

}

TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {

data.substitute(Interner, &opaque_ty.substitution)

})

}

// It always has an parameter for Future::Output type.

ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(),

};

use hir_def::{

db::DefDatabase, hir::ExprId, layout::TargetDataLayout, AdtId, BlockId, ConstParamId,

DefWithBodyId, EnumVariantId, FunctionId, GeneralConstId, GenericDefId, ImplId,

};

use la_arena::ArenaMap;

use smallvec::SmallVec;

layout::{Layout, LayoutError},

method_resolution::{InherentImpls, TraitImpls, TyFingerprint},

mir::{BorrowckResult, MirBody, MirLowerError},

};

use hir_expand::name::Name;

fn callable_item_signature(&self, def: CallableDefId) -> PolyFnSig;

#[salsa::invoke(crate::lower::return_type_impl_traits)]

#[salsa::invoke(crate::lower::generic_predicates_for_param_query)]

#[salsa::cycle(crate::lower::generic_predicates_for_param_recover)]

)?;

// FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution

}

ImplTraitId::AsyncBlockTypeImplTrait(body, ..) => {

let future_trait = db

.lang_item(body.module(db.upcast()).krate(), LangItem::Future)

SizedByDefault::Sized { anchor: krate },

)?;

}

ImplTraitId::AsyncBlockTypeImplTrait(..) => {

write!(f, "{{async block}}")?;

}

use std::{convert::identity, iter, ops::Index};

use chalk_ir::{

};

use either::Either;

use hir_def::{

use crate::{

db::HirDatabase,

fold_tys,

lower::ImplTraitLoweringMode,

static_lifetime, to_assoc_type_id,

traits::FnTrait,

utils::{InTypeConstIdMetadata, UnevaluatedConstEvaluatorFolder},

AliasEq, AliasTy, Binders, ClosureId, Const, DomainGoal, GenericArg, Goal, ImplTraitId,

};

// This lint has a false positive here. See the link below for details.

/// unresolved or missing subpatterns or subpatterns of mismatched types.

pub type_of_pat: ArenaMap<PatId, Ty>,

pub type_of_binding: ArenaMap<BindingId, Ty>,

/// Type of the result of `.into_iter()` on the for. `ExprId` is the one of the whole for loop.

pub type_of_for_iterator: FxHashMap<ExprId, Ty>,

type_mismatches: FxHashMap<ExprOrPatId, TypeMismatch>,

}

fn collect_const(&mut self, data: &ConstData) {

}

fn collect_static(&mut self, data: &StaticData) {

self.write_binding_ty(self_param, ty);

}

}

for (ty, pat) in param_tys.zip(&*self.body.params) {

let ty = self.insert_type_vars(ty);

let ty = self.normalize_associated_types_in(ty);

self.infer_top_pat(*pat, &ty);

}

let return_ty = &*data.ret_type;

let return_ty = if let Some(rpits) = self.db.return_type_impl_traits(func) {

// RPIT opaque types use substitution of their parent function.

let fn_placeholders = TyBuilder::placeholder_subst(self.db, func);

let rpits = rpits.skip_binders();

for (id, _) in rpits.impl_traits.iter() {

if let Entry::Vacant(e) = self.result.type_of_rpit.entry(id) {

self.return_ty = self.normalize_associated_types_in(return_ty);

self.return_coercion = Some(CoerceMany::new(self.return_ty.clone()));

}

&mut self,

t: T,

) -> T

where

T: crate::HasInterner<Interner = Interner> + crate::TypeFoldable<Interner>,

};

let idx = match self.db.lookup_intern_impl_trait_id(opaque_ty_id.into()) {

ImplTraitId::ReturnTypeImplTrait(_, idx) => idx,

_ => unreachable!(),

};

let bounds =

let var = self.table.new_type_var();

let var_subst = Substitution::from1(Interner, var.clone());

for bound in bounds {

let (var_predicate, binders) =

predicate.substitute(Interner, &var_subst).into_value_and_skipped_binders();

always!(binders.is_empty(Interner)); // quantified where clauses not yet handled

var_predicate,

rpits.clone(),

);

self.push_obligation(var_predicate.cast(Interner));

}

)

}

fn infer_body(&mut self) {

match self.return_coercion {

Some(_) => self.infer_return(self.body.body_expr),

return success(simple(Adjust::NeverToAny)(to_ty.clone()), to_ty.clone(), vec![]);

}

// Consider coercing the subtype to a DST

if let Ok(ret) = self.try_coerce_unsized(&from_ty, to_ty) {

return Ok(ret);

method_resolution::{self, VisibleFromModule},

to_chalk_trait_id,

utils::generics,

};

impl InferenceContext<'_> {

pub(super) fn infer_path(&mut self, path: &Path, id: ExprOrPatId) -> Option<Ty> {

use either::Either;

use ena::unify::UnifyKey;

use hir_expand::name;

use smallvec::SmallVec;

use triomphe::Arc;

consteval::unknown_const, db::HirDatabase, fold_tys_and_consts, static_lifetime,

to_chalk_trait_id, traits::FnTrait, AliasEq, AliasTy, BoundVar, Canonical, Const, ConstValue,

DebruijnIndex, DomainGoal, GenericArg, GenericArgData, Goal, GoalData, Guidance, InEnvironment,

};

impl InferenceContext<'_> {

pub(crate) struct InferenceTable<'a> {

pub(crate) db: &'a dyn HirDatabase,

pub(crate) trait_env: Arc<TraitEnvironment>,

var_unification_table: ChalkInferenceTable,

type_variable_table: SmallVec<[TypeVariableFlags; 16]>,

pending_obligations: Vec<Canonicalized<InEnvironment<Goal>>>,

InferenceTable {

db,

trait_env,

var_unification_table: ChalkInferenceTable::new(),

type_variable_table: SmallVec::new(),

pending_obligations: Vec::new(),

let infer = db.infer(func.into());

return db.layout_of_ty(infer.type_of_rpit[idx].clone(), trait_env);

}

crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {

return Err(LayoutError::NotImplemented)

}

#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]

pub enum ImplTraitId {

AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId),

}

impl_intern_value_trivial!(ImplTraitId);

#[derive(Clone, PartialEq, Eq, Debug, Hash)]

}

#[derive(Clone, PartialEq, Eq, Debug, Hash)]

pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>,

}

pub fn static_lifetime() -> Lifetime {

LifetimeData::Static.intern(Interner)

InTypeConstIdMetadata,

},

AliasEq, AliasTy, Binders, BoundVar, CallableSig, Const, ConstScalar, DebruijnIndex, DynTy,

};

#[derive(Debug)]

/// we're grouping the mutable data (the counter and this field) together

/// with the immutable context (the references to the DB and resolver).

/// Splitting this up would be a possible fix.

Param(Cell<u16>),

Variable(Cell<u16>),

Disallowed,

TypeRef::ImplTrait(bounds) => {

match &self.impl_trait_mode {

ImplTraitLoweringState::Opaque(opaque_type_data) => {

};

// this dance is to make sure the data is in the right

// place even if we encounter more opaque types while

// lowering the bounds

bounds: crate::make_single_type_binders(Vec::new()),

});

// We don't want to lower the bounds inside the binders

// away instead of two.

let actual_opaque_type_data = self

.with_debruijn(DebruijnIndex::INNERMOST, |ctx| {

});

opaque_type_data.borrow_mut()[idx] = actual_opaque_type_data;

let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();

let parameters = generics.bound_vars_subst(self.db, self.in_binders);

TyKind::OpaqueType(opaque_ty_id, parameters).intern(Interner)

}

}

}

cov_mark::hit!(lower_rpit);

let self_ty = TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(Interner);

let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {

.collect();

if !ctx.unsized_types.borrow().contains(&self_ty) {

let sized_trait = ctx

.db

.lang_item(krate, LangItem::Sized)

}

predicates

});

}

}

let generics = generics(db.upcast(), t.into());

let resolver = t.resolver(db.upcast());

let ctx = TyLoweringContext::new(db, &resolver, t.into())

.with_type_param_mode(ParamLoweringMode::Variable);

let type_alias_data = db.type_alias_data(t);

if type_alias_data.is_extern {

pub(crate) fn return_type_impl_traits(

db: &dyn HirDatabase,

def: hir_def::FunctionId,

// FIXME unify with fn_sig_for_fn instead of doing lowering twice, maybe

let data = db.function_data(def);

let resolver = def.resolver(db.upcast());

.with_type_param_mode(ParamLoweringMode::Variable);

let _ret = ctx_ret.lower_ty(&data.ret_type);

let generics = generics(db.upcast(), def.into());

impl_traits: match ctx_ret.impl_trait_mode {

ImplTraitLoweringState::Opaque(x) => x.into_inner(),

_ => unreachable!(),

}

}

pub(crate) fn lower_to_chalk_mutability(m: hir_def::type_ref::Mutability) -> Mutability {

match m {

hir_def::type_ref::Mutability::Shared => Mutability::Not,

};

filler.try_fold_ty(infer.type_of_rpit[idx].clone(), outer_binder)

}

crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {

not_supported!("async block impl trait");

}

"#,

);

}