checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"

[[package]]

name = "clap"

version = "4.5.48"

source = "registry+https://github.com/rust-lang/crates.io-index"

"arrayvec",

"base-db",

"bitflags 2.9.4",

"cov-mark",

"either",

"ena",

[patch.'crates-io']

# rowan = { path = "../rowan" }

# line-index = { path = "lib/line-index" }

# la-arena = { path = "lib/la-arena" }

# lsp-server = { path = "lib/lsp-server" }

bitflags = "2.9.1"

cargo_metadata = "0.21.0"

camino = "1.1.10"

crossbeam-channel = "0.5.15"

dissimilar = "1.0.10"

dot = "0.1.4"

tracing.workspace = true

rustc-hash.workspace = true

scoped-tls = "1.0.1"

la-arena.workspace = true

triomphe.workspace = true

typed-arena = "2.0.2"

//! The home of `HirDatabase`, which is the Salsa database containing all the

//! type inference-related queries.

use hir_def::{

AdtId, BlockId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,

GeneralConstId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId, StaticId, TraitId,

use triomphe::Arc;

use crate::{

consteval::ConstEvalError,

dyn_compatibility::DynCompatibilityViolation,

layout::{Layout, LayoutError},

method_resolution::{InherentImpls, TraitImpls, TyFingerprint},

mir::{BorrowckResult, MirBody, MirLowerError},

};

#[query_group::query_group]

fn monomorphized_mir_body<'db>(

&'db self,

def: DefWithBodyId,

env: Arc<TraitEnvironment<'db>>,

) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>>;

fn monomorphized_mir_body_for_closure<'db>(

&'db self,

def: InternedClosureId,

env: Arc<TraitEnvironment<'db>>,

) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>>;

fn const_eval<'db>(

&'db self,

def: GeneralConstId,

trait_env: Option<Arc<TraitEnvironment<'db>>>,

#[salsa::invoke(crate::consteval::const_eval_static_query)]

#[salsa::cycle(cycle_result = crate::consteval::const_eval_static_cycle_result)]

#[salsa::invoke(crate::consteval::const_eval_discriminant_variant)]

#[salsa::cycle(cycle_result = crate::consteval::const_eval_discriminant_cycle_result)]

&'db self,

env: Arc<TraitEnvironment<'db>>,

func: FunctionId,

// endregion:mir

fn layout_of_adt<'db>(

&'db self,

def: AdtId,

trait_env: Arc<TraitEnvironment<'db>>,

) -> Result<Arc<Layout>, LayoutError>;

#[salsa::cycle(cycle_result = crate::layout::layout_of_ty_cycle_result)]

fn layout_of_ty<'db>(

&'db self,

env: Arc<TraitEnvironment<'db>>,

) -> Result<Arc<Layout>, LayoutError>;

#[salsa::invoke(crate::dyn_compatibility::dyn_compatibility_of_trait_query)]

fn dyn_compatibility_of_trait(&self, trait_: TraitId) -> Option<DynCompatibilityViolation>;

#[salsa::transparent]

fn type_for_type_alias_with_diagnostics<'db>(

&'db self,

def: TypeAliasId,

/// Returns the type of the value of the given constant, or `None` if the `ValueTyDefId` is

/// a `StructId` or `EnumVariantId` with a record constructor.

fn impl_self_ty_with_diagnostics<'db>(

&'db self,

def: ImplId,

#[salsa::transparent]

// FIXME: Make this a non-interned query.

fn impl_trait_with_diagnostics<'db>(

&'db self,

def: ImplId,

#[salsa::transparent]

fn field_types_with_diagnostics<'db>(

&'db self,

var: VariantId,

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

#[salsa::transparent]

fn callable_item_signature<'db>(

&'db self,

def: CallableDefId,

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

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

fn generic_predicates_without_parent_with_diagnostics<'db>(

&'db self,

def: GenericDefId,

#[salsa::transparent]

fn generic_predicates_without_parent<'db>(

&'db self,

def: GenericDefId,

#[salsa::transparent]

fn trait_environment_for_body<'db>(&'db self, def: DefWithBodyId)

-> Arc<TraitEnvironment<'db>>;

fn trait_environment<'db>(&'db self, def: GenericDefId) -> Arc<TraitEnvironment<'db>>;

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

#[salsa::cycle(cycle_result = crate::lower::generic_defaults_with_diagnostics_cycle_result)]

def: GenericDefId,

/// This returns an empty list if no parameter has default.

///

/// The binders of the returned defaults are only up to (not including) this parameter.

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

#[salsa::transparent]

#[salsa::invoke(InherentImpls::inherent_impls_in_crate_query)]

fn inherent_impls_in_crate(&self, krate: Crate) -> Arc<InherentImpls>;

#[salsa::invoke(TraitImpls::trait_impls_in_deps_query)]

fn trait_impls_in_deps(&self, krate: Crate) -> Arc<[Arc<TraitImpls>]>;

#[salsa::interned]

fn intern_impl_trait_id(&self, id: ImplTraitId) -> InternedOpaqueTyId;

// cycle_initial = crate::variance::variances_of_cycle_initial,

cycle_result = crate::variance::variances_of_cycle_initial,

)]

}

#[test]

) -> impl Iterator<Item = (LocalFieldId, Ty<'db>)> {

let (_, substs) = ty.as_adt().unwrap();

let fields_len = variant.fields(self.db).fields().len() as u32;

(0..fields_len).map(|idx| LocalFieldId::from_raw(idx.into())).map(move |fid| {

// FIXME: We shouldn't use `param.id`, it should be removed. We should know the

// `GenericDefId` from the formatted type (store it inside the `HirFormatter`).

let bounds =

.instantiate_identity()

.into_iter()

.flatten()

hir_def::AdtId::StructId(s) => {

let data = f.db.struct_signature(s);

write!(f, "{}", data.name.display(f.db, f.edition()))?;

render_variant_after_name(

s.fields(f.db),

f,

.1

.display(f.db, f.edition())

)?;

render_variant_after_name(

var_id.fields(f.db),

f,

let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty_id);

if let ImplTraitId::ReturnTypeImplTrait(func, idx) = impl_trait_id {

let datas = db

.expect("impl trait id without data");

let data = (*datas).as_ref().map_bound(|rpit| {

&rpit.impl_traits[idx.to_nextsolver(interner)].predicates

let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty_id);

match impl_trait_id {

ImplTraitId::ReturnTypeImplTrait(func, idx) => {

let data = (*datas).as_ref().map_bound(|rpit| {

&rpit.impl_traits[idx.to_nextsolver(interner)].predicates

});

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

}

ImplTraitId::TypeAliasImplTrait(alias, idx) => {

let data = (*datas).as_ref().map_bound(|rpit| {

&rpit.impl_traits[idx.to_nextsolver(interner)].predicates

});

}

TypeParamProvenance::ArgumentImplTrait => {

let bounds = db

.instantiate_identity()

.into_iter()

.flatten()

parameters: &'ga [GenericArg<'db>],

) -> &'ga [GenericArg<'db>] {

if f.display_kind.is_source_code() || f.omit_verbose_types() {

None => parameters,

Some(default_parameters) => {

let should_show = |arg: GenericArg<'db>, i: usize| match default_parameters.get(i) {

{

return DropGlue::None;

}

.iter()

.map(|(_, field_ty)| {

has_drop_glue_impl(

.variants

.iter()

.map(|&(variant, _, _)| {

.iter()

.map(|(_, field_ty)| {

has_drop_glue_impl(

use crate::{

ImplTraitId,

db::{HirDatabase, InternedOpaqueTyId},

next_solver::{

},

traits::next_trait_solve_in_ctxt,

};

};

let interner = DbInterner::new_with(db, Some(krate), None);

// FIXME: We should use `explicit_predicates_of` here, which hasn't been implemented to

// rust-analyzer yet

// https://github.com/rust-lang/rust/blob/ddaf12390d3ffb7d5ba74491a48f3cd528e5d777/compiler/rustc_hir_analysis/src/collect/predicates_of.rs#L490

// but we don't have good way to render such locations.

// So, just return single boolean value for existence of such `Self` reference

fn predicates_reference_self(db: &dyn HirDatabase, trait_: TraitId) -> bool {

.iter()

.any(|pred| predicate_references_self(db, trait_, pred, AllowSelfProjection::No))

}

}) = pred

&& let trait_data = db.trait_signature(pred_trait_ref.def_id.0)

&& trait_data.flags.contains(TraitFlags::AUTO)

pred_trait_ref.self_ty().kind()

{

continue;

db: &dyn HirDatabase,

trait_: TraitId,

func: FunctionId,

) -> bool {

let sig = sig.instantiate_identity();

parent: trait_.into(),

local_id: LocalTypeOrConstParamId::from_raw(la_arena::RawIdx::from_u32(0)),

});

// `self: Self` can't be dispatched on, but this is already considered dyn-compatible

// See rustc's comment on https://github.com/rust-lang/rust/blob/3f121b9461cce02a703a0e7e450568849dfaa074/compiler/rustc_trait_selection/src/traits/object_safety.rs#L433-L437

// Type `U`

// FIXME: That seems problematic to fake a generic param like that?

// `Receiver[Self => U]`

let unsized_receiver_ty = receiver_for_self_ty(interner, func, receiver_ty, unsized_self_ty);

let param_env = {

// Self: Unsize<U>

let unsize_predicate =

// Receiver: DispatchFromDyn<Receiver[Self => U]>

let predicate =

TraitRef::new(interner, dispatch_from_dyn_did.into(), [receiver_ty, unsized_receiver_ty]);

let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());

// the receiver is dispatchable iff the obligation holds

fn receiver_for_self_ty<'db>(

interner: DbInterner<'db>,

func: FunctionId,

}

fn contains_illegal_impl_trait_in_trait<'db>(

db: &'db dyn HirDatabase,

) -> Option<MethodViolationCode> {

struct OpaqueTypeCollector(FxHashSet<InternedOpaqueTyId>);

//! where parent follows the same scheme.

use std::ops;

use hir_def::{

ConstParamId, GenericDefId, GenericParamId, ItemContainerId, LifetimeParamId, Lookup,

TypeOrConstParamId, TypeParamId,

use itertools::chain;

use triomphe::Arc;

pub fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics {

let parent_generics = parent_generic_def(db, def).map(|def| Box::new(generics(db, def)));

let (params, store) = db.generic_params_and_store(def);

pub(crate) fn parent_generics(&self) -> Option<&Generics> {

self.parent_generics.as_deref()

}

}

pub(crate) fn trait_self_param_idx(db: &dyn DefDatabase, def: GenericDefId) -> Option<usize> {

expr::ExprIsRead,

unify::InferenceTable,

},

mir::MirSpan,

next_solver::{

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

},

);

let return_ty = self.insert_type_vars(return_ty);

let mut mode = ImplTraitReplacingMode::ReturnPosition(FxHashSet::default());

let result = self.insert_inference_vars_for_impl_trait(return_ty, &mut mode);

if let ImplTraitReplacingMode::ReturnPosition(taits) = mode {

}

return ty;

}

}

ImplTraitId::TypeAliasImplTrait(def, idx) => {

if let ImplTraitReplacingMode::ReturnPosition(taits) = mode {

taits.insert(ty);

return ty;

}

}

_ => unreachable!(),

};

match ty.kind() {

TyKind::Adt(adt_def, substs) => match adt_def.def_id().0 {

AdtId::StructId(struct_id) => {

Some(field) => {

ty = field.instantiate(self.interner(), substs);

}

let struct_data = id.fields(ctx.db);

if let Some((last_field, _)) = struct_data.fields().iter().last() {

let last_field_ty =

pointer_kind(last_field_ty, ctx)

} else {

Ok(Some(PointerKind::Thin))

use crate::{

InferenceDiagnostic, InferenceTyDiagnosticSource, TyLoweringDiagnostic,

db::HirDatabase,

};

// Unfortunately, this struct needs to use interior mutability (but we encapsulate it)

pat::contains_explicit_ref_binding,

},

lang_items::lang_items_for_bin_op,

LifetimeElisionKind, lower_mutability,

path::{GenericArgsLowerer, TypeLikeConst, substs_from_args_and_bindings},

},

match def_id {

_ if fields.is_empty() => {}

Some(def) => {

let variant_data = def.fields(self.db);

let visibilities = self.db.field_visibilities(def);

for field in fields.iter() {

}

return None;

}

.instantiate(interner, parameters);

Some((Either::Left(field_id), ty))

});

None => {

let (field_id, subst) = private_field?;

let adjustments = autoderef.adjust_steps();

.instantiate(self.interner(), subst);

let ty = self.process_remote_user_written_ty(ty);

let callable_ty = self.table.try_structurally_resolve_type(callable_ty);

if let TyKind::FnDef(fn_def, parameters) = callable_ty.kind() {

let generic_predicates =

if let Some(predicates) = generic_predicates.instantiate(self.interner(), parameters) {

let interner = self.interner();

let param_env = self.table.trait_env.env;

use crate::{

Adjust, Adjustment, AutoBorrow, OverloadedDeref,

infer::{Expectation, InferenceContext, expr::ExprIsRead},

next_solver::TyKind,

};

AllowTwoPhase, BindingMode, Expectation, InferenceContext, TypeMismatch,

coerce::CoerceNever, expr::ExprIsRead,

},

next_solver::{GenericArgs, Ty, TyKind},

};

match def {

_ if subs.is_empty() => {}

Some(def) => {

let variant_data = def.fields(self.db);

let visibilities = self.db.field_visibilities(def);

match def {

_ if subs.len() == 0 => {}

Some(def) => {

let variant_data = def.fields(self.db);

let visibilities = self.db.field_visibilities(def);

InferenceDiagnostic, ValueTyDefId,

generics::generics,

infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext,

method_resolution::{self, VisibleFromModule},

next_solver::{

GenericArg, GenericArgs, TraitRef, Ty,

def: GenericDefId,

subst: GenericArgs<'db>,

) {

let interner = self.interner();

let param_env = self.table.trait_env.env;

if let Some(predicates) = predicates.instantiate(self.interner(), subst) {

while let Some((AdtId::StructId(id), subst)) = ty.as_adt() {

let struct_data = id.fields(self.db);

if let Some((last_field, _)) = struct_data.fields().iter().next_back() {

.instantiate(self.interner(), subst);

if structs.contains(&ty) {

// A struct recursively contains itself as a tail field somewhere.

}

let is_enum = matches!(variant, VariantId::EnumVariantId(..));

let field_vis = if is_enum { None } else { Some(self.db().field_visibilities(variant)) };

for (fid, _) in fields.iter() {

// * #[repr(simd)] struct S([T; 4])

//

// where T is a primitive scalar (integer/float/pointer).

let mut fields = fields.iter();

let Some(TyKind::Array(e_ty, e_len)) = fields

.next()

fd: LocalFieldId,

args: &GenericArgs<'a>,

) -> Ty<'a> {

}

fn scalar_unit(dl: &TargetDataLayout, value: Primitive) -> Scalar {

extern crate self as hir_ty;

mod infer;

mod inhabitedness;

mod lower;

pub mod next_solver;

mod target_feature;

mod utils;

pub mod autoderef;

pub mod consteval;

pub mod db;

pub mod diagnostics;

pub mod display;

use std::hash::Hash;

use hir_expand::name::Name;

use indexmap::{IndexMap, map::Entry};

use intern::{Symbol, sym};

use mir::{MirEvalError, VTableMap};

use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};

use rustc_type_ir::{

use triomphe::Arc;

use crate::{

db::HirDatabase,

display::{DisplayTarget, HirDisplay},

infer::unify::InferenceTable,

};

pub use autoderef::autoderef;

closure::analysis::{CaptureKind, CapturedItem},

could_coerce, could_unify, could_unify_deeply,

};

};

pub use method_resolution::check_orphan_rules;

pub use next_solver::interner::{attach_db, attach_db_allow_change, with_attached_db};

is_fn_unsafe_to_call, target_feature_is_safe_in_target,

};

/// A constant can have reference to other things. Memory map job is holding

/// the necessary bits of memory of the const eval session to keep the constant

/// meaningful.

}

impl<'db> MemoryMap<'db> {

match self {

MemoryMap::Empty | MemoryMap::Simple(_) => Err(MirEvalError::InvalidVTableId(id)),

MemoryMap::Complex(cm) => cm.vtable.ty(id),

}

}

/// Return an index of a parameter in the generic type parameter list by it's id.

pub fn param_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) -> Option<usize> {

generics::generics(db, id.parent).type_or_const_param_idx(id)

}

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

pub enum FnAbi {

Aapcs,

}

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

pub type ImplTraitIdx = Idx<ImplTrait>;

/// 'Canonicalizes' the `t` by replacing any errors with new variables. Also

/// ensures there are no unbound variables or inference variables anywhere in

/// the `t`.

where

T: rustc_type_ir::TypeFoldable<DbInterner<'db>> + Clone,

{

use rustc_type_ir::{FallibleTypeFolder, TypeSuperFoldable};

struct ErrorReplacer<'db> {

interner: DbInterner<'db>,

binder: rustc_type_ir::DebruijnIndex,

}

impl<'db> FallibleTypeFolder<DbInterner<'db>> for ErrorReplacer<'db> {

self.interner

}

where

T: rustc_type_ir::TypeFoldable<DbInterner<'db>>,

{

result

}

if !t.has_type_flags(

rustc_type_ir::TypeFlags::HAS_ERROR

| rustc_type_ir::TypeFlags::HAS_TY_INFER

#[cfg(debug_assertions)]

let error = || Err(());

#[cfg(not(debug_assertions))]

match t.kind() {

let var = rustc_type_ir::BoundVar::from_usize(self.vars.len());

ui: rustc_type_ir::UniverseIndex::ZERO,

sub_root: var,

});

self.interner,

self.binder,

))

}

_ => t.try_super_fold_with(self),

}

}

if !ct.has_type_flags(

rustc_type_ir::TypeFlags::HAS_ERROR

| rustc_type_ir::TypeFlags::HAS_TY_INFER

#[cfg(debug_assertions)]

let error = || Err(());

#[cfg(not(debug_assertions))]

match ct.kind() {

let var = rustc_type_ir::BoundVar::from_usize(self.vars.len());

}

_ => ct.try_super_fold_with(self),

}

}

#[cfg(debug_assertions)]

let error = || Err(());

#[cfg(not(debug_assertions))]

match region.kind() {

let var = rustc_type_ir::BoundVar::from_usize(self.vars.len());

self.interner,

self.binder,

))

}

_ => Ok(region),

}

}

Ok(t) => t,

Err(_) => panic!("Encountered unbound or inference vars in {t:?}"),

};

value,

max_universe: rustc_type_ir::UniverseIndex::ZERO,

}

}

pub fn callable_sig_from_fn_trait<'db>(

trait_env: Arc<TraitEnvironment<'db>>,

db: &'db dyn HirDatabase,

let krate = trait_env.krate;

let fn_once_trait = FnTrait::FnOnce.get_id(db, krate)?;

let output_assoc_type = fn_once_trait

.associated_type_by_name(&Name::new_symbol_root(sym::Output))?;

let mut table = InferenceTable::new(db, trait_env.clone());

// Register two obligations:

// - Self: FnOnce<?args_ty>

// - <Self as FnOnce<?args_ty>>::Output == ?ret_ty

let args_ty = table.next_ty_var();

let args = [self_ty, args_ty];

table.interner(),

rustc_type_ir::AliasTyKind::Projection,

);

if !table.try_obligation(pred).no_solution() {

table.register_obligation(pred);

let return_ty = table.normalize_alias_ty(projection);

for fn_x in [FnTrait::Fn, FnTrait::FnMut, FnTrait::FnOnce] {

let fn_x_trait = fn_x.get_id(db, krate)?;

if !table

.no_solution()

{

let ret_ty = table.resolve_completely(return_ty);

let args_ty = table.resolve_completely(args_ty);

return None;

};

table.interner(),

params.iter().chain(std::iter::once(ret_ty)),

);

return Some((

fn_x,

inputs_and_output,

c_variadic: false,

abi: FnAbi::RustCall,

}),

));

impl<'db> rustc_type_ir::TypeVisitor<DbInterner<'db>> for ParamCollector {

type Result = ();

self.params.insert(param.id.into());

}

ty.super_visit_with(self);

}

self.params.insert(param.id.into());

}

}

pub fn known_const_to_ast<'db>(

db: &'db dyn HirDatabase,

display_target: DisplayTarget,

) -> Option<ConstArg> {

use std::{

cell::OnceCell,

iter, mem,

};

use base_db::Crate;

use either::Either;

use hir_def::{

UnionId, VariantId,

builtin_type::BuiltinType,

lang_item::LangItem,

type_ref::{

},

};

use hir_expand::name::Name;

use rustc_hash::FxHashSet;

use stdx::{impl_from, never};

use triomphe::{Arc, ThinArc};

use crate::{

db::HirDatabase,

generics::{Generics, generics, trait_self_param_idx},

next_solver::{

},

};

#[derive(Debug, Default)]

/// When turning `impl Trait` into opaque types, we have to collect the

/// bounds at the same time to get the IDs correct (without becoming too

/// complicated).

mode: ImplTraitLoweringMode,

// This is structured as a struct with fields and not as an enum because it helps with the borrow checker.

}

Self { mode, opaque_type_data: Arena::new() }

}

}

#[derive(Debug, Clone)]

/// Create a new anonymous lifetime parameter and reference it.

///

/// If `report_in_path`, report an error when encountering lifetime elision in a path:

AnonymousCreateParameter { report_in_path: bool },

/// Replace all anonymous lifetimes by provided lifetime.

/// Give a hard error when either `&` or `'_` is written. Used to

/// rule out things like `where T: Foo<'_>`. Does not imply an

/// error on default object bounds (e.g., `Box<dyn Foo>`).

AnonymousReportError,

/// Infer all elided lifetimes.

Infer,

}

#[inline]

// FIXME: We should use the elided lifetime here, or `ElisionFailure`.

}

}

#[derive(Debug)]

pub db: &'db dyn HirDatabase,

def: GenericDefId,

generics: OnceCell<Generics>,

in_binders: DebruijnIndex,

/// Tracks types with explicit `?Sized` bounds.

pub(crate) diagnostics: Vec<TyLoweringDiagnostic>,

}

db: &'db dyn HirDatabase,

def: GenericDefId,

) -> Self {

let impl_trait_mode = ImplTraitLoweringState::new(ImplTraitLoweringMode::Disallowed);

Self {

db,

resolver,

def,

generics: Default::default(),

store,

in_binders,

impl_trait_mode,

unsized_types: FxHashSet::default(),

diagnostics: Vec::new(),

lifetime_elision,

}

}

pub(crate) fn with_debruijn<T>(

&mut self,

debruijn: DebruijnIndex,

) -> T {

let old_debruijn = mem::replace(&mut self.in_binders, debruijn);

let result = f(self);

pub(crate) fn with_shifted_in<T>(

&mut self,

debruijn: DebruijnIndex,

) -> T {

}

pub(crate) fn with_impl_trait_mode(self, impl_trait_mode: ImplTraitLoweringMode) -> Self {

Self { impl_trait_mode: ImplTraitLoweringState::new(impl_trait_mode), ..self }

}

}

pub(crate) fn push_diagnostic(&mut self, type_ref: TypeRefId, kind: TyLoweringDiagnosticKind) {

}

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

/// `impl Trait` gets lowered into an opaque type that doesn't unify with

/// anything except itself. This is used in places where values flow 'out',

/// i.e. for arguments of the function we're currently checking, and return

Disallowed,

}

self.lower_ty_ext(type_ref).0

}

let const_ref = &self.store[const_ref.expr];

match const_ref {

hir_def::hir::Expr::Literal(literal) => intern_const_ref(

self.db,

&match *literal {

}

}

}

fn generics(&self) -> &Generics {

self.generics.get_or_init(|| generics(self.db, self.def))

}

let mut res = None;

let type_ref = &self.store[type_ref_id];

let ty = match type_ref {

TypeRef::Tuple(inner) => {

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

}

TypeRef::Path(path) => {

let (ty, res_) =

}

&TypeRef::TypeParam(type_param_id) => {

res = Some(TypeNs::GenericParam(type_param_id));

}

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

let inner_ty = self.lower_ty(inner);

}

TypeRef::Array(array) => {

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

}

&TypeRef::Slice(inner) => {

let inner_ty = self.lower_ty(inner);

}

TypeRef::Reference(ref_) => {

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

let lifetime = ref_

.lifetime

}

TypeRef::Fn(fn_) => {

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

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

}

TypeRef::DynTrait(bounds) => self.lower_dyn_trait(bounds),

TypeRef::ImplTrait(bounds) => {

match self.impl_trait_mode.mode {

ImplTraitLoweringMode::Opaque => {

_ => panic!(

"opaque impl trait lowering must be in function or type alias"

),

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

// place even if we encounter more opaque types while

// lowering the bounds

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

// we're currently in, because they don't end up inside

// those binders. E.g. when we have `impl Trait<impl

// parameter of the outer function, it's just one binder

// away instead of two.

let actual_opaque_type_data = self

});

self.impl_trait_mode.opaque_type_data[idx] = actual_opaque_type_data;

}

ImplTraitLoweringMode::Disallowed => {

// FIXME: report error

}

}

}

};

(ty, res)

}

/// This is only for `generic_predicates_for_param`, where we can't just

/// lower the self types of the predicates since that could lead to cycles.

/// So we just check here if the `type_ref` resolves to a generic param, and which.

let path = match type_ref {

TypeRef::Path(path) => path,

&TypeRef::TypeParam(idx) => return Some(idx.into()),

if path.segments().len() > 1 {

return None;

}

_ => return None,

};

match resolution {

}

#[inline]

PathDiagnosticCallback {

data: Either::Left(PathDiagnosticCallbackData(type_ref)),

callback: |data, this, diag| {

}

#[inline]

PathLoweringContext::new(

self,

Self::on_path_diagnostic_callback(path_id.type_ref()),

)

}

// Resolve the path (in type namespace)

if let Some(type_ref) = path.type_anchor() {

let (ty, res) = self.lower_ty_ext(type_ref);

let mut ctx = self.at_path(path_id);

let (resolution, remaining_index) = match ctx.resolve_path_in_type_ns() {

Some(it) => it,

};

if matches!(resolution, TypeNs::TraitId(_)) && remaining_index.is_none() {

fn lower_trait_ref_from_path(

&mut self,

path_id: PathId,

let mut ctx = self.at_path(path_id);

let resolved = match ctx.resolve_path_in_type_ns_fully()? {

// FIXME(trait_alias): We need to handle trait alias here.

Some((ctx.lower_trait_ref_from_resolved_path(resolved, explicit_self_ty, false), ctx))

}

pub(crate) fn lower_where_predicate<'b>(

&'b mut self,

where_predicate: &'b WherePredicate,

ignore_bindings: bool,

match where_predicate {

WherePredicate::ForLifetime { target, bound, .. }

| WherePredicate::TypeBound { target, bound } => {

let self_ty = self.lower_ty(*target);

}

}

.into_iter()

}

pub(crate) fn lower_type_bound<'b>(

&'b mut self,

bound: &'b TypeBound,

ignore_bindings: bool,

let mut assoc_bounds = None;

let mut clause = None;

match bound {

&TypeBound::Path(path, TraitBoundModifier::None) | &TypeBound::ForLifetime(_, path) => {

// FIXME Don't silently drop the hrtb lifetimes here

// FIXME(sized-hierarchy): Remove this bound modifications once we have implemented

// sized-hierarchy correctly.

let meta_sized = LangItem::MetaSized

.resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate());

let pointee_sized = LangItem::PointeeSized

.resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate());

// Ignore this bound

// Regard this as `?Sized` bound

ctx.ty_ctx().unsized_types.insert(self_ty);

} else {

if !ignore_bindings {

}

}

}

}

// `?Sized` has no of them.

// If we got another trait here ignore the bound completely.

let trait_id = self

if trait_id == sized_trait {

self.unsized_types.insert(self_ty);

}

}

&TypeBound::Lifetime(l) => {

let lifetime = self.lower_lifetime(l);

}

TypeBound::Use(_) | TypeBound::Error => {}

}

clause.into_iter().chain(assoc_bounds.into_iter().flatten())

}

// INVARIANT: The principal trait bound, if present, must come first. Others may be in any

// order but should be in the same order for the same set but possibly different order of

// bounds in the input.

// INVARIANT: If this function returns `DynTy`, there should be at least one trait bound.

// These invariants are utilized by `TyExt::dyn_trait()` and chalk.

let mut lifetime = None;

for b in bounds {

}

}

let mut multiple_regular_traits = false;

let mut multiple_same_projection = false;

lowered_bounds.sort_unstable_by(|lhs, rhs| {

use std::cmp::Ordering;

}

_ => unreachable!(),

}

}

}

});

return None;

}

// As multiple occurrences of the same auto traits *are* permitted, we deduplicate the

// bounds. We shouldn't have repeated elements besides auto traits at this point.

lowered_bounds.dedup();

});

if let Some(bounds) = bounds {

},

} else {

// FIXME: report error

// (additional non-auto traits, associated type rebound, or no resolved trait)

}

}

cov_mark::hit!(lower_rpit);

let mut predicates = Vec::new();

for b in bounds {

}

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

let sized_clause = sized_trait.map(|trait_id| {

});

predicates.extend(sized_clause);

}

predicates.shrink_to_fit();

predicates

});

}

match self.resolver.resolve_lifetime(&self.store[lifetime]) {

Some(resolution) => match resolution {

}

},

}

}

}

let interner = DbInterner::new_with(db, None, None);

}

}

}

}

}

db: &dyn HirDatabase,

variant_id: VariantId,

}

/// Build the type of all specific fields of a struct or enum variant.

variant_id: VariantId,

let var_data = variant_id.fields(db);

let fields = var_data.fields();

if fields.is_empty() {

VariantId::UnionId(it) => (it.resolver(db), it.into()),

VariantId::EnumVariantId(it) => (it.resolver(db), it.lookup(db).parent.into()),

};

let mut res = ArenaMap::default();

let mut ctx = TyLoweringContext::new(

db,

&var_data.store,

def,

LifetimeElisionKind::AnonymousReportError,

}

(Arc::new(res), create_diagnostics(ctx.diagnostics))

}

/// This is a query mostly to handle cycles somewhat gracefully; e.g. the

/// following bounds are disallowed: `T: Foo<U::Item>, U: Foo<T::Item>`, but

/// these are fine: `T: Foo<U::Item>, U: Foo<()>`.

def: GenericDefId,

param_id: TypeOrConstParamId,

assoc_name: Option<Name>,

let generics = generics(db, def);

let resolver = def.resolver(db);

let mut ctx = TyLoweringContext::new(

db,

generics.store(),

def,

LifetimeElisionKind::AnonymousReportError,

// we have to filter out all other predicates *first*, before attempting to lower them

WherePredicate::ForLifetime { target, bound, .. }

| WherePredicate::TypeBound { target, bound, .. } => {

let invalid_target = { ctx.lower_ty_only_param(*target) != Some(param_id) };

}

}();

if lower {

}

return false;

}

return false;

};

matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name

})

})

ctx.store = maybe_parent_generics.store();

for pred in maybe_parent_generics.where_predicates() {

if predicate(pred, &mut ctx) {

}

}

}

let explicitly_unsized_tys = ctx.unsized_types;

};

}

GenericPredicates(predicates.is_empty().not().then(|| predicates.into()))

_def: GenericDefId,

_param_id: TypeOrConstParamId,

_assoc_name: Option<Name>,

GenericPredicates(None)

}

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

fn deref(&self) -> &Self::Target {

self.0.as_deref().unwrap_or(&[])

}

}

db: &dyn HirDatabase,

def: GenericDefId,

}

/// Resolve the where clause(s) of an item with generics,

/// with a given filter

def: GenericDefId,

filter: F,

where

{

let generics = generics(db, def);

let resolver = def.resolver(db);

let mut ctx = TyLoweringContext::new(

db,

&resolver,

generics.store(),

def,

LifetimeElisionKind::AnonymousReportError,

let mut predicates = Vec::new();

for maybe_parent_generics in

{

ctx.store = maybe_parent_generics.store();

for pred in maybe_parent_generics.where_predicates() {

}

}

}

);

};

}

(

GenericPredicates(predicates.is_empty().not().then(|| predicates.into())),

create_diagnostics(ctx.diagnostics),

/// Generate implicit `: Sized` predicates for all generics that has no `?Sized` bound.

/// Exception is Self of a trait def.

db: &'db dyn HirDatabase,

def: GenericDefId,

resolver: &Resolver<'db>,

let trait_self_idx = trait_self_param_idx(db, def);

Some(

.enumerate()

.filter_map(

move |(idx, generic_arg)| {

if Some(idx) == trait_self_idx { None } else { Some(generic_arg) }

},

)

.map(move |self_ty| {

}),

)

}

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

}

}

db.generic_defaults_with_diagnostics(def).0

}

pub(crate) fn generic_defaults_with_diagnostics_query(

db: &dyn HirDatabase,

def: GenericDefId,

let generic_params = generics(db, def);

if generic_params.is_empty() {

return (GenericDefaults(None), None);

def,

LifetimeElisionKind::AnonymousReportError,

)

let mut idx = 0;

let mut has_any_default = false;

let mut defaults = generic_params

.iter_parents_with_store()

ctx.store = store;

has_any_default |= has_default;

idx += 1;

result

})

.collect::<Vec<_>>();

ctx.diagnostics.clear(); // Don't include diagnostics from the parent.

has_any_default |= has_default;

idx += 1;

result

};

return (defaults, diagnostics);

idx: usize,

p: GenericParamDataRef<'_>,

match p {

GenericParamDataRef::TypeParamData(p) => {

}

GenericParamDataRef::ConstParamData(p) => {

}

}

}

}

pub(crate) fn generic_defaults_with_diagnostics_cycle_result(

_db: &dyn HirDatabase,

_def: GenericDefId,

(GenericDefaults(None), None)

}

}

}

db,

&resolver,

);

}

};

}

}

}

let mut ctx = TyLoweringContext::new(

db,

&resolver,

LifetimeElisionKind::AnonymousReportError,

}

}

}

}

}

}

}

//! A wrapper around [`TyLoweringContext`] specifically for lowering paths.

use either::Either;

use hir_def::{

expr_store::{

},

hir::generics::{

GenericParamDataRef, TypeOrConstParamData, TypeParamData, TypeParamProvenance,

},

signatures::TraitFlags,

type_ref::{TypeRef, TypeRefId},

};

use smallvec::SmallVec;

use stdx::never;

use crate::{

db::HirDatabase,

generics::{Generics, generics},

next_solver::{

},

};

type CallbackData<'a, 'db> = Either<

crate::infer::diagnostics::PathDiagnosticCallbackData<'a, 'db>,

>;

pub(crate) struct PathDiagnosticCallback<'a, 'db> {

pub(crate) data: CallbackData<'a, 'db>,

pub(crate) callback:

}

path: &'a Path,

segments: PathSegments<'a>,

current_segment_idx: usize,

current_or_prev_segment: PathSegment<'a>,

}

#[inline]

pub(crate) fn new(

path: &'a Path,

) -> Self {

let segments = path.segments();

}

#[inline]

self.ctx

}

}

#[inline]

fn with_lifetime_elision<T>(

&mut self,

) -> T {

let old_lifetime_elision =

std::mem::replace(&mut self.ctx.lifetime_elision, lifetime_elision);

pub(crate) fn lower_ty_relative_path(

&mut self,

// We need the original resolution to lower `Self::AssocTy` correctly

res: Option<TypeNs>,

infer_args: bool,

0 => (ty, res),

1 => {

// resolve unselected assoc types

}

_ => {

// FIXME report error (ambiguous associated type)

}

}

}

&mut self,

resolution: TypeNs,

infer_args: bool,

let remaining_segments = self.segments.skip(self.current_segment_idx + 1);

let ty = match resolution {

TypeNs::TraitId(trait_) => {

1 => {

let trait_ref = self.lower_trait_ref_from_resolved_path(

trait_,

);

self.skip_resolved_segment();

let segment = self.current_or_prev_segment;

let found =

match found {

Some(associated_ty) => {

// FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent

// this point (`trait_ref.substitution`).

let substitution = self.substs_from_path_segment(

associated_ty.into(),

None,

true,

);

);

}

None => {

// FIXME: report error (associated type not found)

}

}

}

// Trait object type without dyn; this should be handled in upstream. See

// `lower_path()`.

stdx::never!("unexpected fully resolved trait path");

}

_ => {

// FIXME report error (ambiguous associated type)

}

};

return (ty, None);

}

let generics = self.ctx.generics();

}

}

}

TypeNs::AdtSelfType(adt) => {

}

TypeNs::AdtId(it) => self.lower_path_inner(it.into(), infer_args),

TypeNs::TypeAliasId(it) => self.lower_path_inner(it.into(), infer_args),

// FIXME: report error

TypeNs::EnumVariantId(_) | TypeNs::ModuleId(_) => {

}

};

self.skip_resolved_segment();

self.lower_ty_relative_path(ty, Some(resolution), infer_args)

}

let mut prohibit_generics_on_resolved = |reason| {

if self.current_or_prev_segment.args_and_bindings.is_some() {

let segment = self.current_segment_u32();

prohibit_generics_on_resolved(GenericArgsProhibitedReason::TyParam)

}

TypeNs::AdtSelfType(_) => {

}

TypeNs::BuiltinType(_) => {

prohibit_generics_on_resolved(GenericArgsProhibitedReason::PrimitiveTy)

| TypeNs::TypeAliasId(_)

| TypeNs::TraitId(_) => {}

}

}

pub(crate) fn resolve_path_in_type_ns_fully(&mut self) -> Option<TypeNs> {

Some(res)

}

pub(crate) fn resolve_path_in_type_ns(&mut self) -> Option<(TypeNs, Option<usize>)> {

let (resolution, remaining_index, _, prefix_info) =

self.ctx.resolver.resolve_path_in_type_ns_with_prefix_info(self.ctx.db, self.path)?;

self.current_or_prev_segment =

segments.get(resolved_segment_idx).expect("should have resolved segment");

for (i, mod_segment) in module_segments.iter().enumerate() {

if mod_segment.args_and_bindings.is_some() {

self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {

});

}

Some((resolution, remaining_index))

}

self.ctx.db,

}

};

}

let generic_def = match typeable {

}

TyDefId::AdtId(it) => it.into(),

TyDefId::TypeAliasId(it) => it.into(),

};

}

pub(crate) fn substs_from_path_segment(

&mut self,

def: GenericDefId,

infer_args: bool,

lowering_assoc_type_generics: bool,

let old_lifetime_elision = self.ctx.lifetime_elision.clone();

if let Some(args) = self.current_or_prev_segment.args_and_bindings

PathLoweringDiagnostic::ParenthesizedGenericArgsWithoutFnTrait { segment },

);

}

// `Fn()`-style generics are treated like functions for the purpose of lifetime elision.

pub(super) fn substs_from_args_and_bindings(

&mut self,

def: GenericDefId,

infer_args: bool,

generics_source: PathGenericsSource,

lowering_assoc_type_generics: bool,

generics_source: PathGenericsSource,

}

fn report_len_mismatch(

&mut self,

def: GenericDefId,

&mut self,

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

}

let GenericParamId::ConstParamId(const_id) = param_id else {

unreachable!("non-const param ID for const param");

};

self.ctx

.ctx

}

_ => unreachable!("unmatching param kinds were passed to `provided_kind()`"),

}

fn provided_type_like_const(

&mut self,

arg: TypeLikeConst<'_>,

match arg {

TypeLikeConst::Path(path) => self.ctx.ctx.lower_path_as_const(path, const_ty),

TypeLikeConst::Infer => unknown_const(const_ty),

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

infer_args: bool,

match param {

GenericParamDataRef::TypeParamData(param) => {

if !infer_args

&& param.default.is_some()

{

return default;

}

}

GenericParamDataRef::ConstParamData(param) => {

if !infer_args

let GenericParamId::ConstParamId(const_id) = param_id else {

unreachable!("non-const param ID for const param");

};

}

}

}

match param_id {

GenericParamId::ConstParamId(const_id) => {

}

}

}

});

}

fn report_missing_lifetime(&mut self, def: GenericDefId, expected_count: u32) {

self.ctx.on_diagnostic(PathLoweringDiagnostic::MissingLifetime {

generics_source: self.generics_source,

pub(crate) fn lower_trait_ref_from_resolved_path(

&mut self,

resolved: TraitId,

infer_args: bool,

}

fn trait_ref_substs_from_path(

&mut self,

resolved: TraitId,

infer_args: bool,

self.substs_from_path_segment(resolved.into(), infer_args, Some(explicit_self_ty), false)

}

pub(super) fn assoc_type_bindings_from_type_bound<'c>(

mut self,

self.current_or_prev_segment.args_and_bindings.map(|args_and_bindings| {

args_and_bindings.bindings.iter().enumerate().flat_map(move |(binding_idx, binding)| {

let found = associated_type_by_name_including_super_traits(

self.ctx.db,

&binding.name,

);

let (super_trait_ref, associated_ty) = match found {

None => return SmallVec::new(),

Some(t) => t,

};

self.with_lifetime_elision(LifetimeElisionKind::AnonymousReportError, |this| {

// FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent

// generic params. It's inefficient to splice the `Substitution`s, so we may want

binding.args.as_ref(),

associated_ty.into(),

false, // this is not relevant

PathGenericsSource::AssocType {

segment: this.current_segment_u32(),

assoc_type: binding_idx as u32,

this.ctx.lifetime_elision.clone(),

)

});

);

let mut predicates: SmallVec<[_; 1]> = SmallVec::with_capacity(

binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),

);

if let Some(type_ref) = binding.type_ref {

let lifetime_elision =

if args_and_bindings.parenthesized == GenericArgsParentheses::ParenSugar {

// `Fn()`-style generics are elided like functions. This is `Output` (we lower to it in hir-def).

} else {

self.ctx.lifetime_elision.clone()

};

ImplTraitLoweringMode::Disallowed | ImplTraitLoweringMode::Opaque,

) => {

let ty = this.ctx.lower_ty(type_ref);

}

}

}

predicates

})

})

Path(&'a Path),

}

fn report_elided_lifetimes_in_path(

&mut self,

def: GenericDefId,

hard_error: bool,

);

fn report_missing_lifetime(&mut self, def: GenericDefId, expected_count: u32);

fn report_len_mismatch(

&mut self,

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

fn inferred_kind(

&mut self,

param_id: GenericParamId,

param: GenericParamDataRef<'_>,

infer_args: bool,

}

/// Returns true if there was an error.

def: GenericDefId,

def_generics: &Generics,

infer_args: bool,

lowering_assoc_type_generics: bool,

) -> bool {

let mut had_error = false;

let args_no_self = &args_and_bindings.args[usize::from(args_and_bindings.has_self_type)..];

for arg in args_no_self {

match arg {

}

}

}

ctx.report_missing_lifetime(def, lifetime_args_len as u32);

had_error = true

}

LifetimeElisionKind::Elided(_) => {

ctx.report_elided_lifetimes_in_path(def, lifetime_args_len as u32, false);

}

had_error

}

store: &ExpressionStore,

def: GenericDefId,

mut infer_args: bool,

lowering_assoc_type_generics: bool,

// Order is

// - Parent parameters

// - Optional Self parameter

// We do not allow inference if there are specified args, i.e. we do not allow partial inference.

let has_non_lifetime_args =

infer_args &= !has_non_lifetime_args;

let had_count_error = check_generic_args_len(

let (_, self_ty) = args.next().expect("has_self_type=true, should have Self type");

ctx.provided_kind(self_param_id, self_param, self_ty)

} else {

ctx.inferred_kind(def, self_param_id, self_param, infer_args, &substs)

})

};

// input. We try to handle both sensibly.

match (args.peek(), params.peek()) {

(Some(&(arg_idx, arg)), Some(&(param_id, param))) => match (arg, param) {

if type_param.provenance == TypeParamProvenance::ArgumentImplTrait =>

{

// Do not allow specifying `impl Trait` explicitly. We already err at that, but if we won't handle it here

substs.push(ctx.inferred_kind(def, param_id, param, infer_args, &substs));

params.next();

}

substs.push(ctx.provided_kind(param_id, param, arg));

args.next();

params.next();

}

(

GenericParamDataRef::LifetimeParamData(_),

) => {

// We expected a lifetime argument, but got a type or const

params.next();

force_infer_lt = Some((arg_idx as u32, param_id));

}

if let Some(konst) = type_looks_like_const(store, *type_ref) {

let GenericParamId::ConstParamId(param_id) = param_id else {

panic!("unmatching param kinds");

};

args.next();

params.next();

} else {

// after a type or const). We want to throw an error in this case.

if !had_count_error {

assert!(

"the only possible situation here is incorrect lifetime order"

);

let (provided_arg_idx, param_id) =

// If there are fewer arguments than parameters, it means we're inferring the remaining arguments.

let param = if let GenericParamId::LifetimeParamId(_) = param_id {

match &lifetime_elision {

| LifetimeElisionKind::AnonymousReportError => {

assert!(had_count_error);

ctx.inferred_kind(def, param_id, param, infer_args, &substs)

}

LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false }

| LifetimeElisionKind::Infer => {

// FIXME: With `AnonymousCreateParameter`, we need to create a new lifetime parameter here

}

}

}

fn type_looks_like_const(

_ => None,

}

}