mod expr;

mod fallback;

mod mutability;

mod opaques;

mod pat;

mod path;

pub(crate) mod unify;

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

use indexmap::IndexSet;

use intern::sym;

use la_arena::ArenaMap;

use rustc_ast_ir::Mutability;

use rustc_hash::{FxHashMap, FxHashSet};

use rustc_type_ir::{

AliasTyKind, TypeFoldable,

inherent::{AdtDef, IntoKind, Region as _, SliceLike, Ty as _},

};

use stdx::never;

use triomphe::Arc;

lower::{

ImplTraitIdx, ImplTraitLoweringMode, LifetimeElisionKind, diagnostics::TyLoweringDiagnostic,

},

mir::MirSpan,

next_solver::{

AliasTy, Const, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs, Region, Ty, TyKind,

},

traits::FnTrait,

utils::TargetFeatureIsSafeInTarget,

/// At some point, of course, `Box` should move out of the compiler, in which

/// case this is analogous to transforming a struct. E.g., Box<[i32; 4]> ->

/// Box<[i32]> is an `Adjust::Unsize` with the target `Box<[i32]>`.

pub struct Adjustment<'db> {

pub target: Ty<'db>,

}

impl<'db> Adjustment<'db> {

pub fn borrow(interner: DbInterner<'db>, m: Mutability, ty: Ty<'db>, lt: Region<'db>) -> Self {

let ty = Ty::new_ref(interner, lt, ty, m);

}

}

/// capable mutable borrows.

/// See #49434 for tracking.

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

// FIXME: We should use this when appropriate.

Yes,

No,

}

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

/// Go from ! to any type.

NeverToAny,

/// Dereference once, producing a place.

Deref(Option<OverloadedDeref>),

/// Take the address and produce either a `&` or `*` pointer.

Pointer(PointerCast),

}

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

pub struct OverloadedDeref(pub Option<Mutability>);

/// Converts from T to &T.

/// Converts from T to *T.

RawPtr(Mutability),

}

}

}

/// For each struct literal or pattern, records the variant it resolves to.

variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,

/// For each associated item record what it resolves to

/// Whenever a tuple field expression access a tuple field, we allocate a tuple id in

/// [`InferenceContext`] and store the tuples substitution there. This map is the reverse of

/// that which allows us to resolve a [`TupleFieldId`]s type.

pub(crate) type_of_pat: ArenaMap<PatId, Ty<'db>>,

pub(crate) type_of_binding: ArenaMap<BindingId, Ty<'db>>,

pub(crate) type_of_opaque: FxHashMap<InternedOpaqueTyId, Ty<'db>>,

/// Whether there are any type-mismatching errors in the result.

// FIXME: This isn't as useful as initially thought due to us falling back placeholders to

// `TyKind::Error`.

pub fn assoc_resolutions_for_expr(

&self,

id: ExprId,

self.assoc_resolutions.get(&id.into()).copied()

}

self.assoc_resolutions.get(&id.into()).copied()

}

pub fn assoc_resolutions_for_expr_or_pat(

&self,

id: ExprOrPatId,

match id {

ExprOrPatId::ExprId(id) => self.assoc_resolutions_for_expr(id),

ExprOrPatId::PatId(id) => self.assoc_resolutions_for_pat(id),

re_erased: Region<'db>,

empty_args: GenericArgs<'db>,

}

impl<'db> InternedStandardTypes<'db> {

re_erased: Region::new_erased(interner),

empty_args: GenericArgs::new_from_iter(interner, []),

}

}

}

/// and resolve the path via its methods. This will ensure proper error reporting.

pub(crate) resolver: Resolver<'db>,

target_features: OnceCell<(TargetFeatures, TargetFeatureIsSafeInTarget)>,

pub(crate) generic_def: GenericDefId,

/// The traits in scope, disregarding block modules. This is used for caching purposes.

traits_in_scope: FxHashSet<TraitId>,

pub(crate) result: InferenceResult<'db>,

return_ty: types.error, // set in collect_* calls

types,

target_features: OnceCell::new(),

table,

tuple_field_accesses_rev: Default::default(),

resume_yield_tys: None,

self.resolver.krate()

}

_ => TargetFeatures::default(),

};

Ok(target) => crate::utils::target_feature_is_safe_in_target(target),

Err(_) => TargetFeatureIsSafeInTarget::No,

};

}

#[inline]

self.result.has_errors = true;

}

self.table.interner()

}

fn infer_body(&mut self) {

match self.return_coercion {

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

self.result.type_of_expr.insert(expr, ty);

}

if adjustments.is_empty() {

return;

}

self.result.pat_adjustments.entry(pat).or_default().extend(adjustments);

}

self.result.method_resolutions.insert(expr, (func, subst));

}

fn write_assoc_resolution(

&mut self,

id: ExprOrPatId,

subs: GenericArgs<'db>,

) {

self.result.assoc_resolutions.insert(id, (item, subs));

self.result.type_of_binding.insert(id, ty);

}

self.diagnostics.push(diagnostic);

}

self.process_user_written_ty(ty)

}

self.make_ty(

type_ref,

self.body,

)

}

let const_ = self.with_ty_lowering(

self.body,

InferenceTyDiagnosticSource::Body,

self.insert_type_vars(const_)

}

let const_ = self.with_ty_lowering(

self.body,

InferenceTyDiagnosticSource::Body,

self.types.error

}

let lt = self.with_ty_lowering(

self.body,

InferenceTyDiagnosticSource::Body,

}

/// Whenever you lower a user-written type, you should call this.

self.table.process_user_written_ty(ty)

}

/// The difference of this method from `process_user_written_ty()` is that this method doesn't register a well-formed obligation,

/// while `process_user_written_ty()` should (but doesn't currently).

self.table.process_remote_user_written_ty(ty)

}

self.resolve_associated_type_with_params(inner_ty, assoc_ty, &[])

}

let result = self

.table

.eq(expected, actual)

.map(|infer_ok| self.table.register_infer_ok(infer_ok));

if let Err(_err) = result {

// FIXME: Emit diagnostic.

}

}

fn resolve_associated_type_with_params(

(ty, _) = path_ctx.lower_partly_resolved_path(resolution, true);

tried_resolving_once = true;

if ty.is_ty_error() {

return (self.err_ty(), None);

}

trait_.trait_items(self.db).associated_type_by_name(&Name::new_symbol_root(sym::Output))

}

fn resolve_future_future_output(&self) -> Option<TypeAliasId> {

let ItemContainerId::TraitId(trait_) = self

.resolve_lang_item(LangItem::IntoFutureIntoFuture)?

Some(struct_.into())

}

fn resolve_va_list(&self) -> Option<AdtId> {

let struct_ = self.resolve_lang_item(LangItem::VaList)?.as_struct()?;

Some(struct_.into())

}

if b_traits.peek().is_some() {

} else {

}

}

}