rust-analyzer

diff --git a/crates/hir-ty/src/layout.rs b/crates/hir-ty/src/layout.rs
index a4e49e0aa1..2ac1792ba8 100644
--- a/crates/hir-ty/src/layout.rs
+++ b/crates/hir-ty/src/layout.rs

@@ -6,16 +6,15 @@ use base_db::ra_salsa::Cycle;

use chalk_ir::{AdtId, FloatTy, IntTy, TyKind, UintTy};

use hir_def::{

layout::{

- BackendRepr, FieldsShape, Float, Integer, LayoutCalculator, LayoutCalculatorError,

- LayoutData, Primitive, ReprOptions, Scalar, Size, StructKind, TargetDataLayout,

+ Float, Integer, LayoutCalculator, LayoutCalculatorError,

+ LayoutData, Primitive, ReprOptions, Scalar, StructKind, TargetDataLayout,

WrappingRange,

LocalFieldId, StructId,

};

use la_arena::{Idx, RawIdx};

use rustc_abi::AddressSpace;

-use rustc_hashes::Hash64;

-use rustc_index::{IndexSlice, IndexVec};

+use rustc_index::IndexVec;

use triomphe::Arc;

@@ -23,7 +22,6 @@ use crate::{

consteval::try_const_usize,

db::{HirDatabase, InternedClosure},

infer::normalize,

- layout::adt::struct_variant_idx,

utils::ClosureSubst,

Interner, ProjectionTy, Substitution, TraitEnvironment, Ty,

};

@@ -125,82 +123,34 @@ impl<'a> LayoutCx<'a> {

}

-// FIXME: move this to the `rustc_abi`.

fn layout_of_simd_ty(

db: &dyn HirDatabase,

id: StructId,

+ repr_packed: bool,

subst: &Substitution,

env: Arc<TraitEnvironment>,

dl: &TargetDataLayout,

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

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

- // Supported SIMD vectors are homogeneous ADTs with at least one field:

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

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

- // * #[repr(simd)] struct S { it: T, y: T, z: T, w: T }

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

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

- let f0_ty = match fields.iter().next() {

- Some(it) => it.1.clone().substitute(Interner, subst),

- None => return Err(LayoutError::InvalidSimdType),

- };

- // The element type and number of elements of the SIMD vector

- // are obtained from:

- //

- // * the element type and length of the single array field, if

- // the first field is of array type, or

- //

- // * the homogeneous field type and the number of fields.

- let (e_ty, e_len, is_array) = if let TyKind::Array(e_ty, _) = f0_ty.kind(Interner) {

- // Extract the number of elements from the layout of the array field:

- let FieldsShape::Array { count, .. } = db.layout_of_ty(f0_ty.clone(), env.clone())?.fields

- else {

- return Err(LayoutError::Unknown);

- };

- (e_ty.clone(), count, true)

- } else {

- // First ADT field is not an array:

- (f0_ty, fields.iter().count() as u64, false)

+ 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);

};

- // Compute the ABI of the element type:

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

let e_ly = db.layout_of_ty(e_ty, env)?;

- let BackendRepr::Scalar(e_abi) = e_ly.backend_repr else {

- return Err(LayoutError::Unknown);

- };

- // Compute the size and alignment of the vector:

- let size = e_ly

- .size

- .checked_mul(e_len, dl)

- .ok_or(LayoutError::BadCalc(LayoutCalculatorError::SizeOverflow))?;

- let align = dl.llvmlike_vector_align(size);

- let size = size.align_to(align.abi);

- // Compute the placement of the vector fields:

- let fields = if is_array {

- FieldsShape::Arbitrary { offsets: [Size::ZERO].into(), memory_index: [0].into() }

- } else {

- FieldsShape::Array { stride: e_ly.size, count: e_len }

- };

- Ok(Arc::new(Layout {

- variants: Variants::Single { index: struct_variant_idx() },

- fields,

- backend_repr: BackendRepr::SimdVector { element: e_abi, count: e_len },

- largest_niche: e_ly.largest_niche,

- uninhabited: false,

- size,

- align,

- max_repr_align: None,

- unadjusted_abi_align: align.abi,

- randomization_seed: Hash64::ZERO,

- }))

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

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

}

pub fn layout_of_ty_query(

@@ -215,13 +165,14 @@ pub fn layout_of_ty_query(

let dl = &*target;

let cx = LayoutCx::new(dl);

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

- let result = match ty.kind(Interner) {

+ let kind = ty.kind(Interner);

+ let result = match kind {

TyKind::Adt(AdtId(def), subst) => {

if let hir_def::AdtId::StructId(s) = def {

let data = db.struct_data(*s);

let repr = data.repr.unwrap_or_default();

if repr.simd() {

- return layout_of_simd_ty(db, *s, subst, trait_env, &target);

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

}

};

return db.layout_of_adt(*def, subst.clone(), trait_env);

@@ -241,7 +192,7 @@ pub fn layout_of_ty_query(

valid_range: WrappingRange { start: 0, end: 0x10FFFF },

- chalk_ir::Scalar::Int(i) => scalar(

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

dl,

Primitive::Int(

match i {

@@ -254,8 +205,8 @@ pub fn layout_of_ty_query(

true,

- ),

- chalk_ir::Scalar::Uint(i) => scalar(

+ )),

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

dl,

Primitive::Int(

match i {

@@ -268,8 +219,8 @@ pub fn layout_of_ty_query(

false,

- ),

- chalk_ir::Scalar::Float(f) => scalar(

+ )),

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

dl,

Primitive::Float(match f {

FloatTy::F16 => Float::F16,

@@ -277,7 +228,7 @@ pub fn layout_of_ty_query(

FloatTy::F64 => Float::F64,

FloatTy::F128 => Float::F128,

}),

- ),

+ )),

TyKind::Tuple(len, tys) => {

let kind = if *len == 0 { StructKind::AlwaysSized } else { StructKind::MaybeUnsized };

@@ -293,56 +244,16 @@ pub fn layout_of_ty_query(

TyKind::Array(element, count) => {

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

let element = db.layout_of_ty(element.clone(), trait_env)?;

- let size = element

- .size

- .checked_mul(count, dl)

- .ok_or(LayoutError::BadCalc(LayoutCalculatorError::SizeOverflow))?;

- let backend_repr = BackendRepr::Memory { sized: true };

- let largest_niche = if count != 0 { element.largest_niche } else { None };

- let uninhabited = if count != 0 { element.uninhabited } else { false };

- Layout {

- variants: Variants::Single { index: struct_variant_idx() },

- fields: FieldsShape::Array { stride: element.size, count },

- backend_repr,

- largest_niche,

- uninhabited,

- align: element.align,

- size,

- max_repr_align: None,

- unadjusted_abi_align: element.align.abi,

- randomization_seed: Hash64::ZERO,

- }

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

}

TyKind::Slice(element) => {

let element = db.layout_of_ty(element.clone(), trait_env)?;

- Layout {

- variants: Variants::Single { index: struct_variant_idx() },

- fields: FieldsShape::Array { stride: element.size, count: 0 },

- backend_repr: BackendRepr::Memory { sized: false },

- largest_niche: None,

- uninhabited: false,

- align: element.align,

- size: Size::ZERO,

- max_repr_align: None,

- unadjusted_abi_align: element.align.abi,

- randomization_seed: Hash64::ZERO,

- }

+ 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)?

}

- TyKind::Str => Layout {

- variants: Variants::Single { index: struct_variant_idx() },

- fields: FieldsShape::Array { stride: Size::from_bytes(1), count: 0 },

- backend_repr: BackendRepr::Memory { sized: false },

- largest_niche: None,

- uninhabited: false,

- align: dl.i8_align,

- size: Size::ZERO,

- max_repr_align: None,

- unadjusted_abi_align: dl.i8_align.abi,

- randomization_seed: Hash64::ZERO,

- },

// Potentially-wide pointers.

TyKind::Ref(_, _, pointee) | TyKind::Raw(_, pointee) => {

let mut data_ptr = scalar_unit(dl, Primitive::Pointer(AddressSpace::DATA));

@@ -380,17 +291,12 @@ pub fn layout_of_ty_query(

};

// Effectively a (ptr, meta) tuple.

- cx.calc.scalar_pair(data_ptr, metadata)

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

}

- TyKind::FnDef(_, _) => layout_of_unit(&cx)?,

- TyKind::Never => cx.calc.layout_of_never_type(),

- TyKind::Dyn(_) | TyKind::Foreign(_) => {

- let mut unit = layout_of_unit(&cx)?;

- match &mut unit.backend_repr {

- BackendRepr::Memory { sized } => *sized = false,

- _ => return Err(LayoutError::Unknown),

- }

- unit

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

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

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

+ LayoutData::unit(dl, sized)

}

TyKind::Function(_) => {

let mut ptr = scalar_unit(dl, Primitive::Pointer(dl.instruction_address_space));

@@ -459,16 +365,6 @@ pub fn layout_of_ty_recover(

Err(LayoutError::RecursiveTypeWithoutIndirection)

}

-fn layout_of_unit(cx: &LayoutCx<'_>) -> Result<Layout, LayoutError> {

- cx.calc

- .univariant::<RustcFieldIdx, RustcEnumVariantIdx, &&Layout>(

- IndexSlice::empty(),

- &ReprOptions::default(),

- StructKind::AlwaysSized,

- )

- .map_err(Into::into)

fn struct_tail_erasing_lifetimes(db: &dyn HirDatabase, pointee: Ty) -> Ty {

match pointee.kind(Interner) {

TyKind::Adt(AdtId(hir_def::AdtId::StructId(i)), subst) => {

@@ -499,9 +395,5 @@ fn scalar_unit(dl: &TargetDataLayout, value: Primitive) -> Scalar {

Scalar::Initialized { value, valid_range: WrappingRange::full(value.size(dl)) }

}

-fn scalar(dl: &TargetDataLayout, value: Primitive) -> Layout {

- Layout::scalar(dl, scalar_unit(dl, value))

#[cfg(test)]

mod tests;

diff --git a/crates/hir-ty/src/layout/adt.rs b/crates/hir-ty/src/layout/adt.rs
index 0ba765bd75..eb4729fab8 100644
--- a/crates/hir-ty/src/layout/adt.rs
+++ b/crates/hir-ty/src/layout/adt.rs

@@ -16,16 +16,12 @@ use triomphe::Arc;

use crate::{

db::HirDatabase,

lang_items::is_unsafe_cell,

- layout::{field_ty, Layout, LayoutError, RustcEnumVariantIdx},

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

Substitution, TraitEnvironment,

};

use super::LayoutCx;

-pub(crate) fn struct_variant_idx() -> RustcEnumVariantIdx {

- RustcEnumVariantIdx(0)

pub fn layout_of_adt_query(

db: &dyn HirDatabase,

def: AdtId,

diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index 707c437772..e0dcc01821 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs

@@ -12,9 +12,6 @@ extern crate ra_ap_rustc_index as rustc_index;

#[cfg(feature = "in-rust-tree")]

extern crate rustc_abi;

-#[cfg(feature = "in-rust-tree")]

-extern crate rustc_hashes;

#[cfg(not(feature = "in-rust-tree"))]

extern crate ra_ap_rustc_abi as rustc_abi;

diff --git a/crates/ide-db/src/generated/lints.rs b/crates/ide-db/src/generated/lints.rs
index 333dbe3305..0a7a7d1fb2 100644
--- a/crates/ide-db/src/generated/lints.rs
+++ b/crates/ide-db/src/generated/lints.rs

@@ -12317,40 +12317,6 @@ will unnecessarily extend the stack frame.

deny_since: None,

Lint {

- label: "unsized_tuple_coercion",

- description: r##"# `unsized_tuple_coercion`

-The tracking issue for this feature is: [#42877]

-[#42877]: https://github.com/rust-lang/rust/issues/42877

-------------------------

-This is a part of [RFC0401]. According to the RFC, there should be an implementation like this:

-```rust,ignore (partial-example)

-impl<..., T, U: ?Sized> Unsized<(..., U)> for (..., T) where T: Unsized<U> {}

-```

-This implementation is currently gated behind `#[feature(unsized_tuple_coercion)]` to avoid insta-stability. Therefore you can use it like this:

-```rust

-#![feature(unsized_tuple_coercion)]

-fn main() {

- let x : ([i32; 3], [i32; 3]) = ([1, 2, 3], [4, 5, 6]);

- let y : &([i32; 3], [i32]) = &x;

- assert_eq!(y.1[0], 4);

-```

-[RFC0401]: https://github.com/rust-lang/rfcs/blob/master/text/0401-coercions.md

-"##,

- default_severity: Severity::Allow,

- warn_since: None,

- deny_since: None,

- },

- Lint {

label: "unwrap_infallible",

description: r##"# `unwrap_infallible`

diff --git a/lib/line-index/src/lib.rs b/lib/line-index/src/lib.rs
index bc87ada3eb..905da330e6 100644
--- a/lib/line-index/src/lib.rs
+++ b/lib/line-index/src/lib.rs

@@ -257,6 +257,8 @@ fn analyze_source_file_dispatch(

/// SSE2 intrinsics to quickly find all newlines.

#[target_feature(enable = "sse2")]

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]

+// This can be removed once 1.87 is stable due to some intrinsics switching to safe.

+#[allow(unsafe_op_in_unsafe_fn)]

unsafe fn analyze_source_file_sse2(

src: &str,

lines: &mut Vec<TextSize>,

@@ -287,17 +289,17 @@ unsafe fn analyze_source_file_sse2(

// For character in the chunk, see if its byte value is < 0, which

// indicates that it's part of a UTF-8 char.

- let multibyte_test = unsafe { _mm_cmplt_epi8(chunk, _mm_set1_epi8(0)) };

+ let multibyte_test = _mm_cmplt_epi8(chunk, _mm_set1_epi8(0));

// Create a bit mask from the comparison results.

- let multibyte_mask = unsafe { _mm_movemask_epi8(multibyte_test) };

+ let multibyte_mask = _mm_movemask_epi8(multibyte_test);

// If the bit mask is all zero, we only have ASCII chars here:

if multibyte_mask == 0 {

assert!(intra_chunk_offset == 0);

// Check for newlines in the chunk

- let newlines_test = unsafe { _mm_cmpeq_epi8(chunk, _mm_set1_epi8(b'\n' as i8)) };

- let newlines_mask = unsafe { _mm_movemask_epi8(newlines_test) };

+ let newlines_test = _mm_cmpeq_epi8(chunk, _mm_set1_epi8(b'\n' as i8));

+ let newlines_mask = _mm_movemask_epi8(newlines_test);

if newlines_mask != 0 {

// All control characters are newlines, record them

@@ -354,15 +356,19 @@ unsafe fn analyze_source_file_sse2(

// The mask is a 64-bit integer, where each 4-bit corresponds to a u8 in the

// input vector. The least significant 4 bits correspond to the first byte in

// the vector.

+// This can be removed once 1.87 is stable due to some intrinsics switching to safe.

+#[allow(unsafe_op_in_unsafe_fn)]

unsafe fn move_mask(v: std::arch::aarch64::uint8x16_t) -> u64 {

use std::arch::aarch64::*;

- let nibble_mask = unsafe { vshrn_n_u16(vreinterpretq_u16_u8(v), 4) };

- unsafe { vget_lane_u64(vreinterpret_u64_u8(nibble_mask), 0) }

+ let nibble_mask = vshrn_n_u16(vreinterpretq_u16_u8(v), 4);

+ vget_lane_u64(vreinterpret_u64_u8(nibble_mask), 0)

}

#[target_feature(enable = "neon")]

#[cfg(all(target_arch = "aarch64", target_endian = "little"))]

+// This can be removed once 1.87 is stable due to some intrinsics switching to safe.

+#[allow(unsafe_op_in_unsafe_fn)]

unsafe fn analyze_source_file_neon(

src: &str,

lines: &mut Vec<TextSize>,

@@ -376,7 +382,7 @@ unsafe fn analyze_source_file_neon(

let chunk_count = src.len() / CHUNK_SIZE;

- let newline = unsafe { vdupq_n_s8(b'\n' as i8) };

+ let newline = vdupq_n_s8(b'\n' as i8);

// This variable keeps track of where we should start decoding a

// chunk. If a multi-byte character spans across chunk boundaries,

@@ -390,7 +396,7 @@ unsafe fn analyze_source_file_neon(

// For character in the chunk, see if its byte value is < 0, which

// indicates that it's part of a UTF-8 char.

- let multibyte_test = unsafe { vcltzq_s8(chunk) };

+ let multibyte_test = vcltzq_s8(chunk);

// Create a bit mask from the comparison results.

let multibyte_mask = unsafe { move_mask(multibyte_test) };

@@ -399,7 +405,7 @@ unsafe fn analyze_source_file_neon(

assert!(intra_chunk_offset == 0);

// Check for newlines in the chunk

- let newlines_test = unsafe { vceqq_s8(chunk, newline) };

+ let newlines_test = vceqq_s8(chunk, newline);

let mut newlines_mask = unsafe { move_mask(newlines_test) };

// If the bit mask is not all zero, there are newlines in this chunk.