+

+[COMMIT_EDITMSG]

+max_line_length = unset

+ if: ${{ github.repository == 'rust-lang/rust-analyzer' || github.event_name == 'workflow_dispatch' }}

+ - 'crates/tt/**'

+ proc-macro-srv:

+ if: github.repository == 'rust-lang/rust-analyzer' && needs.changes.outputs.proc_macros == 'true'

+ name: proc-macro-srv

+ runs-on: ubuntu-latest

+ steps:

+ - name: Checkout repository

+ uses: actions/checkout@v4

+ with:

+ ref: ${{ github.event.pull_request.head.sha }}

+

+ - name: Install Rust toolchain

+ run: |

+ rustup update --no-self-update nightly

+ rustup default nightly

+ rustup component add --toolchain nightly rust-src rustfmt

+ # https://github.com/actions-rust-lang/setup-rust-toolchain/blob/main/rust.json

+ - name: Install Rust Problem Matcher

+ if: matrix.os == 'ubuntu-latest'

+ run: echo "::add-matcher::.github/rust.json"

+

+ - name: Cache Dependencies

+ uses: Swatinem/rust-cache@9bdad043e88c75890e36ad3bbc8d27f0090dd609

+

+ - name: Bump opt-level

+ if: matrix.os == 'ubuntu-latest'

+ run: sed -i '/\[profile.dev]/a opt-level=1' Cargo.toml

+

+ - name: Test

+ run: cargo test --features sysroot-abi -p rust-analyzer -p proc-macro-srv -p proc-macro-srv-cli -p proc-macro-api -- --quiet

+

+ rust:

+ rustup update --no-self-update stable

+ rustup default stable

+ rustup component add --toolchain stable rust-src

+ rustup toolchain install nightly --profile minimal --component rustfmt

+ run: cargo test --no-run --locked

+ run: cargo build --quiet

+ run: cargo test -- --quiet

+ if: github.repository == 'rust-lang/rust-analyzer' && needs.changes.outputs.typescript == 'true'

+ node-version: 22

+ if: matrix.os == 'ubuntu-latest'

+ if: matrix.os == 'ubuntu-latest'

+ if: matrix.os == 'windows-latest'

+ needs: [rust, rust-cross, typescript, typo-check, proc-macro-srv]

+ # Check if all jobs that we depend on (in the needs array) were successful (or have been skipped).

+ jq --exit-status 'all(.result == "success" or .result == "skipped")' <<< '${{ toJson(needs) }}'

+ if: ${{ github.repository == 'rust-lang/rust-analyzer' || github.event_name == 'workflow_dispatch' }}

+ if: ${{ github.repository == 'rust-lang/rust-analyzer' || github.event_name == 'workflow_dispatch' }}

+ ZIG_VERSION: 0.13.0

+ ZIGBUILD_VERSION: 0.19.8

+ if: ${{ github.repository == 'rust-lang/rust-analyzer' || github.event_name == 'workflow_dispatch' }}

+ zig_target: x86_64-unknown-linux-gnu.2.28

+ zig_target: aarch64-unknown-linux-gnu.2.28

+ zig_target: arm-unknown-linux-gnueabihf.2.28

+ - name: Install Node.js toolchain

+ uses: actions/setup-node@v4

+ with:

+ node-version: 22

+ rustup target add ${{ matrix.target }}

+ - name: Install Zig toolchain

+ if: ${{ matrix.zig_target }}

+ run: |

+ which cargo

+ curl -L "https://ziglang.org/download/${ZIG_VERSION}/zig-linux-$(uname -m)-${ZIG_VERSION}.tar.xz" | sudo tar JxC /usr/local

+ sudo ln -s "/usr/local/zig-linux-$(uname -m)-${ZIG_VERSION}/zig" /usr/local/bin/zig

+ curl -L "https://github.com/rust-cross/cargo-zigbuild/releases/download/v${ZIGBUILD_VERSION}/cargo-zigbuild-v${ZIGBUILD_VERSION}.x86_64-unknown-linux-musl.tar.gz" | tar zxC ~/.cargo/bin

+ - name: Dist (plain)

+ if: ${{ !matrix.zig_target }}

+ - name: Dist (using zigbuild)

+ if: ${{ matrix.zig_target }}

+ run: RA_TARGET=${{ matrix.zig_target}} cargo xtask dist --client-patch-version ${{ github.run_number }} --zig

+

+ if: ${{ github.repository == 'rust-lang/rust-analyzer' || github.event_name == 'workflow_dispatch' }}

+ if: ${{ github.repository == 'rust-lang/rust-analyzer' || github.event_name == 'workflow_dispatch' }}

+ node-version: 22

+ # ignore `// spellchecker:off` until `// spellchecker:on`

+ "(?s)(#|//)\\s*spellchecker:off.*?\\n\\s*(#|//)\\s*spellchecker:on",

+version = "0.100.0"

+checksum = "ab2d131019373f0d0d1f2af0abd4f719739f6583c1b33965112455f643a910af"

+version = "0.100.0"

+checksum = "4f114996bda14c0213f014a4ef31a7867dcf5f539a3900477fc6b20138e7a17b"

+version = "0.100.0"

+checksum = "551e956e031c09057c7b21f17d48d91de99c9b6b6e34bceaf5e7202d71021268"

+version = "0.100.0"

+checksum = "cd7ca50181156ce649efe8e5dd00580f573651554e4dcd11afa4e2ac93f53324"

+version = "0.100.0"

+checksum = "f1651b0f7e8c3eb7c27a88f39d277e69c32bfe58e3be174d286c1a24d6a7a4d8"

+version = "0.100.0"

+checksum = "2bcd85e93dc0ea850bcfe7957a115957df799ccbc9eea488bdee5ec6780d212b"

+version = "0.100.0"

+checksum = "62b295fc0640cd9fe0ecab872ee4a17a96f90a3998ec9f0c4765e9b8415c12cc"

+version = "0.100.0"

+checksum = "c675f4257023aa933882906f13802cae287e88cc39ab13cbb96809083db0c801"

+version = "0.100.0"

+checksum = "c8358702c2a510ea84ba5801ddc047d9ad9520902cfb0e6173277610cdce2c9c"

+version = "0.100.0"

+checksum = "b98f402011d46732c35c47bfd111dec0495747fef2ec900ddee7fe15d78449a7"

+version = "0.100.0"

+checksum = "bef3ff73fa4653252ffe1d1e9177a446f49ef46d97140e4816b7ff2dad59ed53"

+ "tracing",

+ra-ap-rustc_hashes = { version = "0.100", default-features = false }

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

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

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

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

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

+chalk-solve = { version = "0.100.0", default-features = false }

+chalk-ir = "0.100.0"

+chalk-recursive = { version = "0.100.0", default-features = false }

+chalk-derive = "0.100.0"

+impl PartialOrd for CfgAtom {

+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {

+ Some(self.cmp(other))

+ }

+}

+

+impl Ord for CfgAtom {

+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {

+ match (self, other) {

+ (CfgAtom::Flag(a), CfgAtom::Flag(b)) => a.as_str().cmp(b.as_str()),

+ (CfgAtom::Flag(_), CfgAtom::KeyValue { .. }) => std::cmp::Ordering::Less,

+ (CfgAtom::KeyValue { .. }, CfgAtom::Flag(_)) => std::cmp::Ordering::Greater,

+ (CfgAtom::KeyValue { key, value }, CfgAtom::KeyValue { key: key2, value: value2 }) => {

+ key.as_str().cmp(key2.as_str()).then(value.as_str().cmp(value2.as_str()))

+ }

+ }

+ }

+}

+

+ res.enabled.sort_unstable();

+ res.disabled.sort_unstable();

+ diff.enable.sort_unstable();

+ diff.disable.sort_unstable();

+ /// Create a new CfgDiff.

+ pub fn new(mut enable: Vec<CfgAtom>, mut disable: Vec<CfgAtom>) -> CfgDiff {

+ enable.sort();

+ enable.dedup();

+ disable.sort();

+ disable.dedup();

+ for i in (0..enable.len()).rev() {

+ if let Some(j) = disable.iter().position(|atom| *atom == enable[i]) {

+ enable.remove(i);

+ disable.remove(j);

+ }

+ CfgDiff { enable, disable }

+//! ```ignore

+//! # use hir_def::dyn_map::DynMap;

+//! # use hir_def::dyn_map::Key;

+ Literal(u16),

+const _: [(); 24] = [(); size_of::<TypeBound>()];

+ /// ```ignore

+ /// ```ignore

+ /// ```ignore

+fn f1() { m1!(x); }

+fn f2() { m2!(x }

+fn f1() { (x); }

+fn f2() { /* error: expected ident */ }

+ InFile, MacroCallKind, MacroFileId, MacroFileIdExt, MacroKind,

+ if let MacroKind::Derive

+ | MacroKind::DeriveBuiltIn

+ | MacroKind::Attr

+ | MacroKind::AttrBuiltIn = file_id.kind(&db)

+ {

+ if let MacroKind::DeriveBuiltIn | MacroKind::Derive = macro_file.kind(&db) {

+ /// ```ignore

+ /// `Path::Normal` will always have either generics or type anchor.

+ if type_anchor.is_none() && qualifier_generic_args.iter().all(|it| it.is_none()) {

+ Some(Path::BarePath(qualifier_mod_path))

+ } else {

+ Some(Path::Normal(NormalPath::new(

+ type_anchor,

+ qualifier_mod_path,

+ qualifier_generic_args.iter().cloned(),

+ )))

+ }

+use intern::{sym, Symbol};

+use span::SyntaxContextId;

+ let mut hygiene_info = hygiene_info(db, hygiene_id);

+ handle_macro_def_scope(db, &mut hygiene_id, &mut hygiene_info, macro_id)

+ /// # #![allow(non_camel_case_types)]

+ /// const t: t = t!();

+ /// ```ignore

+ /// Checks if we rename `renamed` (currently named `current_name`) to `new_name`, will the meaning of this reference

+ /// (that contains `current_name` path) change from `renamed` to some another variable (returned as `Some`).

+ pub fn rename_will_conflict_with_another_variable(

+ &self,

+ db: &dyn DefDatabase,

+ current_name: &Name,

+ current_name_as_path: &ModPath,

+ mut hygiene_id: HygieneId,

+ new_name: &Symbol,

+ to_be_renamed: BindingId,

+ ) -> Option<BindingId> {

+ let mut hygiene_info = hygiene_info(db, hygiene_id);

+ let mut will_be_resolved_to = None;

+ for scope in self.scopes() {

+ match scope {

+ Scope::ExprScope(scope) => {

+ for entry in scope.expr_scopes.entries(scope.scope_id) {

+ if entry.hygiene() == hygiene_id {

+ if entry.binding() == to_be_renamed {

+ // This currently resolves to our renamed variable, now `will_be_resolved_to`

+ // contains `Some` if the meaning will change or `None` if not.

+ return will_be_resolved_to;

+ } else if entry.name().symbol() == new_name {

+ will_be_resolved_to = Some(entry.binding());

+ }

+ }

+ }

+ }

+ Scope::MacroDefScope(macro_id) => {

+ handle_macro_def_scope(db, &mut hygiene_id, &mut hygiene_info, macro_id)

+ }

+ Scope::GenericParams { params, def } => {

+ if params.find_const_by_name(current_name, *def).is_some() {

+ // It does not resolve to our renamed variable.

+ return None;

+ }

+ }

+ Scope::AdtScope(_) | Scope::ImplDefScope(_) => continue,

+ Scope::BlockScope(m) => {

+ if m.resolve_path_in_value_ns(db, current_name_as_path).is_some() {

+ // It does not resolve to our renamed variable.

+ return None;

+ }

+ }

+ }

+ }

+ // It does not resolve to our renamed variable.

+ None

+ }

+

+ /// Checks if we rename `renamed` to `name`, will the meaning of this reference (that contains `name` path) change

+ /// from some other variable (returned as `Some`) to `renamed`.

+ pub fn rename_will_conflict_with_renamed(

+ &self,

+ db: &dyn DefDatabase,

+ name: &Name,

+ name_as_path: &ModPath,

+ mut hygiene_id: HygieneId,

+ to_be_renamed: BindingId,

+ ) -> Option<BindingId> {

+ let mut hygiene_info = hygiene_info(db, hygiene_id);

+ let mut will_resolve_to_renamed = false;

+ for scope in self.scopes() {

+ match scope {

+ Scope::ExprScope(scope) => {

+ for entry in scope.expr_scopes.entries(scope.scope_id) {

+ if entry.binding() == to_be_renamed {

+ will_resolve_to_renamed = true;

+ } else if entry.hygiene() == hygiene_id && entry.name() == name {

+ if will_resolve_to_renamed {

+ // This will resolve to the renamed variable before it resolves to the original variable.

+ return Some(entry.binding());

+ } else {

+ // This will resolve to the original variable.

+ return None;

+ }

+ }

+ }

+ }

+ Scope::MacroDefScope(macro_id) => {

+ handle_macro_def_scope(db, &mut hygiene_id, &mut hygiene_info, macro_id)

+ }

+ Scope::GenericParams { params, def } => {

+ if params.find_const_by_name(name, *def).is_some() {

+ // Here and below, it might actually resolve to our renamed variable - in which case it'll

+ // hide the generic parameter or some other thing (not a variable). We don't check for that

+ // because due to naming conventions, it is rare that variable will shadow a non-variable.

+ return None;

+ }

+ }

+ Scope::AdtScope(_) | Scope::ImplDefScope(_) => continue,

+ Scope::BlockScope(m) => {

+ if m.resolve_path_in_value_ns(db, name_as_path).is_some() {

+ return None;

+ }

+ }

+ }

+ }

+ None

+ }

+

+#[inline]

+fn handle_macro_def_scope(

+ db: &dyn DefDatabase,

+ hygiene_id: &mut HygieneId,

+ hygiene_info: &mut Option<(SyntaxContextId, MacroDefId)>,

+ macro_id: &MacroDefId,

+) {

+ if let Some((parent_ctx, label_macro_id)) = hygiene_info {

+ if label_macro_id == macro_id {

+ // A macro is allowed to refer to variables from before its declaration.

+ // Therefore, if we got to the rib of its declaration, give up its hygiene

+ // and use its parent expansion.

+ let parent_ctx = db.lookup_intern_syntax_context(*parent_ctx);

+ *hygiene_id = HygieneId::new(parent_ctx.opaque_and_semitransparent);

+ *hygiene_info = parent_ctx.outer_expn.map(|expansion| {

+ let expansion = db.lookup_intern_macro_call(expansion);

+ (parent_ctx.parent, expansion.def)

+ });

+ }

+ }

+}

+

+#[inline]

+fn hygiene_info(

+ db: &dyn DefDatabase,

+ hygiene_id: HygieneId,

+) -> Option<(SyntaxContextId, MacroDefId)> {

+ if !hygiene_id.is_root() {

+ let ctx = hygiene_id.lookup(db);

+ ctx.outer_expn.map(|expansion| {

+ let expansion = db.lookup_intern_macro_call(expansion);

+ (ctx.parent, expansion.def)

+ })

+ } else {

+ None

+ }

+}

+

+/// ```ignore

+ map_node_range_up, map_node_range_up_rooted, span_for_offset, MacroFileIdExt, MacroKind,

+ HirFileIdRepr::MacroFile(m)

+ if matches!(m.kind(db), MacroKind::Attr | MacroKind::AttrBuiltIn) =>

+ {

+ m

+ }

+ if !matches!(file_id.kind(db), MacroKind::Attr | MacroKind::AttrBuiltIn) {

+ // fixup should only create matching delimiters, but proc macros

+ // could just copy the span to one of the delimiters. We don't want

+ // to leak the dummy ID, so we remove both.

+ // the fixed-up tree should not contain braces as punct

+ // FIXME: should probably instead check that it's a valid punctuation character

+ for x in tt.token_trees().flat_tokens() {

+ match x {

+ ::tt::TokenTree::Leaf(::tt::Leaf::Punct(punct)) => {

+ assert!(!matches!(punct.char, '{' | '}' | '(' | ')' | '[' | ']'))

+ }

+ _ => (),

+ }

+ }

+

+fn foo () {for _ in __ra_fixup {}}

+fn foo () {for bar in qux {}}

+fn foo () {match __ra_fixup {}}

+fn foo () {match __ra_fixup {}}

+fn foo () {if a {}}

+fn foo () {if __ra_fixup {}}

+fn foo () {if __ra_fixup {} {}}

+fn foo () {while __ra_fixup {}}

+fn foo () {while foo {}}

+fn foo () {loop {}}

+fn foo () {foo (a)}

+fn foo () {bar . foo (a)}

+pub use intern;

+

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

+pub enum MacroKind {

+ /// `macro_rules!` or Macros 2.0 macro.

+ Declarative,

+ /// A built-in function-like macro.

+ DeclarativeBuiltIn,

+ /// A custom derive.

+ Derive,

+ /// A builtin-in derive.

+ DeriveBuiltIn,

+ /// A procedural attribute macro.

+ Attr,

+ /// A built-in attribute macro.

+ AttrBuiltIn,

+ /// A function-like procedural macro.

+ ProcMacro,

+}

+

+ fn kind(&self, db: &dyn ExpandDatabase) -> MacroKind;

+ fn kind(&self, db: &dyn ExpandDatabase) -> MacroKind {

+ match db.lookup_intern_macro_call(self.macro_call_id).def.kind {

+ MacroDefKind::Declarative(..) => MacroKind::Declarative,

+ MacroDefKind::BuiltIn(..) | MacroDefKind::BuiltInEager(..) => {

+ MacroKind::DeclarativeBuiltIn

+ }

+ MacroDefKind::BuiltInDerive(..) => MacroKind::DeriveBuiltIn,

+ MacroDefKind::ProcMacro(_, _, ProcMacroKind::CustomDerive) => MacroKind::Derive,

+ MacroDefKind::ProcMacro(_, _, ProcMacroKind::Attr) => MacroKind::Attr,

+ MacroDefKind::ProcMacro(_, _, ProcMacroKind::Bang) => MacroKind::ProcMacro,

+ MacroDefKind::BuiltInAttr(..) => MacroKind::AttrBuiltIn,

+ }

+ $crate::name::Name::new_symbol_root($crate::intern::sym::$start.clone()), $($crate::name::Name::new_symbol_root($crate::intern::sym::$seg.clone()),)*

+ $crate::name::Name::new_symbol_root($crate::intern::sym::rust_analyzer.clone()), $crate::name::Name::new_symbol_root($crate::intern::sym::$start.clone()), $($crate::name::Name::new_symbol_root($crate::intern::sym::$seg.clone()),)*

+ LangItem::AsyncFn => WellKnownTrait::AsyncFn,

+ LangItem::AsyncFnMut => WellKnownTrait::AsyncFnMut,

+ LangItem::AsyncFnOnce => WellKnownTrait::AsyncFnOnce,

+ LangItem::Future => WellKnownTrait::Future,

+ WellKnownTrait::AsyncFn => LangItem::AsyncFn,

+ WellKnownTrait::AsyncFnMut => LangItem::AsyncFnMut,

+ WellKnownTrait::AsyncFnOnce => LangItem::AsyncFnOnce,

+ WellKnownTrait::Future => LangItem::Future,

+ db::HirDatabase, display::DisplayTarget, generics::Generics, infer::InferenceContext,

+ lower::ParamLoweringMode, mir::monomorphize_mir_body_bad, to_placeholder_idx, Const, ConstData,

+ ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution, TraitEnvironment, Ty,

+ TyBuilder,

+ display_target: DisplayTarget,

+ ConstEvalError::MirLowerError(e) => {

+ e.pretty_print(f, db, span_formatter, display_target)

+ }

+ ConstEvalError::MirEvalError(e) => {

+ e.pretty_print(f, db, span_formatter, display_target)

+ }

+ consteval::try_const_usize, db::HirDatabase, display::DisplayTarget, mir::pad16,

+ test_db::TestDB, Const, ConstScalar, Interner, MemoryMap,

+ let display_target = DisplayTarget::from_crate(

+ &db,

+ *db.crate_graph().crates_in_topological_order().last().unwrap(),

+ );

+ ConstEvalError::MirLowerError(e) => {

+ e.pretty_print(&mut err, &db, span_formatter, display_target)

+ }

+ ConstEvalError::MirEvalError(e) => {

+ e.pretty_print(&mut err, &db, span_formatter, display_target)

+ }

+ let f = || size_of::<T>();

+ //- minicore: drop, manually_drop, copy, sized

+ use core::mem::ManuallyDrop;

+ struct NeedsDrop;

+ impl Drop for NeedsDrop {

+ fn drop(&mut self) {}

+ }

+ enum Enum<T> {

+ A(T),

+ B(X),

+ }

+ const fn val_needs_drop<T>(_v: T) -> bool { needs_drop::<T>() }

+ const fn closure_needs_drop() -> bool {

+ let a = NeedsDrop;

+ let b = X;

+ !val_needs_drop(|| &a) && val_needs_drop(move || &a) && !val_needs_drop(move || &b)

+ }

+ const fn opaque() -> impl Sized {

+ || {}

+ }

+ const fn opaque_copy() -> impl Sized + Copy {

+ || {}

+ }

+ trait Everything {}

+ impl<T> Everything for T {}

+ const GOAL: bool = !needs_drop::<i32>() && !needs_drop::<X>()

+ && needs_drop::<NeedsDrop>() && !needs_drop::<ManuallyDrop<NeedsDrop>>()

+ && needs_drop::<[NeedsDrop; 1]>() && !needs_drop::<[NeedsDrop; 0]>()

+ && needs_drop::<(X, NeedsDrop)>()

+ && needs_drop::<Enum<NeedsDrop>>() && !needs_drop::<Enum<X>>()

+ && closure_needs_drop()

+ && !val_needs_drop(opaque()) && !val_needs_drop(opaque_copy())

+ && needs_drop::<[NeedsDrop]>() && needs_drop::<dyn Everything>()

+ && !needs_drop::<&dyn Everything>() && !needs_drop::<str>();

+use hir_expand::name::Name;

+ drop::DropGlue,

+

+ #[ra_salsa::invoke(crate::drop::has_drop_glue)]

+ #[ra_salsa::cycle(crate::drop::has_drop_glue_recover)]

+ fn has_drop_glue(&self, ty: Ty, env: Arc<TraitEnvironment>) -> DropGlue {}

+ unsafe_check::{

+ missing_unsafe, unsafe_operations, unsafe_operations_for_body, InsideUnsafeBlock,

+ UnsafetyReason,

+ },

+ display::{DisplayTarget, HirDisplay},

+ struct DisplayWitness<'a, 'p>(&'a WitnessPat<'p>, &'a MatchCheckCtx<'p>, DisplayTarget);

+ let DisplayWitness(witness, cx, display_target) = *self;

+ write!(f, "{}", pat.display(cx.db, display_target))

+ let display_target = DisplayTarget::from_crate(cx.db, krate);

+ format!("type `{}` is non-empty", scrut_ty.display(cx.db, display_target))

+ let pat_display = |witness| DisplayWitness(witness, cx, display_target);

+pub fn unsafe_operations_for_body(

+ db: &dyn HirDatabase,

+ infer: &InferenceResult,

+ def: DefWithBodyId,

+ body: &Body,

+ callback: &mut dyn FnMut(ExprOrPatId),

+) {

+ let mut visitor_callback = |diag| {

+ if let UnsafeDiagnostic::UnsafeOperation { node, .. } = diag {

+ callback(node);

+ }

+ };

+ let mut visitor = UnsafeVisitor::new(db, infer, body, def, &mut visitor_callback);

+ visitor.walk_expr(body.body_expr);

+ for &param in &body.params {

+ visitor.walk_pat(param);

+ }

+}

+

+pub fn unsafe_operations(

+ Expr::Unsafe { statements, .. } => {

+ let old_inside_unsafe_block =

+ mem::replace(&mut self.inside_unsafe_block, InsideUnsafeBlock::Yes);

+ self.walk_pats_top(

+ statements.iter().filter_map(|statement| match statement {

+ &Statement::Let { pat, .. } => Some(pat),

+ _ => None,

+ }),

+ current,

+ );

+ self.body.walk_child_exprs_without_pats(current, |child| self.walk_expr(child));

+ self.inside_unsafe_block = old_inside_unsafe_block;

+ return;

+ }

+ mem,

+ infer::normalize,

+ display_kind: DisplayKind,

+ /// ```ignore

+ display_kind: DisplayKind,

+ !matches!(display_kind, DisplayKind::SourceCode { .. }),

+ display_kind,

+ display_target: DisplayTarget,

+ display_target,

+ display_kind: DisplayKind::Diagnostics,

+ display_target: DisplayTarget,

+ display_target,

+ display_kind: DisplayKind::Diagnostics,

+ display_target: DisplayTarget,

+ display_target,

+ display_kind: DisplayKind::Diagnostics,

+ display_target: DisplayTarget::from_crate(db, module_id.krate()),

+ display_kind: DisplayKind::SourceCode { target_module_id: module_id, allow_opaque },

+ fn display_test<'a>(

+ &'a self,

+ db: &'a dyn HirDatabase,

+ display_target: DisplayTarget,

+ ) -> HirDisplayWrapper<'a, Self>

+ display_target,

+ display_kind: DisplayKind::Test,

+ display_target: DisplayTarget,

+ display_target,

+ display_kind: DisplayKind::Diagnostics,

+ pub fn krate(&self) -> CrateId {

+ self.display_target.krate

+ }

+

+ self.display_target.edition

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

+pub struct DisplayTarget {

+ krate: CrateId,

+ pub edition: Edition,

+}

+

+impl DisplayTarget {

+ pub fn from_crate(db: &dyn HirDatabase, krate: CrateId) -> Self {

+ let edition = db.crate_graph()[krate].edition;

+ Self { krate, edition }

+ }

+}

+

+pub enum DisplayKind {

+ Diagnostics,

+ SourceCode { target_module_id: ModuleId, allow_opaque: bool },

+impl DisplayKind {

+ display_kind: DisplayKind,

+ display_kind: self.display_kind,

+ if !f.display_kind.is_source_code() {

+ let trait_env = TraitEnvironment::empty(f.krate());

+ let ty = normalize(f.db, trait_env.clone(), ty.clone());

+ if f.display_kind.is_source_code() {

+ match f.display_kind {

+ DisplayKind::Diagnostics { .. } | DisplayKind::Test { .. } => {

+ DisplayKind::SourceCode { target_module_id: module_id, allow_opaque: _ } => {

+ if f.display_kind.is_test() {

+ if !f.display_kind.allows_opaque() {

+ if f.display_kind.is_source_code() {

+ if !f.display_kind.allows_opaque() {

+ if !f.display_kind.allows_opaque() {

+ if f.display_kind.is_source_code() {

+ if f.display_kind.is_source_code() {

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

+ _ if f.display_kind.is_source_code() => write!(f, "'_"),

+//! Utilities for computing drop info about types.

+

+use base_db::ra_salsa;

+use chalk_ir::cast::Cast;

+use hir_def::data::adt::StructFlags;

+use hir_def::lang_item::LangItem;

+use hir_def::AdtId;

+use stdx::never;

+use triomphe::Arc;

+

+use crate::{

+ db::HirDatabase, method_resolution::TyFingerprint, AliasTy, Canonical, CanonicalVarKinds,

+ InEnvironment, Interner, ProjectionTy, TraitEnvironment, Ty, TyBuilder, TyKind,

+};

+use crate::{ConcreteConst, ConstScalar, ConstValue};

+

+fn has_destructor(db: &dyn HirDatabase, adt: AdtId) -> bool {

+ let module = match adt {

+ AdtId::EnumId(id) => db.lookup_intern_enum(id).container,

+ AdtId::StructId(id) => db.lookup_intern_struct(id).container,

+ AdtId::UnionId(id) => db.lookup_intern_union(id).container,

+ };

+ let Some(drop_trait) =

+ db.lang_item(module.krate(), LangItem::Drop).and_then(|it| it.as_trait())

+ else {

+ return false;

+ };

+ let impls = match module.containing_block() {

+ Some(block) => match db.trait_impls_in_block(block) {

+ Some(it) => it,

+ None => return false,

+ },

+ None => db.trait_impls_in_crate(module.krate()),

+ };

+ let result = impls.for_trait_and_self_ty(drop_trait, TyFingerprint::Adt(adt)).next().is_some();

+ result

+}

+

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

+pub enum DropGlue {

+ // Order of variants is important.

+ None,

+ /// May have a drop glue if some type parameter has it.

+ ///

+ /// For the compiler this is considered as a positive result, IDE distinguishes this from "yes".

+ DependOnParams,

+ HasDropGlue,

+}

+

+pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment>) -> DropGlue {

+ match ty.kind(Interner) {

+ TyKind::Adt(adt, subst) => {

+ if has_destructor(db, adt.0) {

+ return DropGlue::HasDropGlue;

+ }

+ match adt.0 {

+ AdtId::StructId(id) => {

+ if db.struct_data(id).flags.contains(StructFlags::IS_MANUALLY_DROP) {

+ return DropGlue::None;

+ }

+ db.field_types(id.into())

+ .iter()

+ .map(|(_, field_ty)| {

+ db.has_drop_glue(

+ field_ty.clone().substitute(Interner, subst),

+ env.clone(),

+ )

+ })

+ .max()

+ .unwrap_or(DropGlue::None)

+ }

+ // Unions cannot have fields with destructors.

+ AdtId::UnionId(_) => DropGlue::None,

+ AdtId::EnumId(id) => db

+ .enum_data(id)

+ .variants

+ .iter()

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

+ db.field_types(variant.into())

+ .iter()

+ .map(|(_, field_ty)| {

+ db.has_drop_glue(

+ field_ty.clone().substitute(Interner, subst),

+ env.clone(),

+ )

+ })

+ .max()

+ .unwrap_or(DropGlue::None)

+ })

+ .max()

+ .unwrap_or(DropGlue::None),

+ }

+ }

+ TyKind::Tuple(_, subst) => subst

+ .iter(Interner)

+ .map(|ty| ty.assert_ty_ref(Interner))

+ .map(|ty| db.has_drop_glue(ty.clone(), env.clone()))

+ .max()

+ .unwrap_or(DropGlue::None),

+ TyKind::Array(ty, len) => {

+ if let ConstValue::Concrete(ConcreteConst { interned: ConstScalar::Bytes(len, _) }) =

+ &len.data(Interner).value

+ {

+ match (&**len).try_into() {

+ Ok(len) => {

+ let len = usize::from_le_bytes(len);

+ if len == 0 {

+ // Arrays of size 0 don't have drop glue.

+ return DropGlue::None;

+ }

+ }

+ Err(_) => {

+ never!("const array size with non-usize len");

+ }

+ }

+ }

+ db.has_drop_glue(ty.clone(), env)

+ }

+ TyKind::Slice(ty) => db.has_drop_glue(ty.clone(), env),

+ TyKind::Closure(closure_id, subst) => {

+ let owner = db.lookup_intern_closure((*closure_id).into()).0;

+ let infer = db.infer(owner);

+ let (captures, _) = infer.closure_info(closure_id);

+ let env = db.trait_environment_for_body(owner);

+ captures

+ .iter()

+ .map(|capture| db.has_drop_glue(capture.ty(subst), env.clone()))

+ .max()

+ .unwrap_or(DropGlue::None)

+ }

+ // FIXME: Handle coroutines.

+ TyKind::Coroutine(..) | TyKind::CoroutineWitness(..) => DropGlue::None,

+ TyKind::Ref(..)

+ | TyKind::Raw(..)

+ | TyKind::FnDef(..)

+ | TyKind::Str

+ | TyKind::Never

+ | TyKind::Scalar(_)

+ | TyKind::Function(_)

+ | TyKind::Foreign(_)

+ | TyKind::Error => DropGlue::None,

+ TyKind::Dyn(_) => DropGlue::HasDropGlue,

+ TyKind::AssociatedType(assoc_type_id, subst) => projection_has_drop_glue(

+ db,

+ env,

+ ProjectionTy { associated_ty_id: *assoc_type_id, substitution: subst.clone() },

+ ty,

+ ),

+ TyKind::Alias(AliasTy::Projection(projection)) => {

+ projection_has_drop_glue(db, env, projection.clone(), ty)

+ }

+ TyKind::OpaqueType(..) | TyKind::Alias(AliasTy::Opaque(_)) => {

+ if is_copy(db, ty, env) {

+ DropGlue::None

+ } else {

+ DropGlue::HasDropGlue

+ }

+ }

+ TyKind::Placeholder(_) | TyKind::BoundVar(_) => {

+ if is_copy(db, ty, env) {

+ DropGlue::None

+ } else {

+ DropGlue::DependOnParams

+ }

+ }

+ TyKind::InferenceVar(..) => unreachable!("inference vars shouldn't exist out of inference"),

+ }

+}

+

+fn projection_has_drop_glue(

+ db: &dyn HirDatabase,

+ env: Arc<TraitEnvironment>,

+ projection: ProjectionTy,

+ ty: Ty,

+) -> DropGlue {

+ let normalized = db.normalize_projection(projection, env.clone());

+ match normalized.kind(Interner) {

+ TyKind::Alias(AliasTy::Projection(_)) | TyKind::AssociatedType(..) => {

+ if is_copy(db, ty, env) {

+ DropGlue::None

+ } else {

+ DropGlue::DependOnParams

+ }

+ }

+ _ => db.has_drop_glue(normalized, env),

+ }

+}

+

+fn is_copy(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment>) -> bool {

+ let Some(copy_trait) = db.lang_item(env.krate, LangItem::Copy).and_then(|it| it.as_trait())

+ else {

+ return false;

+ };

+ let trait_ref = TyBuilder::trait_ref(db, copy_trait).push(ty).build();

+ let goal = Canonical {

+ value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),

+ binders: CanonicalVarKinds::empty(Interner),

+ };

+ db.trait_solve(env.krate, env.block, goal).is_some()

+}

+

+pub(crate) fn has_drop_glue_recover(

+ _db: &dyn HirDatabase,

+ _cycle: &ra_salsa::Cycle,

+ _ty: &Ty,

+ _env: &Arc<TraitEnvironment>,

+) -> DropGlue {

+ DropGlue::None

+}

+/// ```ignore

+ /// slice = match slice {

+ /// [0, rest @ ..] | rest => rest,

+ /// };

+ /// 0

+ Float, Integer, LayoutCalculator, LayoutCalculatorError, LayoutData, Primitive,

+ ReprOptions, Scalar, StructKind, TargetDataLayout, WrappingRange,

+use rustc_index::IndexVec;

+ repr_packed: bool,

+ // Supported SIMD vectors are homogeneous ADTs with exactly one array field:

+ let fields = db.field_types(id.into());

+ let mut fields = fields.iter();

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

+ .next()

+ .filter(|_| fields.next().is_none())

+ .map(|f| f.1.clone().substitute(Interner, subst).kind(Interner).clone())

+ else {

+ return Err(LayoutError::InvalidSimdType);

+ let e_len = try_const_usize(db, &e_len).ok_or(LayoutError::HasErrorConst)? as u64;

+ let cx = LayoutCx::new(dl);

+ Ok(Arc::new(cx.calc.simd_type(e_ly, e_len, repr_packed)?))

+ let kind = ty.kind(Interner);

+ let result = match kind {

+ return layout_of_simd_ty(db, *s, repr.packed(), subst, trait_env, &target);

+ chalk_ir::Scalar::Int(i) => Layout::scalar(

+ scalar_unit(

+ dl,

+ Primitive::Int(

+ match i {

+ IntTy::Isize => dl.ptr_sized_integer(),

+ IntTy::I8 => Integer::I8,

+ IntTy::I16 => Integer::I16,

+ IntTy::I32 => Integer::I32,

+ IntTy::I64 => Integer::I64,

+ IntTy::I128 => Integer::I128,

+ },

+ true,

+ ),

+ chalk_ir::Scalar::Uint(i) => Layout::scalar(

+ scalar_unit(

+ dl,

+ Primitive::Int(

+ match i {

+ UintTy::Usize => dl.ptr_sized_integer(),

+ UintTy::U8 => Integer::I8,

+ UintTy::U16 => Integer::I16,

+ UintTy::U32 => Integer::I32,

+ UintTy::U64 => Integer::I64,

+ UintTy::U128 => Integer::I128,

+ },

+ false,

+ ),

+ chalk_ir::Scalar::Float(f) => Layout::scalar(

+ scalar_unit(

+ dl,

+ Primitive::Float(match f {

+ FloatTy::F16 => Float::F16,

+ FloatTy::F32 => Float::F32,

+ FloatTy::F64 => Float::F64,

+ FloatTy::F128 => Float::F128,

+ }),

+ ),

+ cx.calc.array_like::<_, _, ()>(&element, Some(count))?

+ cx.calc.array_like::<_, _, ()>(&element, None)?

+ }

+ TyKind::Str => {

+ let element = scalar_unit(dl, Primitive::Int(Integer::I8, false));

+ cx.calc.array_like::<_, _, ()>(&Layout::scalar(dl, element), None)?

+ LayoutData::scalar_pair(dl, data_ptr, metadata)

+ TyKind::Never => LayoutData::never_type(dl),

+ TyKind::FnDef(..) | TyKind::Dyn(_) | TyKind::Foreign(_) => {

+ let sized = matches!(kind, TyKind::FnDef(..));

+ LayoutData::unit(dl, sized)

+ // Usually we should not try to normalize `TyKind::AssociatedType`, but layout calculation is used

+ // in monomorphized MIR where this is okay. If outside monomorphization, this will lead to cycle,

+ // which we will recover from with an error.

+ layout::{field_ty, Layout, LayoutError},

+ struct SimdType([i64; 2]);

+mod drop;

+mod target_feature;

+ consteval::unknown_const,

+ db::HirDatabase,

+ display::{DisplayTarget, HirDisplay},

+ generics::Generics,

+pub use drop::DropGlue;

+pub use target_feature::TargetFeatures;

+pub use utils::{all_super_traits, direct_super_traits, is_fn_unsafe_to_call, Unsafety};

+ display_target: DisplayTarget,

+ Some(make::expr_const_value(konst.display(db, display_target).to_string().as_str()))

+ display::{DisplayTarget, HirDisplay},

+ base.display(db, DisplayTarget::from_crate(db, krate))

+ display::DisplayTarget,

+ body.pretty_print(

+ db,

+ DisplayTarget::from_crate(db, body.owner.krate(db.upcast()))

+ )

+use span::FileId;

+ display::{ClosureStyle, DisplayTarget, HirDisplay},

+ fn to_bytes(&self) -> [u8; size_of::<usize>()] {

+ display_target: DisplayTarget,

+ function_name.name.display(db.upcast(), display_target.edition),

+ ty.display(db, display_target).with_closure_style(ClosureStyle::ClosureWithId)

+ .display(db, display_target)

+ ItemContainerId::TraitId(it) => Some(

+ db.trait_data(it)

+ .name

+ .display(db.upcast(), display_target.edition)

+ .to_string(),

+ ),

+ function_name.name.display(db.upcast(), display_target.edition),

+ err.pretty_print(f, db, span_formatter, display_target)?;

+ display_target,

+ if evaluator.ptr_size() != size_of::<usize>() {

+use stdx::never;

+ display::DisplayTarget,

+ DropGlue,

+ ty.display(self.db, DisplayTarget::from_crate(self.db, krate)).to_string()

+ let result = match self.db.has_drop_glue(ty.clone(), self.trait_env.clone()) {

+ DropGlue::HasDropGlue => true,

+ DropGlue::None => false,

+ DropGlue::DependOnParams => {

+ never!("should be fully monomorphized now");

+ true

+ }

+ };

+use crate::display::DisplayTarget;

+ let krate = db.module_for_file(file_id).krate();

+ e.pretty_print(&mut err, &db, span_formatter, DisplayTarget::from_crate(&db, krate))

+ .unwrap();

+use base_db::{ra_salsa::Cycle, CrateId};

+ display::{hir_display_with_types_map, DisplayTarget, HirDisplay},

+ display_target: DisplayTarget,

+ e.pretty_print(f, db, span_formatter, display_target)?

+ e.pretty_print(f, db, span_formatter, display_target)?

+ body.pretty_print_expr(db.upcast(), *owner, *it, display_target.edition)

+ e.expected.display(db, display_target),

+ e.actual.display(db, display_target),

+ param

+ .name()

+ .unwrap_or(&Name::missing())

+ .display(db.upcast(), display_target.edition)

+ write!(f, " {},", g.display(db, display_target))?;

+ display_target: DisplayTarget,

+ hir_display_with_types_map(p, types_map).display(db, display_target).to_string(),

+ DisplayTarget::from_crate(self.db, self.krate()),

+ .display(self.db, self.display_target())

+ let owner = self.owner;

+ let db = self.db;

+ let unresolved_name = || {

+ MirLowerError::unresolved_path(

+ self.db,

+ c,

+ DisplayTarget::from_crate(db, owner.krate(db.upcast())),

+ &self.body.types,

+ )

+ };

+ const USIZE_SIZE: usize = size_of::<usize>();

+ self.db.crate_graph()[self.krate()].edition

+ }

+

+ fn krate(&self) -> CrateId {

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

+ }

+

+ fn display_target(&self) -> DisplayTarget {

+ DisplayTarget::from_crate(self.db, self.krate())

+ MirLowerError::unresolved_path(

+ self.db,

+ p,

+ self.display_target(),

+ &self.body.types,

+ )

+ display::{ClosureStyle, DisplayTarget, HirDisplay},

+ pub fn pretty_print(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> String {

+ let mut ctx = MirPrettyCtx::new(self, &hir_body, db, display_target);

+ w!(this, "fn {}() ", data.name.display(db.upcast(), this.display_target.edition));

+ w!(

+ this,

+ "static {}: _ = ",

+ data.name.display(db.upcast(), this.display_target.edition)

+ );

+ .display(db.upcast(), this.display_target.edition)

+ .display(db.upcast(), this.display_target.edition),

+ .display(db.upcast(), this.display_target.edition),

+ pub fn dbg(&self, db: &dyn HirDatabase, display_target: DisplayTarget) -> impl Debug {

+ StringDbg(self.pretty_print(db, display_target))

+ display_target: DisplayTarget,

+ fn new(

+ body: &'a MirBody,

+ hir_body: &'a Body,

+ db: &'a dyn HirDatabase,

+ display_target: DisplayTarget,

+ ) -> Self {

+ display_target,

+ self.local_name(id).display_test(self.db, self.display_target),

+ this.local_name(*p).display_test(this.db, this.display_target)

+ this.local_name(*p).display_test(this.db, this.display_target)

+ w!(this, "{}", this.local_name(local).display_test(this.db, this.display_target));

+ variant_name.display(this.db.upcast(), this.display_target.edition),

+ name.display(this.db.upcast(), this.display_target.edition)

+ w!(

+ this,

+ ".{}",

+ name.display(this.db.upcast(), this.display_target.edition)

+ );

+ w!(

+ this,

+ "[{}]",

+ this.local_name(*l).display_test(this.db, this.display_target)

+ );

+ w!(self, "; {}]", len.display_test(self.db, self.display_target));

+ ty.display_test(self.db, self.display_target)

+ .with_closure_style(ClosureStyle::ClosureWithSubst)

+//! Stuff for handling `#[target_feature]` (needed for unsafe check).

+

+use std::sync::LazyLock;

+

+use hir_def::attr::Attrs;

+use hir_def::tt;

+use intern::{sym, Symbol};

+use rustc_hash::{FxHashMap, FxHashSet};

+

+#[derive(Debug, Default)]

+pub struct TargetFeatures {

+ pub(crate) enabled: FxHashSet<Symbol>,

+}

+

+impl TargetFeatures {

+ pub fn from_attrs(attrs: &Attrs) -> Self {

+ let mut result = TargetFeatures::from_attrs_no_implications(attrs);

+ result.expand_implications();

+ result

+ }

+

+ fn expand_implications(&mut self) {

+ let all_implications = LazyLock::force(&TARGET_FEATURE_IMPLICATIONS);

+ let mut queue = self.enabled.iter().cloned().collect::<Vec<_>>();

+ while let Some(feature) = queue.pop() {

+ if let Some(implications) = all_implications.get(&feature) {

+ for implication in implications {

+ if self.enabled.insert(implication.clone()) {

+ queue.push(implication.clone());

+ }

+ }

+ }

+ }

+ }

+

+ /// Retrieves the target features from the attributes, and does not expand the target features implied by them.

+ pub(crate) fn from_attrs_no_implications(attrs: &Attrs) -> Self {

+ let enabled = attrs

+ .by_key(&sym::target_feature)

+ .tt_values()

+ .filter_map(|tt| {

+ match tt.token_trees().flat_tokens() {

+ [

+ tt::TokenTree::Leaf(tt::Leaf::Ident(enable_ident)),

+ tt::TokenTree::Leaf(tt::Leaf::Punct(tt::Punct { char: '=', .. })),

+ tt::TokenTree::Leaf(tt::Leaf::Literal(tt::Literal { kind: tt::LitKind::Str, symbol: features, .. })),

+ ] if enable_ident.sym == sym::enable => Some(features),

+ _ => None,

+ }

+ })

+ .flat_map(|features| features.as_str().split(',').map(Symbol::intern))

+ .collect();

+ Self { enabled }

+ }

+}

+

+// List of the target features each target feature implies.

+// Ideally we'd depend on rustc for this, but rustc_target doesn't compile on stable,

+// and t-compiler prefers for it to stay this way.

+

+static TARGET_FEATURE_IMPLICATIONS: LazyLock<FxHashMap<Symbol, Box<[Symbol]>>> =

+ LazyLock::new(|| {

+ let mut result = FxHashMap::<Symbol, FxHashSet<Symbol>>::default();

+ for &(feature_str, implications) in TARGET_FEATURE_IMPLICATIONS_RAW {

+ let feature = Symbol::intern(feature_str);

+ let implications = implications.iter().copied().map(Symbol::intern);

+ // Some target features appear in two archs, e.g. Arm and x86.

+ // Sometimes they contain different implications, e.g. `aes`.

+ // We should probably choose by the active arch, but for now just merge them.

+ result.entry(feature).or_default().extend(implications);

+ }

+ let mut result = result

+ .into_iter()

+ .map(|(feature, implications)| (feature, Box::from_iter(implications)))

+ .collect::<FxHashMap<_, _>>();

+ result.shrink_to_fit();

+ result

+ });

+

+// spellchecker:off

+const TARGET_FEATURE_IMPLICATIONS_RAW: &[(&str, &[&str])] = &[

+ // Arm

+ ("aes", &["neon"]),

+ ("dotprod", &["neon"]),

+ ("fp-armv8", &["vfp4"]),

+ ("fp16", &["neon"]),

+ ("i8mm", &["neon"]),

+ ("neon", &["vfp3"]),

+ ("sha2", &["neon"]),

+ ("v6", &["v5te"]),

+ ("v6k", &["v6"]),

+ ("v6t2", &["v6k", "thumb2"]),

+ ("v7", &["v6t2"]),

+ ("v8", &["v7"]),

+ ("vfp3", &["vfp2", "d32"]),

+ ("vfp4", &["vfp3"]),

+ // Aarch64

+ ("aes", &["neon"]),

+ ("dotprod", &["neon"]),

+ ("dpb2", &["dpb"]),

+ ("f32mm", &["sve"]),

+ ("f64mm", &["sve"]),

+ ("fcma", &["neon"]),

+ ("fhm", &["fp16"]),

+ ("fp16", &["neon"]),

+ ("fp8", &["faminmax", "lut", "bf16"]),

+ ("fp8dot2", &["fp8dot4"]),

+ ("fp8dot4", &["fp8fma"]),

+ ("fp8fma", &["fp8"]),

+ ("jsconv", &["neon"]),

+ ("lse128", &["lse"]),

+ ("rcpc2", &["rcpc"]),

+ ("rcpc3", &["rcpc2"]),

+ ("rdm", &["neon"]),

+ ("sha2", &["neon"]),

+ ("sha3", &["sha2"]),

+ ("sm4", &["neon"]),

+ ("sme", &["bf16"]),

+ ("sme-b16b16", &["bf16", "sme2", "sve-b16b16"]),

+ ("sme-f16f16", &["sme2"]),

+ ("sme-f64f64", &["sme"]),

+ ("sme-f8f16", &["sme-f8f32"]),

+ ("sme-f8f32", &["sme2", "fp8"]),

+ ("sme-fa64", &["sme", "sve2"]),

+ ("sme-i16i64", &["sme"]),

+ ("sme2", &["sme"]),

+ ("sme2p1", &["sme2"]),

+ ("ssve-fp8dot2", &["ssve-fp8dot4"]),

+ ("ssve-fp8dot4", &["ssve-fp8fma"]),

+ ("ssve-fp8fma", &["sme2", "fp8"]),

+ ("sve", &["neon"]),

+ ("sve-b16b16", &["bf16"]),

+ ("sve2", &["sve"]),

+ ("sve2-aes", &["sve2", "aes"]),

+ ("sve2-bitperm", &["sve2"]),

+ ("sve2-sha3", &["sve2", "sha3"]),

+ ("sve2-sm4", &["sve2", "sm4"]),

+ ("sve2p1", &["sve2"]),

+ ("v8.1a", &["crc", "lse", "rdm", "pan", "lor", "vh"]),

+ ("v8.2a", &["v8.1a", "ras", "dpb"]),

+ ("v8.3a", &["v8.2a", "rcpc", "paca", "pacg", "jsconv"]),

+ ("v8.4a", &["v8.3a", "dotprod", "dit", "flagm"]),

+ ("v8.5a", &["v8.4a", "ssbs", "sb", "dpb2", "bti"]),

+ ("v8.6a", &["v8.5a", "bf16", "i8mm"]),

+ ("v8.7a", &["v8.6a", "wfxt"]),

+ ("v8.8a", &["v8.7a", "hbc", "mops"]),

+ ("v8.9a", &["v8.8a", "cssc"]),

+ ("v9.1a", &["v9a", "v8.6a"]),

+ ("v9.2a", &["v9.1a", "v8.7a"]),

+ ("v9.3a", &["v9.2a", "v8.8a"]),

+ ("v9.4a", &["v9.3a", "v8.9a"]),

+ ("v9.5a", &["v9.4a"]),

+ ("v9a", &["v8.5a", "sve2"]),

+ // x86

+ ("aes", &["sse2"]),

+ ("amx-bf16", &["amx-tile"]),

+ ("amx-complex", &["amx-tile"]),

+ ("amx-fp16", &["amx-tile"]),

+ ("amx-int8", &["amx-tile"]),

+ ("avx", &["sse4.2"]),

+ ("avx2", &["avx"]),

+ ("avx512bf16", &["avx512bw"]),

+ ("avx512bitalg", &["avx512bw"]),

+ ("avx512bw", &["avx512f"]),

+ ("avx512cd", &["avx512f"]),

+ ("avx512dq", &["avx512f"]),

+ ("avx512f", &["avx2", "fma", "f16c"]),

+ ("avx512fp16", &["avx512bw", "avx512vl", "avx512dq"]),

+ ("avx512ifma", &["avx512f"]),

+ ("avx512vbmi", &["avx512bw"]),

+ ("avx512vbmi2", &["avx512bw"]),

+ ("avx512vl", &["avx512f"]),

+ ("avx512vnni", &["avx512f"]),

+ ("avx512vp2intersect", &["avx512f"]),

+ ("avx512vpopcntdq", &["avx512f"]),

+ ("avxifma", &["avx2"]),

+ ("avxneconvert", &["avx2"]),

+ ("avxvnni", &["avx2"]),

+ ("avxvnniint16", &["avx2"]),

+ ("avxvnniint8", &["avx2"]),

+ ("f16c", &["avx"]),

+ ("fma", &["avx"]),

+ ("gfni", &["sse2"]),

+ ("kl", &["sse2"]),

+ ("pclmulqdq", &["sse2"]),

+ ("sha", &["sse2"]),

+ ("sha512", &["avx2"]),

+ ("sm3", &["avx"]),

+ ("sm4", &["avx2"]),

+ ("sse2", &["sse"]),

+ ("sse3", &["sse2"]),

+ ("sse4.1", &["ssse3"]),

+ ("sse4.2", &["sse4.1"]),

+ ("sse4a", &["sse3"]),

+ ("ssse3", &["sse3"]),

+ ("vaes", &["avx2", "aes"]),

+ ("vpclmulqdq", &["avx", "pclmulqdq"]),

+ ("widekl", &["kl"]),

+ ("xop", &[/*"fma4", */ "avx", "sse4a"]),

+ ("xsavec", &["xsave"]),

+ ("xsaveopt", &["xsave"]),

+ ("xsaves", &["xsave"]),

+ // Hexagon

+ ("hvx-length128b", &["hvx"]),

+ // PowerPC

+ ("power10-vector", &["power9-vector"]),

+ ("power8-altivec", &["altivec"]),

+ ("power8-crypto", &["power8-altivec"]),

+ ("power8-vector", &["vsx", "power8-altivec"]),

+ ("power9-altivec", &["power8-altivec"]),

+ ("power9-vector", &["power8-vector", "power9-altivec"]),

+ ("vsx", &["altivec"]),

+ // MIPS

+ // RISC-V

+ ("a", &["zaamo", "zalrsc"]),

+ ("d", &["f"]),

+ ("zabha", &["zaamo"]),

+ ("zdinx", &["zfinx"]),

+ ("zfh", &["zfhmin"]),

+ ("zfhmin", &["f"]),

+ ("zhinx", &["zhinxmin"]),

+ ("zhinxmin", &["zfinx"]),

+ ("zk", &["zkn", "zkr", "zkt"]),

+ ("zkn", &["zbkb", "zbkc", "zbkx", "zkne", "zknd", "zknh"]),

+ ("zks", &["zbkb", "zbkc", "zbkx", "zksed", "zksh"]),

+ // WASM

+ ("relaxed-simd", &["simd128"]),

+ // BPF

+ ("alu32", &[]),

+ // CSKY

+ ("10e60", &["7e10"]),

+ ("2e3", &["e2"]),

+ ("3e3r2", &["3e3r1", "doloop"]),

+ ("3e3r3", &["doloop"]),

+ ("3e7", &["2e3"]),

+ ("7e10", &["3e7"]),

+ ("e1", &["elrw"]),

+ ("e2", &["e2"]),

+ ("mp", &["2e3"]),

+ ("mp1e2", &["3e7"]),

+ // LoongArch

+ ("d", &["f"]),

+ ("lasx", &["lsx"]),

+ ("lsx", &["d"]),

+ // IBM Z

+ ("nnp-assist", &["vector"]),

+ ("vector-enhancements-1", &["vector"]),

+ ("vector-enhancements-2", &["vector-enhancements-1"]),

+ ("vector-packed-decimal", &["vector"]),

+ ("vector-packed-decimal-enhancement", &["vector-packed-decimal"]),

+ ("vector-packed-decimal-enhancement-2", &["vector-packed-decimal-enhancement"]),

+ // SPARC

+ // m68k

+ ("isa-68010", &["isa-68000"]),

+ ("isa-68020", &["isa-68010"]),

+ ("isa-68030", &["isa-68020"]),

+ ("isa-68040", &["isa-68030", "isa-68882"]),

+ ("isa-68060", &["isa-68040"]),

+ ("isa-68882", &["isa-68881"]),

+];

+// spellchecker:on

+use base_db::{CrateId, SourceDatabaseFileInputExt as _};

+ display::{DisplayTarget, HirDisplay},

+ let mut defs: Vec<(DefWithBodyId, CrateId)> = Vec::new();

+ let def = match it {

+ };

+ defs.push((def, module.krate()))

+ defs.sort_by_key(|(def, _)| match def {

+ for (def, krate) in defs {

+ let display_target = DisplayTarget::from_crate(&db, krate);

+ ty.display_test(&db, display_target).to_string()

+ ty.display_test(&db, display_target).to_string()

+ mismatch.expected.display_test(&db, display_target),

+ mismatch.actual.display_test(&db, display_target)

+ body_source_map: Arc<BodySourceMap>,

+ krate: CrateId| {

+ let display_target = DisplayTarget::from_crate(&db, krate);

+ ty.display_test(&db, display_target)

+ mismatch.expected.display_test(&db, display_target),

+ mismatch.actual.display_test(&db, display_target),

+ let mut defs: Vec<(DefWithBodyId, CrateId)> = Vec::new();

+ let def = match it {

+ };

+ defs.push((def, module.krate()))

+ defs.sort_by_key(|(def, _)| match def {

+ for (def, krate) in defs {

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

+use crate::display::{DisplayTarget, HirDisplay};

+ let capture_ty = capture

+ .ty

+ .skip_binders()

+ .display_test(db, DisplayTarget::from_crate(db, module.krate()))

+ .to_string();

+

+#[test]

+fn regression_19196() {