+ TypeRefId, TypesMap, TypesSourceMap,

+ types_map: &'a TypesMap,

+ /// If this is set, that means we're in a context of a freshly expanded macro, and that means

+ /// we should not use `TypeRefId` in diagnostics because the caller won't have the `TypesMap`,

+ /// instead we need to put `TypeSource` from the source map.

+ types_source_map: Option<&'a TypesSourceMap>,

+ pub fn new(

+ db: &'a dyn HirDatabase,

+ resolver: &'a Resolver,

+ types_map: &'a TypesMap,

+ owner: TypeOwnerId,

+ ) -> Self {

+ Self::new_maybe_unowned(db, resolver, types_map, None, Some(owner))

+ types_map: &'a TypesMap,

+ types_source_map: Option<&'a TypesSourceMap>,

+ types_map,

+ types_source_map,

+

+ pub fn impl_trait_mode(&mut self, impl_trait_mode: ImplTraitLoweringMode) -> &mut Self {

+ self.impl_trait_mode = ImplTraitLoweringState::new(impl_trait_mode);

+ self

+ }

+

+ pub fn type_param_mode(&mut self, type_param_mode: ParamLoweringMode) -> &mut Self {

+ self.type_param_mode = type_param_mode;

+ self

+ }

+ pub fn lower_ty(&self, type_ref: TypeRefId) -> Ty {

+ pub fn lower_ty_ext(&self, type_ref_id: TypeRefId) -> (Ty, Option<TypeNs>) {

+ let type_ref = &self.types_map[type_ref_id];

+ let inner_tys = inner.iter().map(|&tr| self.lower_ty(tr));

+ &TypeRef::RawPtr(inner, mutability) => {

+ TyKind::Raw(lower_to_chalk_mutability(mutability), inner_ty).intern(Interner)

+ TypeRef::Array(array) => {

+ let inner_ty = self.lower_ty(array.ty);

+ let const_len = self.lower_const(&array.len, TyBuilder::usize());

+ &TypeRef::Slice(inner) => {

+ TypeRef::Reference(ref_) => {

+ let inner_ty = self.lower_ty(ref_.ty);

+ let lifetime = ref_

+ .lifetime

+ .as_ref()

+ .map_or_else(error_lifetime, |lr| self.lower_lifetime(lr));

+ TyKind::Ref(lower_to_chalk_mutability(ref_.mutability), lifetime, inner_ty)

+ TypeRef::Fn(fn_) => {

+ Substitution::from_iter(

+ Interner,

+ fn_.params().iter().map(|&(_, tr)| ctx.lower_ty(tr)),

+ )

+ abi: fn_.abi().as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),

+ safety: if fn_.is_unsafe() { Safety::Unsafe } else { Safety::Safe },

+ variadic: fn_.is_varargs(),

+ // Since those have been emitted as implicit type args already.

+ counter.set(idx + self.count_impl_traits(type_ref_id) as u16);

+ counter.set(idx + self.count_impl_traits(type_ref_id) as u16);

+ let (mut types_map, mut types_source_map) =

+ (TypesMap::default(), TypesSourceMap::default());

+

+ let ctx = expander.ctx(

+ self.db.upcast(),

+ &mut types_map,

+ &mut types_source_map,

+ );

+

+ // FIXME: That may be better served by mutating `self` then restoring, but this requires

+ // making it `&mut self`.

+ let inner_ctx = TyLoweringContext {

+ db: self.db,

+ resolver: self.resolver,

+ generics: self.generics.clone(),

+ types_map: &types_map,

+ types_source_map: Some(&types_source_map),

+ in_binders: self.in_binders,

+ owner: self.owner,

+ type_param_mode: self.type_param_mode,

+ impl_trait_mode: self.impl_trait_mode.take(),

+ expander: RefCell::new(self.expander.take()),

+ unsized_types: RefCell::new(self.unsized_types.take()),

+ };

+

+ let ty = inner_ctx.lower_ty(type_ref);

+

+ self.impl_trait_mode.swap(&inner_ctx.impl_trait_mode);

+ *self.expander.borrow_mut() = inner_ctx.expander.into_inner();

+ *self.unsized_types.borrow_mut() = inner_ctx.unsized_types.into_inner();

+ fn lower_ty_only_param(&self, type_ref: TypeRefId) -> Option<TypeOrConstParamId> {

+ let type_ref = &self.types_map[type_ref];

+ let ty = self.lower_dyn_trait(&[bound]);

+ substs.push(self.lower_ty(*ty).cast(Interner));

+ self.types_map,

+ WherePredicateTypeTarget::TypeRef(type_ref) => self.lower_ty(*type_ref),

+ bound: &'a TypeBound,

+ let clause = match bound {

+ TypeBound::Use(_) | TypeBound::Error => None,

+ bound: &'a TypeBound,

+ let last_segment = match bound {

+ | TypeBound::Use(_)

+ PathSegment { name: &binding.name, args_and_bindings: binding.args.as_ref() },

+ if let Some(type_ref) = binding.type_ref {

+ match (&self.types_map[type_ref], &self.impl_trait_mode) {

+ self.types_map,

+ self.types_source_map,

+ fn lower_dyn_trait(&self, bounds: &[TypeBound]) -> Ty {

+ fn lower_impl_trait(&self, bounds: &[TypeBound], krate: CrateId) -> ImplTrait {

+

+ // FIXME: This does not handle macros!

+ fn count_impl_traits(&self, type_ref: TypeRefId) -> usize {

+ let mut count = 0;

+ TypeRef::walk(type_ref, self.types_map, &mut |type_ref| {

+ if matches!(type_ref, TypeRef::ImplTrait(_)) {

+ count += 1;

+ }

+ });

+ count

+ }

+ let ctx = TyLoweringContext::new(db, &resolver, var_data.types_map(), def.into())

+ res.insert(field_id, make_binders(db, &generics, ctx.lower_ty(field_data.type_ref)));

+ let mut ctx = if let GenericDefId::FunctionId(_) = def {

+ TyLoweringContext::new(db, &resolver, TypesMap::EMPTY, def.into())

+ TyLoweringContext::new(db, &resolver, TypesMap::EMPTY, def.into())

+ let predicate = |pred: &_, def: &_, ctx: &TyLoweringContext<'_>| match pred {

+ ctx.lower_ty_only_param(*type_ref) != Some(param_id)

+ let target_id = TypeOrConstParamId { parent: *def, local_id };

+ if let TypeBound::Path(_, TraitBoundModifier::Maybe) = bound {

+ ctx.lower_where_predicate(pred, def, true).for_each(drop);

+ match bound {

+ TypeBound::Use(_) | TypeBound::Lifetime(_) | TypeBound::Error => false,

+ let mut predicates = Vec::new();

+ for (params, def) in resolver.all_generic_params() {

+ ctx.types_map = &params.types_map;

+ predicates.extend(

+ params.where_predicates().filter(|pred| predicate(pred, def, &ctx)).flat_map(|pred| {

+ ctx.lower_where_predicate(pred, def, true).map(|p| make_binders(db, &generics, p))

+ }),

+ );

+ }

+ let mut ctx = if let GenericDefId::FunctionId(_) = def {

+ TyLoweringContext::new(db, &resolver, TypesMap::EMPTY, def.into())

+ TyLoweringContext::new(db, &resolver, TypesMap::EMPTY, def.into())

+ for (params, def) in resolver.all_generic_params() {

+ ctx.types_map = &params.types_map;

+ for pred in params.where_predicates() {

+ for pred in ctx.lower_where_predicate(pred, def, false) {

+ if let WhereClause::Implemented(tr) = pred.skip_binders() {

+ traits_in_scope

+ .push((tr.self_type_parameter(Interner).clone(), tr.hir_trait_id()));

+ }

+ let program_clause: chalk_ir::ProgramClause<Interner> = pred.cast(Interner);

+ clauses.push(program_clause.into_from_env_clause(Interner));

+ let mut ctx = TyLoweringContext::new(db, &resolver, TypesMap::EMPTY, def.into())

+ let mut predicates = Vec::new();

+ for (params, def) in resolver.all_generic_params() {

+ ctx.types_map = &params.types_map;

+ predicates.extend(params.where_predicates().filter(|pred| filter(pred, def)).flat_map(

+ |pred| {

+ ctx.lower_where_predicate(pred, def, false).map(|p| make_binders(db, &generics, p))

+ },

+ ));

+ }

+ let mut ctx = TyLoweringContext::new(db, &resolver, TypesMap::EMPTY, def.into())

+ GenericDefaults(Some(Arc::from_iter(generic_params.iter_with_types_map().enumerate().map(

+ |(idx, ((id, p), types_map))| {

+ ctx.types_map = types_map;

+ fallback_bound_vars(ctx.lower_ty(*ty), idx, parent_start_idx)

+ let c = ctx.lower_const(c, ctx.lower_ty(p.ty));

+ let ctx_params = TyLoweringContext::new(db, &resolver, &data.types_map, def.into())

+ let params = data.params.iter().map(|&tr| ctx_params.lower_ty(tr));

+ let ctx_ret = TyLoweringContext::new(db, &resolver, &data.types_map, def.into())

+ let ret = ctx_ret.lower_ty(data.ret_type);

+ let ctx = TyLoweringContext::new(db, &resolver, &data.types_map, def.into())

+ make_binders(db, &generics, ctx.lower_ty(data.type_ref))

+ let ctx = TyLoweringContext::new(db, &resolver, &data.types_map, def.into());

+ Binders::empty(Interner, ctx.lower_ty(data.type_ref))

+ let ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ struct_data.variant_data.types_map(),

+ AdtId::from(def).into(),

+ )

+ .with_type_param_mode(ParamLoweringMode::Variable);

+ let params = fields.iter().map(|(_, field)| ctx.lower_ty(field.type_ref));

+ let ctx = TyLoweringContext::new(

+ db,

+ &resolver,

+ var_data.variant_data.types_map(),

+ DefWithBodyId::VariantId(def).into(),

+ )

+ .with_type_param_mode(ParamLoweringMode::Variable);

+ let params = fields.iter().map(|(_, field)| ctx.lower_ty(field.type_ref));

+ let type_alias_data = db.type_alias_data(t);

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

+ type_alias_data

+ .type_ref

+ .map(|type_ref| ctx.lower_ty(type_ref))

+ .unwrap_or_else(|| TyKind::Error.intern(Interner))

+ let ctx = TyLoweringContext::new(db, &resolver, &impl_data.types_map, impl_id.into())

+ make_binders(db, &generics, ctx.lower_ty(impl_data.self_ty))

+ let ctx = TyLoweringContext::new(db, &resolver, &parent_data.types_map, def.parent().into());

+ TypeOrConstParamData::ConstParamData(d) => ctx.lower_ty(d.ty),

+ let ctx = TyLoweringContext::new(db, &resolver, &impl_data.types_map, impl_id.into())

+ let ctx_ret = TyLoweringContext::new(db, &resolver, &data.types_map, def.into())

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

+ let ctx = TyLoweringContext::new(db, &resolver, &data.types_map, def.into())

+ if let Some(type_ref) = data.type_ref {

+ types_map: &TypesMap,

+ for_type: impl FnOnce(&mut T, TypeRefId) -> Ty + 'a,

+ (GenericArg::Type(type_ref), ParamKind::Type) => for_type(this, *type_ref).cast(Interner),

+ if let TypeRef::Path(p) = &types_map[*t] {