+ AnonConstId, AnonConstLoc, AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc,

+ DefWithBodyId, EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExpressionStoreOwner,

+ ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc,

+ GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander, MacroId,

+ MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId,

+ StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId,

+ UnionLoc, UseId, UseLoc, VariantId,

+ fn intern_anon_const(&self, loc: AnonConstLoc) -> AnonConstId;

+

+ #[salsa::interned]

+ #[salsa::invoke(ExprScopes::body_expr_scopes_query)]

+ fn body_expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;

+

+ #[salsa::invoke(ExprScopes::sig_expr_scopes_query)]

+ fn sig_expr_scopes(&self, def: GenericDefId) -> Arc<ExprScopes>;

+

+ #[salsa::transparent]

+ fn expr_scopes(&self, def: ExpressionStoreOwner) -> Arc<ExprScopes>;

+/// Describes where a const expression originated from.

+///

+/// Used by signature/body inference to determine the expected type for each

+/// const expression root.

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

+pub enum ConstExprOrigin {

+ /// Array length expression: `[T; <expr>]` — expected type is `usize`.

+ ArrayLength,

+ /// Const parameter default value: `const N: usize = <expr>`.

+ ConstParam(crate::hir::generics::LocalTypeOrConstParamId),

+ /// Const generic argument in a path: `SomeType::<{ <expr> }>` or `some_fn::<{ <expr> }>()`.

+ /// Determining the expected type requires path resolution, so it is deferred.

+ GenericArgsPath,

+}

+

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

+

+ /// Maps const expression roots to their origin.

+ ///

+ /// Populated during lowering. Used by signature inference to determine expected types,

+ /// and by `signature_const_expr_roots()` to enumerate roots for scope computation.

+ const_expr_origins: ThinVec<(ExprId, ConstExprOrigin)>,

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

+ pub const_expr_origins: Option<ThinVec<(ExprId, ConstExprOrigin)>>,

+ mut const_expr_origins,

+ if let Some(const_expr_origins) = &mut const_expr_origins {

+ const_expr_origins.shrink_to_fit();

+ }

+ const_expr_origins: const_expr_origins.unwrap_or_default(),

+ /// Returns all const expression root `ExprId`s found in this store.

+ ///

+ /// Used to compute expression scopes for signature stores.

+ pub fn signature_const_expr_roots(&self) -> impl Iterator<Item = ExprId> {

+ self.const_expr_origins().iter().map(|&(id, _)| id)

+ }

+

+ /// Like [`Self::signature_const_expr_roots`], but also returns the origin

+ /// of each const expression.

+ ///

+ /// This is used by signature inference to determine the expected type for

+ /// each root expression.

+ pub fn signature_const_expr_roots_with_origins(

+ &self,

+ ) -> impl Iterator<Item = (ExprId, ConstExprOrigin)> {

+ self.const_expr_origins().iter().map(|&(id, origin)| (id, origin))

+ }

+

+ /// Returns the map of const expression roots to their origins.

+ pub fn const_expr_origins(&self) -> &[(ExprId, ConstExprOrigin)] {

+ self.expr_only.as_ref().map_or(&[], |it| &it.const_expr_origins)

+ }

+

+ src.map(|it| it.const_arg()?.expr())

+ Body, BodySourceMap, ConstExprOrigin, ExprPtr, ExpressionStore, ExpressionStoreBuilder,

+ let mut collector = ExprCollector::body(db, module, current_file_id);

+ let mut expr_collector = ExprCollector::signature(db, module, type_ref.file_id);

+ let mut expr_collector = ExprCollector::signature(db, module, file_id);

+ let mut expr_collector = ExprCollector::signature(db, module, impl_syntax.file_id);

+ let mut expr_collector = ExprCollector::signature(db, module, trait_syntax.file_id);

+ let mut expr_collector = ExprCollector::signature(db, module, alias.file_id);

+ let mut expr_collector = ExprCollector::signature(db, module, fn_.file_id);

+ /// Creates a collector for a signature store, this will populate `const_expr_origins` to any

+ /// top level const arg roots.

+ pub fn signature(

+ db: &dyn DefDatabase,

+ module: ModuleId,

+ current_file_id: HirFileId,

+ ) -> ExprCollector<'_> {

+ let mut this = Self::body(db, module, current_file_id);

+ this.store.const_expr_origins = Some(Default::default());

+ this

+ }

+

+ /// Creates a collector for a bidy store.

+ pub fn body(

+ pub(in crate::expr_store) fn lower_lifetime_ref(

+ &mut self,

+ lifetime: ast::Lifetime,

+ ) -> LifetimeRefId {

+ pub(in crate::expr_store) fn lower_lifetime_ref_opt(

+ &mut self,

+ lifetime: Option<ast::Lifetime>,

+ ) -> LifetimeRefId {

+ pub(in crate::expr_store) fn lower_type_ref(

+ if let Some(const_expr_origins) = &mut self.store.const_expr_origins {

+ const_expr_origins.push((len.expr, ConstExprOrigin::ArrayLength));

+ }

+ pub(in crate::expr_store) fn lower_generic_args_from_fn_path(

+ if let Some(const_expr_origins) = &mut self.store.const_expr_origins {

+ const_expr_origins.push((arg.expr, ConstExprOrigin::GenericArgsPath));

+ }

+ let const_expr_origins = self.store.const_expr_origins.take();

+ let r = ConstRef { expr: self.collect_expr_opt(arg.and_then(|it| it.expr())) };

+ self.store.const_expr_origins = const_expr_origins;

+ r

+ pub fn lower_const_arg(&mut self, arg: ast::ConstArg) -> ConstRef {

+ let const_expr_origins = self.store.const_expr_origins.take();

+ let r = ConstRef { expr: self.collect_expr_opt(arg.expr()) };

+ self.store.const_expr_origins = const_expr_origins;

+ r

+ pub(in crate::expr_store) fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {

+ match expr {

+ Some(expr) => self.collect_expr(expr),

+ None => self.missing_expr(),

+ }

+ }

+

+ let default = const_param.default_val().map(|it| ec.lower_const_arg(it));

+ let param = ConstParamData { name, ty, default };

+ let idx = self.type_or_consts.alloc(param.into());

+ if let Some(default) = default

+ && let Some(const_expr_origins) = &mut ec.store.const_expr_origins

+ {

+ const_expr_origins.push((

+ default.expr,

+ crate::expr_store::ConstExprOrigin::ConstParam(idx),

+ ));

+ }

+ ExprCollector::signature(&db, crate_def_map(&db, krate).root_module_id(), file_id.into());

+ BlockId, DefWithBodyId, ExpressionStoreOwner, GenericDefId,

+ pub(crate) fn expr_scopes_query(

+ db: &dyn DefDatabase,

+ def: ExpressionStoreOwner,

+ ) -> Arc<ExprScopes> {

+ match def {

+ ExpressionStoreOwner::Body(def) => db.body_expr_scopes(def),

+ ExpressionStoreOwner::Signature(def) => db.sig_expr_scopes(def),

+ }

+ }

+

+ pub(crate) fn body_expr_scopes_query(

+ db: &dyn DefDatabase,

+ def: DefWithBodyId,

+ ) -> Arc<ExprScopes> {

+ pub(crate) fn sig_expr_scopes_query(

+ db: &dyn DefDatabase,

+ def: GenericDefId,

+ ) -> Arc<ExprScopes> {

+ let (_, store) = db.generic_params_and_store(def);

+ let roots = store.signature_const_expr_roots();

+ let mut scopes = ExprScopes::new_store(&store, roots);

+ scopes.shrink_to_fit();

+ Arc::new(scopes)

+ }

+

+ fn new_store(store: &ExpressionStore, roots: impl IntoIterator<Item = ExprId>) -> ExprScopes {

+ let mut scopes = ExprScopes {

+ scopes: Arena::default(),

+ scope_entries: Arena::default(),

+ scope_by_expr: ArenaMap::with_capacity(

+ store.expr_only.as_ref().map_or(0, |it| it.exprs.len()),

+ ),

+ };

+ let root = scopes.root_scope();

+ for root_expr in roots {

+ let mut scope = scopes.new_scope(root);

+ compute_expr_scopes(root_expr, store, &mut scopes, &mut scope);

+ }

+ scopes

+ }

+

+ DefWithBodyId, FunctionId, ModuleDefId, db::DefDatabase, nameres::crate_def_map,

+ test_db::TestDB,

+ let scopes = db.expr_scopes(DefWithBodyId::from(function).into());

+ let scopes = db.expr_scopes(DefWithBodyId::from(function).into());

+ hir::{

+ ExprId,

+ generics::{GenericParams, LocalLifetimeParamId, LocalTypeOrConstParamId},

+ },

+/// An anonymous const expression that appears in a type position (e.g., array lengths,

+/// const generic arguments like `{ N + 1 }`). Unlike named constants, these don't have

+/// their own `Body` — their expressions live in the parent's signature `ExpressionStore`.

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

+pub struct AnonConstLoc {

+ /// The owner store containing this expression.

+ pub owner: ExpressionStoreOwner,

+ /// The ExprId within the owner's ExpressionStore that is the root

+ /// of this anonymous const expression.

+ pub expr: ExprId,

+}

+impl_intern!(AnonConstId, AnonConstLoc, intern_anon_const, lookup_intern_anon_const);

+

+ AnonConstId(AnonConstId),

+impl_from!(ConstId, StaticId, AnonConstId for GeneralConstId);

+ pub fn generic_def(self, db: &dyn DefDatabase) -> Option<GenericDefId> {

+ GeneralConstId::AnonConstId(it) => Some(it.lookup(db).owner.generic_def(db)),

+ GeneralConstId::AnonConstId(_) => "{anon const}".to_owned(),

+/// Owner of an expression store - either a body or a signature.

+/// This is used for queries that operate on expression stores generically,

+/// such as `expr_scopes`.

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

+pub enum ExpressionStoreOwner {

+ Signature(GenericDefId),

+ Body(DefWithBodyId),

+}

+

+impl ExpressionStoreOwner {

+ pub fn as_def_with_body(self) -> Option<DefWithBodyId> {

+ if let Self::Body(v) = self { Some(v) } else { None }

+ }

+

+ pub fn generic_def(self, db: &dyn DefDatabase) -> GenericDefId {

+ match self {

+ ExpressionStoreOwner::Signature(generic_def_id) => generic_def_id,

+ ExpressionStoreOwner::Body(def_with_body_id) => match def_with_body_id {

+ DefWithBodyId::FunctionId(id) => GenericDefId::FunctionId(id),

+ DefWithBodyId::StaticId(id) => GenericDefId::StaticId(id),

+ DefWithBodyId::ConstId(id) => GenericDefId::ConstId(id),

+ DefWithBodyId::VariantId(it) => it.lookup(db).parent.into(),

+ },

+ }

+ }

+}

+

+impl From<GenericDefId> for ExpressionStoreOwner {

+ fn from(id: GenericDefId) -> Self {

+ ExpressionStoreOwner::Signature(id)

+ }

+}

+

+impl From<DefWithBodyId> for ExpressionStoreOwner {

+ fn from(id: DefWithBodyId) -> Self {

+ ExpressionStoreOwner::Body(id)

+ }

+}

+

+impl HasModule for ExpressionStoreOwner {

+ fn module(&self, db: &dyn DefDatabase) -> ModuleId {

+ match self {

+ ExpressionStoreOwner::Signature(def) => def.module(db),

+ ExpressionStoreOwner::Body(def) => def.module(db),

+ }

+ }

+}

+

+ AdtId, AstIdLoc, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,

+ ExpressionStoreOwner, ExternBlockId, ExternCrateId, FunctionId, FxIndexMap, GenericDefId,

+ GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, Lookup, Macro2Id, MacroId,

+ MacroRulesId, ModuleDefId, ModuleId, ProcMacroId, StaticId, StructId, TraitId, TypeAliasId,

+ TypeOrConstParamId, TypeParamId, UseId, VariantId,

+ owner: ExpressionStoreOwner,

+ Scope::ExprScope(it) => match it.owner {

+ ExpressionStoreOwner::Body(def) => Some(def),

+ ExpressionStoreOwner::Signature(_) => None,

+ },

+ owner: impl Into<ExpressionStoreOwner>,

+ expr_id: ExprId,

+ ) -> UpdateGuard {

+ self.update_to_inner_scope_(db, owner.into(), expr_id)

+ }

+

+ fn update_to_inner_scope_(

+ &mut self,

+ db: &'db dyn DefDatabase,

+ owner: ExpressionStoreOwner,

+ owner: ExpressionStoreOwner,

+ owner: impl Into<ExpressionStoreOwner> + HasResolver,

+ let store_owner = owner.into();

+ let r = store_owner.resolver(db);

+ let scopes = db.expr_scopes(store_owner);

+ resolver_for_scope_(db, scopes, scope_id, r, store_owner)

+ owner: ExpressionStoreOwner,

+ owner: ExpressionStoreOwner,

+impl HasResolver for ExpressionStoreOwner {

+ fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {

+ match self {

+ ExpressionStoreOwner::Signature(def) => def.resolver(db),

+ ExpressionStoreOwner::Body(def) => def.resolver(db),

+ }

+ }

+}

+

+ type_ref::{ConstRef, TraitRef, TypeBound, TypeRefId},

+ pub default_value: Option<ConstRef>,

+ let mut col = ExprCollector::signature(db, module, fields.file_id);

+ .and_then(|rf| rf.eq_token().is_some().then_some(rf.default_val()))

+ .map(|expr| col.lower_const_arg(expr));

+ let scopes = self.expr_scopes(def_with_body.into());

+ expr_store::ExpressionStore,

+ GeneralConstId::AnonConstId(_) => None,

+ GeneralConstId::AnonConstId(_) => None,

+ fn has_closure(store: &ExpressionStore, expr: ExprId) -> bool {

+ if matches!(store[expr], Expr::Closure { .. }) {

+ store.walk_child_exprs(expr, |idx| r |= has_closure(store, idx));

+ if has_closure(ctx.store, expr) {

+ if let Expr::Path(p) = &ctx.store[expr] {

+ ctx.store,

+ if let Some(body_owner) = ctx.owner.as_def_with_body()

+ && let Ok(mir_body) =

+ lower_body_to_mir(ctx.db, body_owner, &ctx.db.body(body_owner), &infer, expr)

+ ExpressionStoreOwner, FunctionId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId,

+ StaticId, TraitId, TypeAliasId, VariantId, builtin_derive::BuiltinDeriveImplMethod,

+ db::DefDatabase, hir::ExprId, layout::TargetDataLayout,

+pub struct InternedClosure(pub ExpressionStoreOwner, pub ExprId);

+pub struct InternedCoroutine(pub ExpressionStoreOwner, pub ExprId);

+ let InternedClosure(owner, _) = db.lookup_intern_closure(id);

+ let Some(def) = owner.as_def_with_body() else {

+ write!(f, "{{closure}}")?;

+ return Ok(());

+ };

+ let Some(body_owner) = owner.as_def_with_body() else {

+ write!(f, "impl Future<Output = ")?;

+ return_ty.hir_fmt(f)?;

+ write!(f, ">")?;

+ return Ok(());

+ };

+ let body = db.body(body_owner);

+ let Some(body_owner) = owner.as_def_with_body() else {

+ return DropGlue::None;

+ };

+ let infer = InferenceResult::for_body(db, body_owner);

+ let env = db.trait_environment_for_body(body_owner);

+ AdtId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, ExpressionStoreOwner, FieldId,

+ FunctionId, GenericDefId, GenericParamId, ItemContainerId, LocalFieldId, Lookup, TraitId,

+ TupleFieldId, TupleId, TypeAliasId, TypeOrConstParamId, VariantId,

+ expr_store::{ConstExprOrigin, ExpressionStore, HygieneId, path::Path},

+ let mut ctx = InferenceContext::new(db, ExpressionStoreOwner::Body(def), &body.store, resolver);

+ DefWithBodyId::FunctionId(f) => ctx.collect_fn(f, body.self_param, &body.params),

+ ctx.infer_body(body.body_expr);

+

+ ctx.infer_mut_body(body.body_expr);

+ finalize_infer(ctx)

+}

+fn finalize_infer(mut ctx: InferenceContext<'_, '_>) -> InferenceResult {

+/// Infer types for all const expressions in an item's signature.

+///

+/// This handles const expressions that appear in type positions within a generic

+/// item's signature, such as array lengths (`[T; N]`) and const generic arguments

+/// (`Foo<{ expr }>`). Each root expression is inferred independently within

+/// a shared `InferenceContext`, accumulating results into a single `InferenceResult`.

+fn infer_signature_query(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {

+ let _p = tracing::info_span!("infer_signature_query").entered();

+ let (_, store) = db.generic_params_and_store(def);

+ let mut roots = store.signature_const_expr_roots_with_origins().peekable();

+ let Some(_) = roots.peek() else {

+ return InferenceResult::new(crate::next_solver::default_types(db).types.error);

+ };

+

+ let resolver = def.resolver(db);

+ let owner = ExpressionStoreOwner::Signature(def);

+

+ let mut ctx = InferenceContext::new(db, owner, &store, resolver);

+

+ for (root_expr, origin) in roots {

+ let expected = match origin {

+ // Array lengths are always `usize`.

+ ConstExprOrigin::ArrayLength => Expectation::has_type(ctx.types.types.usize),

+ // Const parameter default: look up the param's declared type.

+ ConstExprOrigin::ConstParam(local_id) => Expectation::has_type(db.const_param_ty_ns(

+ ConstParamId::from_unchecked(TypeOrConstParamId { parent: def, local_id }),

+ )),

+ // Path const generic args: determining the expected type requires

+ // path resolution.

+ // FIXME

+ ConstExprOrigin::GenericArgsPath => Expectation::None,

+ };

+ ctx.infer_expr(root_expr, &expected, ExprIsRead::Yes);

+ }

+

+ finalize_infer(ctx)

+}

+

+fn infer_signature_cycle_result(

+ db: &dyn HirDatabase,

+ _: salsa::Id,

+ _: GenericDefId,

+) -> InferenceResult {

+ InferenceResult {

+ has_errors: true,

+ ..InferenceResult::new(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed))

+ }

+}

+

+

+ /// Infer types for all const expressions in an item's signature.

+ ///

+ /// Returns an `InferenceResult` containing type information for array lengths,

+ /// const generic arguments, and other const expressions appearing in type

+ /// positions within the item's signature.

+ #[salsa::tracked(returns(ref), cycle_result = infer_signature_cycle_result)]

+ pub fn for_signature(db: &dyn HirDatabase, def: GenericDefId) -> InferenceResult {

+ infer_signature_query(db, def)

+ }

+ pub(crate) owner: ExpressionStoreOwner,

+ pub(crate) store: &'body ExpressionStore,

+ owner: ExpressionStoreOwner,

+ store: &'body ExpressionStore,

+ let trait_env = match owner {

+ ExpressionStoreOwner::Signature(generic_def_id) => db.trait_environment(generic_def_id),

+ ExpressionStoreOwner::Body(def_with_body_id) => {

+ db.trait_environment_for_body(def_with_body_id)

+ }

+ };

+ generic_def: owner.generic_def(db),

+ store,

+ ExpressionStoreOwner::Body(DefWithBodyId::FunctionId(id)) => {

+ TargetFeatures::from_fn(self.db, id)

+ }

+ fn collect_fn(&mut self, func: FunctionId, self_param: Option<BindingId>, params: &[PatId]) {

+ if let Some(self_param) = self_param

+ for (ty, pat) in param_tys.zip(params) {

+ fn infer_body(&mut self, body_expr: ExprId) {

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

+ body_expr,

+ self.store,

+ self.store,

+ self.store,

+ self.store,

+ self.store,

+ self.store,

+ let hygiene = self.store.expr_or_pat_path_hygiene(id);

+ match &self.store[tgt_expr] {

+ if !span.is_ref_span(self.store) {

+ && span_stack[actual_truncate_to].is_ref_span(self.store)

+ match &self.store[tgt_expr] {

+ None => self.store.walk_pats(target, &mut |pat| match &self.store[pat] {

+ match &self.store[p] {

+ self.store.walk_pats_shallow(p, |p| self.walk_pat_inner(p, update_result, for_mut));

+ return self.store.is_binding_upvar(place.local, root);

+ self.owner.krate(self.db),

+ match &self.store[tgt_pat] {

+ let Expr::Closure { body, capture_by, .. } = &self.store[root] else {

+ if span_stack[span_stack.len() - 1].is_ref_span(self.store) {

+ if let &Expr::Call { callee, .. } = &self.store[expr] {

+ let Some(body_owner) = owner.as_def_with_body() else {

+ return false;

+ };

+ upvars_mentioned(db, body_owner)

+ match &self.store[pat] {

+ if let Pat::Bind { id, .. } = self.store[pat]

+ && matches!(self.store[id].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)

+ self.store.walk_pats_shallow(pat, |pat| result |= self.contains_explicit_ref_binding(pat));

+ match &self.store[expr] {

+ .resolve_path_in_value_ns_fully(self.db, path, self.store.expr_path_hygiene(expr))

+ let expr = &self.store[tgt_expr];

+ let lhs_ty = match &self.store[target] {

+ self.store.pat_path_hygiene(target),

+ let len = match self.store[repeat] {

+ let ty = if contains_explicit_ref_binding(this.store, *pat) {

+ let is_closure = if let Expr::Closure { closure_kind, .. } = self.store[*arg] {

+ pub(crate) fn infer_mut_body(&mut self, body_expr: ExprId) {

+ self.infer_mut_expr(body_expr, Mutability::Not);

+ match &self.store[tgt_expr] {

+ self.store.walk_pats(target, &mut |pat| match self.store[pat] {

+ self.store.walk_bindings_in_pat(pat, |b| {

+ if self.store[b].mode == BindingAnnotation::RefMut {

+ HasModule as _,

+ expr_store::{ExpressionStore, path::Path},

+ if matches!(&self.store[pat], Pat::Ref { .. }) || self.inside_assignment {

+ } else if self.is_non_ref_pat(self.store, pat) {

+ let ty = match &self.store[pat] {

+ let Binding { mode, .. } = self.store[binding];

+ if let Expr::Literal(Literal::ByteString(_)) = self.store[expr]

+ fn is_non_ref_pat(&mut self, store: &hir_def::expr_store::ExpressionStore, pat: PatId) -> bool {

+ match &store[pat] {

+ Pat::Or(pats) => pats.iter().all(|p| self.is_non_ref_pat(store, *p)),

+ store[*expr],

+pub(super) fn contains_explicit_ref_binding(store: &ExpressionStore, pat_id: PatId) -> bool {

+ store.walk_pats(pat_id, &mut |pat| {

+ res |= matches!(store[pat], Pat::Bind { id, .. } if matches!(store[id].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut));

+ self.store,

+ let hygiene = self.store.expr_or_pat_path_hygiene(id);

+use hir_def::{AdtId, ExpressionStoreOwner, GenericParamId};

+ owner: Option<ExpressionStoreOwner>,

+ let Some(body_owner) = def.0.as_def_with_body() else {

+ return Err(LayoutError::HasErrorType);

+ };

+ let infer = InferenceResult::for_body(db, body_owner);

+ let expr_id = const_ref.expr;

+ let expr = &self.store[expr_id];

+ match expr {

+ hir_def::hir::Expr::Path(path) => self

+ .path_to_const(path)

+ .unwrap_or_else(|| Const::new(self.interner, ConstKind::Error(ErrorGuaranteed))),

+ Const::new(self.interner, ConstKind::Error(ErrorGuaranteed))

+ _ => Const::new(self.interner, ConstKind::Error(ErrorGuaranteed)),

+ // Complex negation expression (e.g. `-N` where N is a const param)

+ self.lower_const_as_unevaluated(expr_id, const_type)

+ hir_def::hir::Expr::Underscore => {

+ Const::new(self.interner, ConstKind::Error(ErrorGuaranteed))

+ }

+ // Any other complex expression becomes an unevaluated anonymous const.

+ _ => self.lower_const_as_unevaluated(expr_id, const_type),

+ /// Lower a complex const expression to an `UnevaluatedConst` backed by an `AnonConstId`.

+ ///

+ /// The `expected_ty_ref` is `None` for array lengths (implicitly `usize`) or

+ /// `Some(type_ref_id)` for const generic arguments where the expected type comes

+ /// from the const parameter declaration.

+ fn lower_const_as_unevaluated(

+ &mut self,

+ _expr: hir_def::hir::ExprId,

+ _expected_ty: Ty<'db>,

+ ) -> Const<'db> {

+ // /// Build the identity generic args for the current generic context.

+ // ///

+ // /// This maps each generic parameter to itself (as a `ParamTy`, `ParamConst`,

+ // /// or `EarlyParamRegion`), which is the correct substitution when creating

+ // /// an `UnevaluatedConst` during type lowering — the anon const inherits the

+ // /// parent's generics and they haven't been substituted yet.

+ // fn current_generic_args(&self) -> GenericArgs<'db> {

+ // let generics = self.generics();

+ // let interner = self.interner;

+ // GenericArgs::new_from_iter(

+ // interner,

+ // generics.iter_id().enumerate().map(|(index, id)| match id {

+ // GenericParamId::TypeParamId(id) => {

+ // GenericArg::from(Ty::new_param(interner, id, index as u32))

+ // }

+ // GenericParamId::ConstParamId(id) => GenericArg::from(Const::new_param(

+ // interner,

+ // ParamConst { id, index: index as u32 },

+ // )),

+ // GenericParamId::LifetimeParamId(id) => GenericArg::from(Region::new_early_param(

+ // interner,

+ // EarlyParamRegion { id, index: index as u32 },

+ // )),

+ // }),

+ // )

+ // }

+ // let loc = AnonConstLoc { owner: self.def, expr };

+ // let id = loc.intern(self.db);

+ // let args = self.current_generic_args();

+ // Const::new(

+ // self.interner,

+ // ConstKind::Unevaluated(UnevaluatedConst::new(

+ // GeneralConstId::AnonConstId(id).into(),

+ // args,

+ // )),

+ // )

+ Const::new(self.interner, ConstKind::Error(ErrorGuaranteed))

+ }

+

+ self.ctx.store,

+ expr_store::ExpressionStore,

+ pub fn is_ref_span(&self, store: &ExpressionStore) -> bool {

+ MirSpan::ExprId(expr) => matches!(store[expr], Expr::Ref { .. }),

+ matches!(store[binding].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)

+use rustc_type_ir::inherent::{GenericArgs as _, Ty as _};

+ DbInterner, ErrorGuaranteed, GenericArgs, ParamEnv, StoredTy, Ty, TypingMode,

+ let InternedClosure(owner, _) = db.lookup_intern_closure(c);

+ let interner = DbInterner::new_no_crate(db);

+ let Some(def) = owner.as_def_with_body() else {

+ return Ty::new_error(interner, ErrorGuaranteed);

+ };

+ let InternedClosure(owner, _) = self.db.lookup_intern_closure(c);

+ let Some(def) = owner.as_def_with_body() else {

+ return Ty::new_error(self.interner(), ErrorGuaranteed);

+ };

+ GeneralConstId::AnonConstId(_) => {

+ not_supported!("anonymous const evaluation")

+ }

+ let InternedClosure(owner, _) = self.db.lookup_intern_closure(id.0);

+ let Some(closure_owner) = owner.as_def_with_body() else {

+ not_supported!("closure in non-body context");

+ };

+ GeneralConstId::AnonConstId(_) => {

+ return Err(MirLowerError::IncompleteExpr);

+ }

+ GeneralConstId::AnonConstId(_) => unreachable!("handled above"),

+ let body_owner =

+ owner.as_def_with_body().expect("MIR lowering should only happen for body-owned closures");

+ let body = db.body(body_owner);

+ let infer = InferenceResult::for_body(db, body_owner);

+ let mut ctx = MirLowerCtx::new(db, body_owner, &body.store, infer);

+ let resolver_guard = ctx.resolver.update_to_inner_scope(db, body_owner, expr);

+ AdtId, AnonConstId, AttrDefId, BuiltinDeriveImplId, CallableDefId, ConstId, DefWithBodyId,

+ EnumId, EnumVariantId, ExpressionStoreOwner, FunctionId, GeneralConstId, GenericDefId, ImplId,

+ StaticId, StructId, TraitId, TypeAliasId, UnionId,

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

+#[derive(PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash)]

+ AnonConstId(AnonConstId),

+ SolverDefId::AnonConstId(id) => f.debug_tuple("AnonConstId").field(&id).finish(),

+ AnonConstId,

+impl From<ExpressionStoreOwner> for SolverDefId {

+ fn from(value: ExpressionStoreOwner) -> Self {

+ match value {

+ ExpressionStoreOwner::Signature(generic_def_id) => generic_def_id.into(),

+ ExpressionStoreOwner::Body(def_with_body_id) => def_with_body_id.into(),

+ }

+ }

+}

+

+ GeneralConstId::AnonConstId(anon_const_id) => SolverDefId::AnonConstId(anon_const_id),

+ | SolverDefId::InternedOpaqueTyId(_)

+ | SolverDefId::AnonConstId(_) => Err(()),

+ | SolverDefId::AnonConstId(_)

+ | SolverDefId::AnonConstId(_)

+ GeneralConstId::AnonConstId(id) => SolverDefId::AnonConstId(id),

+ SolverDefId::AnonConstId(it) => Ok(Self(it.into())),

+ AdtId, CallableDefId, DefWithBodyId, EnumVariantId, ExpressionStoreOwner, HasModule,

+ ItemContainerId, StructId, UnionId, VariantId,

+ | SolverDefId::InternedCoroutineId(_)

+ | SolverDefId::AnonConstId(_) => {

+ SolverDefId::ConstId(_) | SolverDefId::AnonConstId(_) => {

+ AliasTermKind::UnevaluatedConst

+ }

+ return self.db().lookup_intern_closure(it).0.generic_def(self.db()).into();

+ return self.db().lookup_intern_coroutine(it).0.generic_def(self.db()).into();

+ | SolverDefId::InternedOpaqueTyId(..)

+ | SolverDefId::AnonConstId(_) => panic!(),

+ let Some(body_owner) = owner.as_def_with_body() else {

+ return rustc_ast_ir::Movability::Static;

+ };

+ let body = self.db.body(body_owner);

+ | SolverDefId::AnonConstId(_)

+ let Some(body_owner) = owner.as_def_with_body() else {

+ return false;

+ };

+ let body = self.db.body(body_owner);

+ let Some(body_owner) = owner.as_def_with_body() else {

+ return false;

+ };

+ let body = self.db.body(body_owner);

+ let coroutine = InternedCoroutineId::new(

+ self.db,

+ InternedCoroutine(ExpressionStoreOwner::Body(def_id), expr_id),

+ );

+ Const, DbInterner, ErrorGuaranteed, GenericArg, SolverDefId, Span,

+ // TODO: Wire up const_eval_anon query in Phase 5.

+ // For now, return an error const so normalization resolves the

+ // unevaluated const to Error (matching the old behavior where

+ // complex expressions produced ConstKind::Error directly).

+ GeneralConstId::AnonConstId(_) => Some(Const::error(self.cx())),

+ let krate = owner.krate(db);

+ AssocItemId, DefWithBodyId, GenericDefId, HasModule, Lookup, ModuleDefId, ModuleId,

+ SyntheticSyntax,

+ expr_store::{Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap},

+ store: &ExpressionStore,

+ source_map: &ExpressionStoreSourceMap,

+ self_param: Option<(

+ hir_def::hir::BindingId,

+ Option<InFile<hir_def::expr_store::SelfParamPtr>>,

+ )>,

+ if let Some((binding_id, syntax_ptr)) = self_param {

+ let ty = &inference_result.type_of_binding[binding_id];

+ if let Some(syntax_ptr) = syntax_ptr {

+ if let Pat::Bind { id, .. } = store[pat] {

+ let node = match source_map.pat_syntax(pat) {

+ let node = match source_map.expr_syntax(expr) {

+ let mut generic_defs: Vec<(GenericDefId, Crate)> = Vec::new();

+ let krate = module.krate(&db);

+ match it {

+ ModuleDefId::FunctionId(it) => {

+ defs.push((it.into(), krate));

+ generic_defs.push((it.into(), krate));

+ }

+ ModuleDefId::EnumVariantId(it) => {

+ defs.push((it.into(), krate));

+ }

+ ModuleDefId::ConstId(it) => {

+ defs.push((it.into(), krate));

+ generic_defs.push((it.into(), krate));

+ }

+ ModuleDefId::StaticId(it) => {

+ defs.push((it.into(), krate));

+ generic_defs.push((it.into(), krate));

+ }

+ ModuleDefId::AdtId(it) => {

+ generic_defs.push((it.into(), krate));

+ }

+ ModuleDefId::TraitId(it) => {

+ generic_defs.push((it.into(), krate));

+ }

+ ModuleDefId::TypeAliasId(it) => {

+ generic_defs.push((it.into(), krate));

+ }

+ _ => {}

+ }

+ // Also collect impls

+ for impl_id in def_map[module].scope.impls() {

+ generic_defs.push((impl_id.into(), module.krate(&db)));

+ let impl_data = impl_id.impl_items(&db);

+ for &(_, item) in impl_data.items.iter() {

+ match item {

+ AssocItemId::FunctionId(it) => {

+ generic_defs.push((it.into(), module.krate(&db)));

+ }

+ AssocItemId::ConstId(it) => {

+ generic_defs.push((it.into(), module.krate(&db)));

+ }

+ AssocItemId::TypeAliasId(it) => {

+ generic_defs.push((it.into(), module.krate(&db)));

+ }

+ }

+ }

+ }

+

+ let self_param = body.self_param.map(|id| (id, source_map.self_param_syntax()));

+ infer_def(infer, &body, &source_map, self_param, krate);

+ }

+

+ // Also infer signature const expressions (array lengths, const generic args, etc.)

+ generic_defs.dedup();

+ for (def, krate) in generic_defs {

+ let (_, store, source_map) = db.generic_params_and_store_and_source_map(def);

+ // Skip if there are no const expressions in the signature

+ if store.const_expr_origins().is_empty() {

+ continue;

+ }

+ let infer = InferenceResult::for_signature(&db, def);

+ infer_def(infer, &store, &source_map, None, krate);

+ let body_owner = closure.0.as_def_with_body().unwrap();

+ let source_map = db.body_with_source_map(body_owner).1;

+ let (body, source_map) = db.body_with_source_map(body_owner);

+ let place = capture.display_place(body_owner, db);

+ "body_expr_scopes_shim",

+ "body_expr_scopes_shim",

+ "body_expr_scopes_shim",

+ "body_expr_scopes_shim",

+ "body_expr_scopes_shim",

+ "body_expr_scopes_shim",

+ "body_expr_scopes_shim",

+ 199..200 '3': usize

+ 62..63 'N': usize

+ 512..513 'N': usize

+ 322..323 '1': usize

+ 205..206 '_': usize

+ 156..157 'N': usize

+ 320..335 '{ Consts::MAX }': usize

+ 322..333 'Consts::MAX': usize

+ 421..422 '0': i32

+ 144..159 '{ Consts::MAX }': usize

+ 146..157 'Consts::MAX': usize

+ 33..34 '2': usize

+ 111..112 '3': usize

+ 197..202 '{ 0 }': usize

+ 199..200 '0': usize

+

+#[test]

+fn signature_inference() {

+ check_infer(

+ r#"

+trait Trait<const A: u8> {}

+struct S<T: Trait<2>, const C: f32 = 0.0>

+where

+ (): Trait<2>

+{

+ field: [(); { C as usize }],

+ field2: *mut S<T, 5.0>

+}

+

+struct S2<const C: u16>;

+

+type Alias = S2<0>;

+impl S2<0> {}

+enum E {

+ V(S2<0>) = 0,

+}

+union U {

+ field: S2<0>

+}

+ "#,

+ expect![[r#"

+ 242..243 '0': isize

+ 46..47 '2': i32

+ 65..68 '0.0': f32

+ 90..91 '2': i32

+ 200..201 '0': i32

+ 212..213 '0': i32

+ "#]],

+ );

+}

+ 46..47 '2': usize

+ 86..87 '4': usize

+ 192..193 '2': usize

+ 130..131 'L': usize

+ 102..103 'L': usize

+ 130..131 'L': usize

+ let body_owner = owner.as_def_with_body()?;

+ let (_, source_map) = db.body_with_source_map(body_owner);

+ pub fn as_generic_def(self) -> Option<GenericDef> {

+ match self {

+ ModuleDef::Function(it) => Some(it.into()),

+ ModuleDef::Adt(it) => Some(it.into()),

+ ModuleDef::Trait(it) => Some(it.into()),

+ ModuleDef::TypeAlias(it) => Some(it.into()),

+ ModuleDef::Static(it) => Some(it.into()),

+ ModuleDef::Const(it) => Some(it.into()),

+ ModuleDef::Variant(_)

+ | ModuleDef::Module(_)

+ | ModuleDef::BuiltinType(_)

+ | ModuleDef::Macro(_) => None,

+ }

+ }

+

+ self.source(db)?.value.const_arg()?.expr()

+ let body_owner = c.0.as_def_with_body()?;

+ let body = db.body(body_owner);

+ return Some(Local { parent: body_owner, binding_id: *id });

+ pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {

+ match self {

+ GenericDef::Function(it) => Some(it.name(db)),

+ GenericDef::Adt(it) => Some(it.name(db)),

+ GenericDef::Trait(it) => Some(it.name(db)),

+ GenericDef::TypeAlias(it) => Some(it.name(db)),

+ GenericDef::Impl(_) => None,

+ GenericDef::Const(it) => it.name(db),

+ GenericDef::Static(it) => Some(it.name(db)),

+ }

+ }

+

+ pub fn module(self, db: &dyn HirDatabase) -> Module {

+ match self {

+ GenericDef::Function(it) => it.module(db),

+ GenericDef::Adt(it) => it.module(db),

+ GenericDef::Trait(it) => it.module(db),

+ GenericDef::TypeAlias(it) => it.module(db),

+ GenericDef::Impl(it) => it.module(db),

+ GenericDef::Const(it) => it.module(db),

+ GenericDef::Static(it) => it.module(db),

+ }

+ }

+

+ let Some(body_owner) = owner.as_def_with_body() else {

+ return Vec::new();

+ };

+ let infer = InferenceResult::for_body(db, body_owner);

+ owner: body_owner,

+ let Some(body_owner) = owner.as_def_with_body() else {

+ return Vec::new();

+ };

+ let infer = InferenceResult::for_body(db, body_owner);

+ let env = body_param_env_from_has_crate(db, body_owner);

+ let Some(body_owner) = owner.as_def_with_body() else {

+ return FnTrait::FnOnce;

+ };

+ let infer = InferenceResult::for_body(db, body_owner);

+ infer: bool,

+ return Some(if infer {

+ return Some(if infer {

+ SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset)

+ } else {

+ SourceAnalyzer::new_generic_def_no_infer(self.db, it.into(), node, offset)

+ });

+ return Some(if infer {

+ SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset)

+ } else {

+ SourceAnalyzer::new_generic_def_no_infer(self.db, it.into(), node, offset)

+ });

+ return Some(if infer {

+ SourceAnalyzer::new_generic_def(self.db, it.into(), node, offset)

+ } else {

+ SourceAnalyzer::new_generic_def_no_infer(self.db, it.into(), node, offset)

+ });

+ return Some(if infer {

+ SourceAnalyzer::new_generic_def(self.db, it, node, offset)

+ } else {

+ SourceAnalyzer::new_generic_def_no_infer(self.db, it, node, offset)

+ });

+ hir::{BindingId, Expr, ExprId, ExprOrPatId, Pat, PatId, generics::GenericParams},

+ infer: Option<&'db InferenceResult>,

+ #[expect(dead_code)]

+ generics: Arc<GenericParams>,

+ let scopes = db.expr_scopes(def.into());

+ node: InFile<&SyntaxNode>,

+ offset: Option<TextSize>,

+ Self::new_generic_def_(db, def, node, offset, true)

+ }

+

+ pub(crate) fn new_generic_def_no_infer(

+ db: &'db dyn HirDatabase,

+ def: GenericDefId,

+ node: InFile<&SyntaxNode>,

+ offset: Option<TextSize>,

+ ) -> SourceAnalyzer<'db> {

+ Self::new_generic_def_(db, def, node, offset, false)

+ }

+

+ pub(crate) fn new_generic_def_(

+ db: &'db dyn HirDatabase,

+ def: GenericDefId,

+ node @ InFile { file_id, .. }: InFile<&SyntaxNode>,

+ offset: Option<TextSize>,

+ infer: bool,

+ ) -> SourceAnalyzer<'db> {

+ let (generics, store, source_map) = db.generic_params_and_store_and_source_map(def);

+ let scopes = db.expr_scopes(def.into());

+ let scope = match offset {

+ None => scope_for(db, &scopes, &source_map, node),

+ Some(offset) => {

+ debug_assert!(

+ node.text_range().contains_inclusive(offset),

+ "{:?} not in {:?}",

+ offset,

+ node.text_range()

+ );

+ scope_for_offset(db, &scopes, &source_map, node.file_id, offset)

+ }

+ };

+ let resolver = resolver_for_scope(db, def, scope);

+ let infer = if infer && !Arc::ptr_eq(&store, &ExpressionStore::empty_singleton().0) {

+ Some(InferenceResult::for_signature(db, def))

+ } else {

+ None

+ };

+ body_or_sig: Some(BodyOrSig::Sig { def, store, source_map, generics, infer }),

+ BodyOrSig::Sig { infer, .. } | BodyOrSig::Body { infer, .. } => infer.as_deref(),

+ self.param_and(self.body_or_sig.as_ref().map_or_else(ParamEnv::empty, |body_or_sig| {

+ match *body_or_sig {

+ BodyOrSig::Body { def, .. } => db.trait_environment_for_body(def),

+ BodyOrSig::VariantFields { .. } => ParamEnv::empty(),

+ BodyOrSig::Sig { def, .. } => db.trait_environment(def),

+ }

+ }))

+ let binding = match self.body_or_sig.as_ref()? {

+ BodyOrSig::Sig { .. } | BodyOrSig::VariantFields { .. } => return None,

+ BodyOrSig::Body { body, .. } => body.self_param?,

+ };

+ let mut collector = ExprCollector::body(db, self.resolver.module(), self.file_id);

+ let mut collector = ExprCollector::body(db, self.resolver.module(), self.file_id);

+ source_map: &ExpressionStoreSourceMap,

+ source_map: &ExpressionStoreSourceMap,

+ source_map: &ExpressionStoreSourceMap,

+ if variant_list.variants().all(|variant_node| variant_node.const_arg().is_some()) {

+ if let Some(expr) = variant_node.const_arg()

+ && let Some(expr) = expr.expr()

+ {

+ if variant.const_arg().is_some() {

+<span class="keyword">fn</span> <span class="function declaration">const_param</span><span class="angle">&lt;</span><span class="keyword const">const</span> <span class="const_param const declaration">FOO</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">usize</span> <span class="keyword">where</span> <span class="bracket">[</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span> <span class="const_param const">FOO</span><span class="bracket">]</span><span class="colon">:</span> <span class="trait default_library library">Sized</span> <span class="brace">{</span>

+fn const_param<const FOO: usize>() -> usize where [(); FOO]: Sized {

+ let m = p.start();

+ m.complete(p, CONST_ARG);

+ let m = p.start();

+ m.complete(p, CONST_ARG);

+ CONST_ARG

+ LITERAL

+ FLOAT_NUMBER "0.0"

+ CONST_ARG

+ LITERAL

+ INT_NUMBER "10"

+ CONST_ARG

+ LITERAL

+ INT_NUMBER "92"

+ Adt, AssocItem, Crate, DefWithBody, FindPathConfig, GenericDef, HasCrate, HasSource,

+ HirDisplay, ModuleDef, Name, crate_lang_items,

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

+ if let Some(g) = decl.as_generic_def() {

+ signatures.push(g);

+ }

+ signatures.push(impl_def.into());

+ AssocItem::Function(f) => {

+ bodies.push(DefWithBody::from(f));

+ signatures.push(f.into())

+ }

+ signatures.push(c.into());

+ AssocItem::TypeAlias(t) => signatures.push(t.into()),

+ ", mods: {}, decls: {num_decls}, bodies: {}, adts: {}, consts: {}, signatures: {}",

+ signatures.len(),

+ self.run_body_lowering(db, &vfs, &bodies, &signatures, verbosity);

+ self.run_inference(db, &vfs, &bodies, &signatures, verbosity);

+ self.run_mir_lowering(db, &bodies, &signatures, verbosity);

+ self.run_const_eval(db, &bodies, &signatures, verbosity);

+ fn run_const_eval(

+ &self,

+ db: &RootDatabase,

+ bodies: &[DefWithBody],

+ _signatures: &[GenericDef],

+ verbosity: Verbosity,

+ ) {

+ bar.set_message(move || {

+ format!("const eval: {}", full_name(db, || b.name(db), b.module(db)))

+ });

+ fn run_mir_lowering(

+ &self,

+ db: &RootDatabase,

+ bodies: &[DefWithBody],

+ _signatures: &[GenericDef],

+ verbosity: Verbosity,

+ ) {

+ format!("mir lowering: {}", full_name(db, || body.name(db), body.module(db)))

+ if !self.should_process(db, || body.name(db), module) {

+ signatures: &[GenericDef],

+ let signatures = signatures

+ .iter()

+ .filter_map(|&signatures| signatures.try_into().ok())

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

+ signatures

+ .par_iter()

+ .map_with(db.clone(), |snap, &signatures| {

+ InferenceResult::for_signature(snap, signatures);

+ })

+ .count();

+ && full_name(db, || body_id.name(db), module) != only_name

+ full_name(db, || body_id.name(db), module),

+ format!("processing: {}", full_name(db, || body_id.name(db), module))

+ format!("processing: {}", full_name(db, || body_id.name(db), module))

+ eprintln!(

+ "infer panicked for {}: {}",

+ full_name(db, || body_id.name(db), module),

+ s

+ );

+ eprintln!(

+ "infer panicked for {}: {}",

+ full_name(db, || body_id.name(db), module),

+ s

+ );

+ eprintln!(

+ "infer panicked for {}",

+ full_name(db, || body_id.name(db), module)

+ );

+ full_name(db, || body_id.name(db), module),

+ full_name(db, || body_id.name(db), module),

+ signatures: &[GenericDef],

+ _ => ProgressReport::new(bodies.len() + signatures.len()),

+ for &signature in signatures {

+ let Ok(signature_id) = signature.try_into() else { continue };

+ let module = signature.module(db);

+ if !self.should_process(db, || signature.name(db), module) {

+ continue;

+ }

+ let msg = move || {

+ if verbosity.is_verbose() {

+ let source = match signature {

+ GenericDef::Function(it) => it.source(db).map(|it| it.syntax().cloned()),

+ GenericDef::Static(it) => it.source(db).map(|it| it.syntax().cloned()),

+ GenericDef::Const(it) => it.source(db).map(|it| it.syntax().cloned()),

+ GenericDef::Adt(adt) => adt.source(db).map(|it| it.syntax().cloned()),

+ GenericDef::Trait(it) => it.source(db).map(|it| it.syntax().cloned()),

+ GenericDef::TypeAlias(type_alias) => {

+ type_alias.source(db).map(|it| it.syntax().cloned())

+ }

+ GenericDef::Impl(it) => it.source(db).map(|it| it.syntax().cloned()),

+ };

+ if let Some(src) = source {

+ let original_file = src.file_id.original_file(db);

+ let path = vfs.file_path(original_file.file_id(db));

+ let syntax_range = src.text_range();

+ format!(

+ "processing: {} ({} {:?})",

+ full_name(db, || signature.name(db), module),

+ path,

+ syntax_range

+ )

+ } else {

+ format!("processing: {}", full_name(db, || signature.name(db), module))

+ }

+ } else {

+ format!("processing: {}", full_name(db, || signature.name(db), module))

+ }

+ };

+ if verbosity.is_spammy() {

+ bar.println(msg());

+ }

+ bar.set_message(msg);

+ db.generic_params_and_store(signature_id);

+ bar.inc(1);

+ }

+

+ if !self.should_process(db, || body_id.name(db), module) {

+ full_name(db, || body_id.name(db), module),

+ format!("processing: {}", full_name(db, || body_id.name(db), module))

+ format!("processing: {}", full_name(db, || body_id.name(db), module))

+ eprintln!("{:<20} {}", "Expression Store Lowering:", body_lowering_time);

+ fn should_process(

+ &self,

+ db: &RootDatabase,

+ name_fn: impl Fn() -> Option<Name>,

+ module: hir::Module,

+ ) -> bool {

+ let name = name_fn().unwrap_or_else(Name::missing);

+ && full_name(db, name_fn, module) != only_name

+fn full_name(db: &RootDatabase, name: impl Fn() -> Option<Name>, module: hir::Module) -> String {

+ .chain(Some(name().unwrap_or_else(Name::missing)))

+ Name ':' Type ('=' default_val:ConstArg)?

+ Name FieldList? ('=' ConstArg)?

+ pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) }

+ pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }

+ builder.map_node(

+ discriminant.syntax().clone(),

+ ast.const_arg().unwrap().syntax().clone(),

+ );