+[profile.default]

+slow-timeout = { period = "60s", terminate-after = 5 }

+ run: cargo nextest run --no-fail-fast --hide-progress-bar

+ env:

+ RUSTC_BOOTSTRAP: 1

+ rustup update --no-self-update stable

+ rustup default stable

+ rustup component add --toolchain stable rust-src rustc-dev rustfmt

+ rustup toolchain install stable --component llvm-tools-preview

+vendor/

+inh = "inh"

+name = "foldhash"

+version = "0.2.0"

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

+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"

+

+[[package]]

+ "foldhash 0.1.5",

+name = "hashbrown"

+version = "0.17.0"

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

+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"

+dependencies = [

+ "allocator-api2",

+ "equivalent",

+ "foldhash 0.2.0",

+]

+

+[[package]]

+ "bitflags 2.9.4",

+ "arrayvec",

+version = "0.3.24"

+checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"

+ "windows-sys 0.61.0",

+version = "0.165.0"

+checksum = "2f25a779e21ca3bba6795193b16508c8ab159f96ee4b07349893fd272065b525"

+version = "0.165.0"

+checksum = "0218ca6c7b096466e85a497e6150c39be5b7bc36637fe62c1cd20370a9d9aac7"

+version = "0.165.0"

+checksum = "d6b410bacf1a7c8038f376fa6283003784d568ac012e35fc0aeefa9a5ab11a2e"

+version = "0.165.0"

+checksum = "2271b55e4a5d0cc0cbe9bdf8056c07ac69e32919a48ce66722ed0526d62588c3"

+version = "0.165.0"

+checksum = "b6a89e743fb881a1e13544e3395a5ad9ad9280d56384256a121066119abd7af2"

+version = "0.165.0"

+checksum = "a6d7c9cc05e0e6b72a214a455a106d9b22b0494164d50a657b17bd319534c218"

+version = "0.165.0"

+checksum = "cb3017c2f0ace80b8e6068b9c613aa56ed50e0374bf44a891447511f1264e40d"

+version = "0.165.0"

+checksum = "4a737f844bdef8ac5ab54dadf2f34704b4d06beef9236d71080bb34db697220b"

+version = "0.165.0"

+checksum = "6de3d4c7d6078cce3c40c55717b8b15002a80b9fa8849faea496a365324861b4"

+version = "0.165.0"

+checksum = "8c5d9a4d3e7bee7313599bc6d794037247ac0165f03857379cf4fc3097199e05"

+version = "0.165.0"

+checksum = "024598d1f54272acd83d28c121f8a2e82e216dd7be1e40158b66b2d12fa214c0"

+ "windows-sys 0.61.0",

+version = "0.26.2"

+checksum = "4612ff789805e65c87e9b38cb749a293212a615af065bed8a2001086801498c3"

+ "hashbrown 0.17.0",

+ "typeid",

+version = "0.26.2"

+checksum = "58e354cbac6939b9b09cd9c11fb419a53e64b4a0f755d929f56a09f4cc752e41"

+version = "0.26.2"

+checksum = "3067861075c2b80608f84ad49fb88f2c7610b94cdf8b4201e79ddee87f8980c8"

+ "windows-sys 0.61.0",

+ "expect-test",

+name = "typeid"

+version = "1.0.3"

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

+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"

+

+[[package]]

+rust-version = "1.95"

+ra-ap-rustc_lexer = { version = "0.165", default-features = false }

+ra-ap-rustc_parse_format = { version = "0.165", default-features = false }

+ra-ap-rustc_index = { version = "0.165", default-features = false }

+ra-ap-rustc_abi = { version = "0.165", default-features = false }

+ra-ap-rustc_pattern_analysis = { version = "0.165", default-features = false }

+ra-ap-rustc_ast_ir = { version = "0.165", default-features = false }

+ra-ap-rustc_type_ir = { version = "0.165", default-features = false }

+ra-ap-rustc_next_trait_solver = { version = "0.165", default-features = false }

+salsa = { version = "0.26.2", default-features = false, features = [

+salsa-macros = "0.26.2"

+//- minicore: fn, iterator, try, panic

+pub use vfs::{AbsPathBuf, AnchoredPath, AnchoredPathBuf, FileId, VfsPath, file_set::FileSet};

+ "must_use" => attr_flags.insert(AttrFlags::IS_MUST_USE),

+ "rustc_reservation_impl" => attr_flags.insert(AttrFlags::RUSTC_RESERVATION_IMPL),

+ "must_use" => attr_flags.insert(AttrFlags::IS_MUST_USE),

+ "diagnostic" => match &*second_segment {

+ "do_not_recommend" => {

+ attr_flags.insert(AttrFlags::DIAGNOSTIC_DO_NOT_RECOMMEND)

+ }

+ _ => {}

+ },

+

+ const IS_MUST_USE = 1 << 50;

+

+ const DIAGNOSTIC_DO_NOT_RECOMMEND = 1 << 51;

+ Self::repr_assume_has(db, owner)

+ }

+ /// Only call this when you've verified the type indeed has a `#[repr]` attribute!

+ ///

+ /// Prefer [`AttrFlags::repr()`] in non-perf-sensitive places as it also has a check that

+ /// that the ADT has repr.

+ #[salsa::tracked]

+ pub fn repr_assume_has(db: &dyn DefDatabase, owner: AdtId) -> Option<ReprOptions> {

+ let mut result = None;

+ collect_attrs::<Infallible>(db, owner.into(), |attr| {

+ let mut current = None;

+ if let ast::Meta::TokenTreeMeta(attr) = &attr

+ && let Some(path) = attr.path()

+ && let Some(tt) = attr.token_tree()

+ {

+ if path.is1("repr")

+ && let Some(repr) = parse_repr_tt(&tt)

+ current = Some(repr);

+ } else if path.is1("rustc_scalable_vector")

+ && let mut tt = TokenTreeChildren::new(&tt)

+ && let Some(NodeOrToken::Token(scalable)) = tt.next()

+ && let Some(scalable) = ast::IntNumber::cast(scalable)

+ && let Ok(scalable) = scalable.value()

+ && let Ok(scalable) = scalable.try_into()

+ scalable: Some(rustc_abi::ScalableElt::ElementCount(scalable)),

+ } else if let ast::Meta::PathMeta(attr) = &attr

+ && attr.path().is1("rustc_scalable_vector")

+ {

+ current = Some(ReprOptions {

+ scalable: Some(rustc_abi::ScalableElt::Container),

+ ..ReprOptions::default()

+ });

+ }

+ if let Some(current) = current {

+ match &mut result {

+ Some(existing) => merge_repr(existing, current),

+ None => result = Some(current),

+ }

+ ControlFlow::Continue(())

+ });

+ result

+

+ /// Returns `None` if there is no `#[must_use]`, `Some(None)` if there is a `#[must_use]` without a message,

+ /// and `Some(Some(message))` if there is a `#[must_use]` with a message.

+ pub fn must_use_message(db: &dyn DefDatabase, owner: AttrDefId) -> Option<Option<&str>> {

+ if !AttrFlags::query(db, owner).contains(AttrFlags::IS_MUST_USE) {

+ return None;

+ }

+ return Some(must_use_message(db, owner));

+

+ #[salsa::tracked(returns(as_deref))]

+ fn must_use_message(db: &dyn DefDatabase, owner: AttrDefId) -> Option<Box<str>> {

+ collect_attrs(db, owner, |attr| {

+ if let ast::Meta::KeyValueMeta(attr) = attr

+ && attr.path().is1("must_use")

+ && let Some(message) = attr.value_string()

+ {

+ return ControlFlow::Break(Box::from(&*message));

+ }

+ ControlFlow::Continue(())

+ })

+ }

+ }

+ span_map: SpanMap<'db>,

+ let parse = expander.db.parse_macro_expansion(call_id).value.0.clone();

+ AssocItemId, AttrDefId, Macro2Loc, MacroExpander, MacroId, MacroRulesLoc, MacroRulesLocFlags,

+ TraitId,

+ item_tree::{ItemTree, file_item_tree},

+pub trait DefDatabase: ExpandDatabase + SourceDatabase {

+ #[salsa::invoke(file_item_tree)]

+ .filter_map(|invoc| invoc.1.loc(db).include_file_id(db, *invoc.1).map(|x| (*invoc.1, x)))

+use std::{

+ borrow::Borrow,

+ ops::{Deref, Index},

+};

+ expr_store::path::{AssociatedTypeBinding, GenericArg, GenericArgs, NormalPath, Path},

+ Array, AsmOperand, Binding, BindingId, Expr, ExprId, ExprOrPatId, InlineAsm, Label,

+ LabelId, MatchArm, OffsetOf, Pat, PatId, RecordFieldPat, RecordLitField, RecordSpread,

+ Statement,

+ type_ref::{

+ ArrayType, ConstRef, FnType, LifetimeRef, LifetimeRefId, PathId, RefType, TypeBound,

+ TypeRef, TypeRefId, UseArgRef,

+ },

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

+struct ExprRoot {

+ root: ExprId,

+ // We store, for each root, the range of exprs (and pats and bindings) it holds.

+ // We store only the end (exclusive), since the start can be inferred from the previous

+ // roots or is zero.

+ exprs_end: ExprId,

+ pats_end: PatId,

+ bindings_end: BindingId,

+ ///

+ /// Note: while every root expr is an inference root (aka. an `AnonConst`), there could be other roots that do not appear here.

+ /// This can happen when anon consts are nested, for example:

+ ///

+ /// ```

+ /// [

+ /// ();

+ /// {

+ /// // this repeat expr is anon const #1, and *only it* appears in this list.

+ /// [

+ /// ();

+ /// {

+ /// // this repeat expr is anon const #2.

+ /// 0

+ /// }

+ /// ];

+ /// 0

+ /// }

+ /// ]

+ /// ```

+ /// We do this because this allows us to search this list using a binary search,

+ /// and it does not bother us because we use this list for two things: constructing `ExprScopes`, which

+ /// works fine with nested exprs, and retrieving inference results, and we copy the inner const's inference

+ /// into the outer const.

+ // FIXME: Array repeat is not problematic indeed, but this could still break with exprs in types,

+ // which we do not visit for `ExprScopes` (they're fine for inference though). We either need to visit them,

+ // or use a more complicated search.

+ expr_roots: SmallVec<[ExprRoot; 1]>,

+ inference_roots: Option<SmallVec<[ExprRoot; 1]>>,

+ PatternArgInExternFn { node: InFile<AstPtr<ast::Pat>> },

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

+ expr_roots.shrink_to_fit();

+ expr_roots: expr_roots

+ .expect("should always finish with a `Some(_)` expr_roots"),

+ const EMPTY: &ExpressionStore =

+ &ExpressionStore { expr_only: None, types: Arena::new(), lifetimes: Arena::new() };

+

+ #[inline]

+ pub fn empty() -> &'static ExpressionStore {

+ ExpressionStore::EMPTY

+ }

+

+ pub fn expr_roots(&self) -> impl DoubleEndedIterator<Item = ExprId> {

+ self.expr_only

+ .as_ref()

+ .map_or(&[][..], |expr_only| &expr_only.expr_roots)

+ .iter()

+ .map(|root| root.root)

+ fn find_root_for(

+ &self,

+ mut get: impl FnMut(&ExprRoot) -> la_arena::RawIdx,

+ find: la_arena::RawIdx,

+ ) -> ExprId {

+ let expr_only = self.assert_expr_only();

+ let find = find.into_u32();

+ let entry = expr_only.expr_roots.partition_point(|root| get(root).into_u32() <= find);

+ expr_only.expr_roots[entry].root

+ pub fn find_root_for_expr(&self, expr: ExprId) -> ExprId {

+ self.find_root_for(|root| root.exprs_end.into_raw(), expr.into_raw())

+ }

+

+ pub fn find_root_for_pat(&self, pat: PatId) -> ExprId {

+ self.find_root_for(|root| root.pats_end.into_raw(), pat.into_raw())

+ }

+

+ pub fn find_root_for_binding(&self, binding: BindingId) -> ExprId {

+ self.find_root_for(|root| root.bindings_end.into_raw(), binding.into_raw())

+ pub fn visit_pat_children(&self, pat_id: PatId, mut visitor: impl StoreVisitor) {

+ // Do not use `..` patterns or field accesses here, only destructuring, to ensure we cover all cases

+ // (we've had multiple bugs with this in the past).

+ Pat::Range { start, end, range_type: _ } => {

+ visitor.on_expr_opt(*start);

+ visitor.on_expr_opt(*end);

+ Pat::Lit(expr) | Pat::ConstBlock(expr) | Pat::Expr(expr) => visitor.on_expr(*expr),

+ Pat::Path(_) | Pat::Wild | Pat::Missing | Pat::Rest => {}

+ &Pat::Bind { subpat, id: _ } => visitor.on_pat_opt(subpat),

+ Pat::Or(args) | Pat::Tuple { args, ellipsis: _ } => visitor.on_pats(args),

+ Pat::TupleStruct { args, ellipsis: _, path } => {

+ visitor.on_pats(args);

+ visitor.on_path(path);

+ Pat::Ref { pat, mutability: _ } => visitor.on_pat(*pat),

+ visitor.on_pats(prefix);

+ visitor.on_pat_opt(*slice);

+ visitor.on_pats(suffix);

+ Pat::Record { args, ellipsis: _, path } => {

+ args.iter().for_each(|RecordFieldPat { pat, name: _ }| visitor.on_pat(*pat));

+ visitor.on_path(path);

+ }

+ Pat::Box { inner } | Pat::Deref { inner } => visitor.on_pat(*inner),

+ }

+ }

+

+ pub fn walk_pats_shallow(&self, pat_id: PatId, f: impl FnMut(PatId)) {

+ return self.visit_pat_children(pat_id, Visitor(f));

+

+ struct Visitor<F>(F);

+

+ impl<F: FnMut(PatId)> StoreVisitor for Visitor<F> {

+ fn on_pat(&mut self, pat: PatId) {

+ (self.0)(pat);

+ pub fn visit_expr_children(&self, expr_id: ExprId, mut visitor: impl StoreVisitor) {

+ // Do not use `..` patterns or field accesses here, only destructuring, to ensure we cover all cases

+ // (we've had multiple bugs with this in the past).

+ match &self[expr_id] {

+ Expr::OffsetOf(OffsetOf { container, fields: _ }) => visitor.on_type(*container),

+ Expr::Path(path) => visitor.on_path(path),

+ Expr::Continue { label: _ } | Expr::Missing | Expr::Literal(_) | Expr::Underscore => {}

+ Expr::InlineAsm(InlineAsm { operands, options: _, kind: _ }) => {

+ operands.iter().for_each(|(_, op)| match op {

+ AsmOperand::In { expr, reg: _ }

+ | AsmOperand::Out { expr: Some(expr), late: _, reg: _ }

+ | AsmOperand::InOut { expr, late: _, reg: _ }

+ | AsmOperand::Const(expr)

+ | AsmOperand::Label(expr) => visitor.on_expr(*expr),

+ AsmOperand::SplitInOut { in_expr, out_expr, late: _, reg: _ } => {

+ visitor.on_expr(*in_expr);

+ visitor.on_expr_opt(*out_expr);

+ AsmOperand::Out { expr: None, late: _, reg: _ } | AsmOperand::Sym(_) => (),

+ })

+ }

+ visitor.on_expr(*condition);

+ visitor.on_expr(*then_branch);

+ visitor.on_expr_opt(*else_branch);

+ visitor.on_pat(*pat);

+ visitor.on_expr(*expr);

+ Expr::Block { statements, tail, id: _, label: _ }

+ | Expr::Unsafe { statements, tail, id: _ } => {

+ for stmt in statements {

+ Statement::Let { initializer, else_branch, pat, type_ref } => {

+ visitor.on_expr_opt(*initializer);

+ visitor.on_expr_opt(*else_branch);

+ visitor.on_pat(*pat);

+ visitor.on_type_opt(*type_ref);

+ }

+ Statement::Expr { expr: expression, has_semi: _ } => {

+ visitor.on_expr(*expression)

+ visitor.on_expr_opt(*tail);

+ Expr::Loop { body, label: _ } => visitor.on_expr(*body),

+ Expr::Call { callee, args } => {

+ visitor.on_expr(*callee);

+ visitor.on_exprs(args);

+ Expr::MethodCall { receiver, args, generic_args, method_name: _ } => {

+ visitor.on_expr(*receiver);

+ visitor.on_exprs(args);

+ visitor.on_generic_args_opt(generic_args);

+ visitor.on_expr(*expr);

+ arms.iter().for_each(|MatchArm { pat, guard, expr }| {

+ visitor.on_expr(*expr);

+ visitor.on_expr_opt(*guard);

+ visitor.on_pat(*pat);

+ Expr::Break { expr, label: _ }

+ | Expr::Yeet { expr } => visitor.on_expr_opt(*expr),

+ Expr::Become { expr } => visitor.on_expr(*expr),

+ Expr::RecordLit { fields, spread, path } => {

+ for RecordLitField { name: _, expr } in fields.iter() {

+ visitor.on_expr(*expr);

+ match spread {

+ RecordSpread::Expr(expr) => visitor.on_expr(*expr),

+ RecordSpread::None | RecordSpread::FieldDefaults => {}

+ visitor.on_path(path);

+ Expr::Closure { body, args, arg_types, ret_type, capture_by: _, closure_kind: _ } => {

+ visitor.on_expr(*body);

+ visitor.on_pats(args);

+ arg_types.iter().for_each(|arg_type| visitor.on_type_opt(*arg_type));

+ visitor.on_type_opt(*ret_type);

+ Expr::BinaryOp { lhs, rhs, op: _ } => {

+ visitor.on_expr(*lhs);

+ visitor.on_expr(*rhs);

+ Expr::Range { lhs, rhs, range_type: _ } => {

+ visitor.on_expr_opt(*lhs);

+ visitor.on_expr_opt(*rhs);

+ Expr::Index { base, index } => {

+ visitor.on_expr(*base);

+ visitor.on_expr(*index);

+ Expr::Cast { expr, type_ref } => {

+ visitor.on_expr(*expr);

+ visitor.on_type(*type_ref);

+ }

+ Expr::Field { expr, name: _ }

+ | Expr::Ref { expr, mutability: _, rawness: _ }

+ | Expr::UnaryOp { expr, op: _ }

+ | Expr::Box { expr }

+ | Expr::Const(expr) => {

+ visitor.on_expr(*expr);

+ Expr::Tuple { exprs } => visitor.on_exprs(exprs),

+ Array::ElementList { elements } => visitor.on_exprs(elements),

+ visitor.on_expr(*initializer);

+ visitor.on_anon_const_expr(*repeat)

+ visitor.on_pat(target);

+ visitor.on_expr(value);

+ /// Walks the immediate children expressions and calls `f` for each child expression.

+ pub fn walk_child_exprs(&self, expr_id: ExprId, callback: impl FnMut(ExprId)) {

+ return self.visit_expr_children(expr_id, Visitor { callback, store: self });

+

+ struct Visitor<'a, F> {

+ callback: F,

+ store: &'a ExpressionStore,

+ }

+

+ impl<F: FnMut(ExprId)> StoreVisitor for Visitor<'_, F> {

+ fn on_expr(&mut self, expr: ExprId) {

+ (self.callback)(expr);

+

+ fn on_pat(&mut self, pat: PatId) {

+ self.store.walk_exprs_in_pat(pat, &mut self.callback);