adder-codec-rs 0.2.7/src/transcoder/source/davis.rs

595	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
596	unsafe {

afe4404 0.2.2/src/value_reading/mod.rs

45	// We also allow wraps since we take the sign into account.
46	#[allow(clippy::cast_precision_loss, clippy::cast_possible_wrap)]
47	for (i, &register_value) in [

afl 0.12.12/src/bin/cargo-afl.rs

274	unsafe {
275	#[allow(clippy::cast_possible_wrap)]
276	let ret = libc::kill(pid as i32, libc::SIGTERM);

alfred-rs 0.7.1/src/updater/tests.rs

128	#[allow(clippy::cast_possible_wrap)]
129	#[test]

alloc-wg 0.9.0/src/vec.rs

2231	#[must_use]
2232	#[allow(clippy::cast_possible_wrap)]
2233	fn into_iter(mut self) -> IntoIter<T, A> {
3372	#[allow(clippy::cast_possible_wrap)]
3373	unsafe fn offset_from<T>(p: const T, origin: const T) -> isize

arcon 0.2.1/src/index/hash_table/sse2.rs

53	#[allow(
54	clippy::cast_possible_wrap, // byte: u8 as i8
55	// byte: i32 as u16

astrotime 0.1.0/src/date_time.rs

637	#[allow(clippy::cast_possible_wrap)]
638	fn add(self, rhs: Duration) -> Self {
649	#[allow(clippy::cast_possible_wrap)]
650	fn sub(self, rhs: Duration) -> Self {
661	#[allow(clippy::cast_possible_wrap)]
662	fn sub(self, other: Self) -> Duration {

au 0.10.0/src/rational_function/mod.rs

92	#[must_use]
93	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
94	pub fn relative_degree(&self) -> i32 {

automaat-server 0.1.0/src/resources/step.rs

204	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
205	impl<'a> TryFrom<(usize, &'a graphql::CreateStepInput)> for NewStep<'a> {

automatica 1.0.0/src/rational_function/mod.rs

126	#[must_use]
127	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
128	pub fn relative_degree(&self) -> i32 {

avocado 0.6.0/src/utils.rs

6

/// the value permits. Constructs an error message based on `msg` otherwise.

7

#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::if_same_then_else)]

8

pub fn int_to_usize_with_msg<T: Into<i64>>(x: T, msg: &str) -> Result<usize> {

belgium 0.2.0/src/alu.rs

77	#[allow(clippy::cast_sign_loss)]
78	#[allow(clippy::cast_possible_wrap)]
79	NEG => (-(val_right as i8) as u8, false),

bevy_save 0.3.0/src/rollbacks.rs

31	/// Rolling back or further farther than what is valid will just return the oldest / newest snapshot.
32	#[allow(clippy::cast_possible_wrap)]
33	#[allow(clippy::cast_sign_loss)]

bmart 0.2.4/src/process.rs

46	std::thread::sleep(timeout);
47	#[allow(clippy::cast_possible_wrap)]
48	#[cfg(not(target_os = "windows"))]
99	#[allow(clippy::cast_possible_wrap)]
100	#[cfg(not(target_os = "windows"))]
131	#[allow(clippy::cast_possible_wrap)]
132	#[cfg(not(target_os = "windows"))]
283	sleep(timeout).await;
284	#[allow(clippy::cast_possible_wrap)]
285	#[cfg(not(target_os = "windows"))]
360	fut_stderr.abort();
361	#[allow(clippy::cast_possible_wrap)]
362	ppid.map(\|pid\| async move {

bme280-rs 0.1.0/src/calibration.rs

69	fn from(data: &[u8; TOTAL_LENGTH]) -> Self {
70	#[allow(clippy::cast_possible_wrap)] // Using documentation
71	let dig_h6 = data[32] as i8;
100	pub fn compensate_temperature(&self, adc_t: u32) -> i32 {
101	#[allow(clippy::cast_possible_wrap)] // Using reference algorithm
102	let adc_t = adc_t as i32;

bocu1 0.1.0/src/trailing_byte_selection.rs

20	// unit, leaving 256 - 13 = 243 values.
21	#[allow(clippy::cast_possible_wrap)]
22	#[allow(clippy::cast_possible_truncation)]

bonsaidb-core 0.4.1/src/keyvalue/implementation/get.rs

63	/// cannot be done without losing data, an error will be returned.
64	#[allow(clippy::cast_possible_wrap)]
65	pub fn into_i64(self) -> Result<Option<i64>, Error> {
113	/// overflows will be allowed during conversion.
114	#[allow(clippy::cast_possible_wrap)]
115	pub fn into_i64_lossy(self, saturating: bool) -> Result<Option<i64>, Error> {
228	/// cannot be done without losing data, an error will be returned.
229	#[allow(clippy::cast_possible_wrap)]
230	pub async fn into_i64(self) -> Result<Option<i64>, Error> {
278	/// overflows will be allowed during conversion.
279	#[allow(clippy::cast_possible_wrap)]
280	pub async fn into_i64_lossy(self, saturating: bool) -> Result<Option<i64>, Error> {

bonsaidb-core 0.4.1/src/keyvalue.rs

570	#[must_use]
571	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
572	pub fn as_i64_lossy(&self, saturating: bool) -> i64 {

boreal 0.1.0/src/module/math.rs

235	#[allow(clippy::cast_possible_wrap)]
236	Some(if a < b {
256	#[allow(clippy::cast_possible_wrap)]
257	Some(if a > b {

boreal 0.1.0/src/module/pe.rs

21	#[cfg(feature = "openssl")]
22	#[allow(clippy::cast_possible_wrap)]
23	#[allow(clippy::cast_possible_truncation)]

bracket-algorithm-traits 0.8.7/src/algorithm3d.rs

29	/// Convert an array index to a point.
30	#[allow(clippy::cast_possible_wrap)]
31	#[allow(clippy::cast_possible_truncation)]

cardpack 0.4.14/src/cards/rank.rs

161	clippy::cast_possible_truncation,
162	clippy::cast_possible_wrap,
163	clippy::into_iter_on_ref

cardpack 0.4.14/src/cards/suit.rs

92	#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
93	fn top_down_value(len: usize, i: usize) -> u32 {

cargo-cache 0.8.3/src/date.rs

45	};
46	#[allow(clippy::cast_possible_wrap)]
47	let nd =

cargo-cache 0.8.3/src/library.rs

662	) -> String {
663	#[allow(clippy::cast_possible_wrap)]
664	let size_diff: i64 = size_after as i64 - size_before as i64;

cetkaik_naive_representation 1.3.0/src/absolute.rs

67	#[must_use]
68	#[allow(clippy::cast_possible_wrap)]
69	pub const fn same_direction(origin: Coord, a: Coord, b: Coord) -> bool {

chemfiles 0.10.3/src/trajectory.rs

73	unsafe {
74	#[allow(clippy::cast_possible_wrap)]
75	let handle = chfl_trajectory_open(path.as_ptr(), mode as c_char);
111	unsafe {
112	#[allow(clippy::cast_possible_wrap)]
113	let handle = chfl_trajectory_with_format(

chksum-arch 0.1.0-rc3/src/x86.rs

75	impl From<[u8; 4]> for u8x4 {
76	#[allow(clippy::unseparated_literal_suffix, clippy::cast_possible_wrap)]
77	#[cfg_attr(not(debug_assertions), inline(always))]
125	impl From<(u8, u8, u8, u8)> for u8x4 {
126	#[allow(clippy::unseparated_literal_suffix, clippy::cast_possible_wrap)]
127	#[cfg_attr(not(debug_assertions), inline(always))]
185	impl From1<u8> for u8x4 {
186	#[allow(clippy::unseparated_literal_suffix, clippy::cast_possible_wrap)]
187	#[cfg_attr(not(debug_assertions), inline(always))]
436	impl From<u32> for u32x4 {
437	#[allow(clippy::cast_possible_wrap)]
438	#[cfg_attr(not(debug_assertions), inline(always))]
456	impl From<[u32; 4]> for u32x4 {
457	#[allow(clippy::cast_possible_wrap)]
458	#[cfg_attr(not(debug_assertions), inline(always))]

chksum-arch 0.1.0-rc3/src/x86_64.rs

75	impl From<[u8; 4]> for u8x4 {
76	#[allow(clippy::unseparated_literal_suffix, clippy::cast_possible_wrap)]
77	#[cfg_attr(not(debug_assertions), inline(always))]
125	impl From<(u8, u8, u8, u8)> for u8x4 {
126	#[allow(clippy::unseparated_literal_suffix, clippy::cast_possible_wrap)]
127	#[cfg_attr(not(debug_assertions), inline(always))]
185	impl From1<u8> for u8x4 {
186	#[allow(clippy::unseparated_literal_suffix, clippy::cast_possible_wrap)]
187	#[cfg_attr(not(debug_assertions), inline(always))]
436	impl From<u32> for u32x4 {
437	#[allow(clippy::cast_possible_wrap)]
438	#[cfg_attr(not(debug_assertions), inline(always))]
456	impl From<[u32; 4]> for u32x4 {
457	#[allow(clippy::cast_possible_wrap)]
458	#[cfg_attr(not(debug_assertions), inline(always))]

cognito-user-reader 1.0.3/src/cli/cli.rs

68	#[allow(clippy::cast_possible_wrap)]
69	fn parse_date(src: &str) -> DateTime<Utc> {

cpclib-asm 0.6.0/src/assembler/mod.rs

3516	/// - Stop: store counter count
3517	#[allow(clippy::cast_possible_wrap)]
3518	pub fn visit_stableticker(

cpclib-imgconverter 0.6.0/src/main.rs

391	// TODO - Add the ability to import a target palette
392	#[allow(clippy::cast_possible_wrap)]
393	#[allow(clippy::cast_possible_truncation)]

cvt-trait 1.2.0/src/windows.rs

68	fn nt_status_to_error(status: i32) -> Error {
69	#[allow(clippy::cast_possible_wrap)]
70	Error::from_raw_os_error(unsafe { RtlNtStatusToDosError(status) } as _)

daachorse 1.0.0/src/charwise.rs

692	/// `state_id` must be smaller than the length of states.
693	#[allow(clippy::cast_possible_wrap)]
694	#[inline(always)]

dashmap-shard 0.1.1/src/raw/sse2.rs

74	#[allow(
75	clippy::cast_possible_wrap, // byte: u8 as i8
76	// byte: i32 as u16
131	#[allow(
132	clippy::cast_possible_wrap, // byte: 0x80_u8 as i8
133	)]

dbgen 0.8.0/src/bytes.rs

131	/// Whether the byte is a leading byte in UTF-8 (`0x00..=0x7F`, `0xC0..=0xFF`).
132	#[allow(clippy::cast_possible_wrap)] // the wrap is intentional.
133	fn is_utf8_leading_byte(b: u8) -> bool {

dbgen 0.8.0/src/functions/string.rs

177

        let (mut input, placing, start, length) = args_4(span, args, None, None, None, Some(None))?;

178

        #[allow(clippy::cast_possible_wrap)] // length will never > isize::MAX.

179

        let length = length.unwrap_or_else(|| self.0.length_of(&placing) as isize);

dcv-color-primitives 0.5.1/src/convert_image/avx2.rs

454	#[cfg(not(tarpaulin_include))]
455	#[allow(clippy::cast_possible_wrap)]
456	const fn shuffle(z: u32, y: u32, x: u32, w: u32) -> i32 {

dcv-color-primitives 0.5.1/src/convert_image/common.rs

37	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
38	#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
39	pub const fn i32x2_to_i32(x: i32, y: i32) -> i32 {

dcv-color-primitives 0.5.1/src/convert_image/x86.rs

715	// Checked: we want to reinterpret the bits
716	#[allow(clippy::cast_possible_wrap)]
717	{
757	// Checked: we want to reinterpret the bits
758	#[allow(clippy::cast_possible_wrap)]
759	storeu(
819	clippy::cast_sign_loss,
820	clippy::cast_possible_wrap
821	)]
909	clippy::cast_sign_loss,
910	clippy::cast_possible_wrap
911	)]

dist_tx 0.3.0/src/xa_transaction_id.rs

91	/// No errors should be possible. The message would panic if allocation fails.
92	#[allow(clippy::cast_possible_wrap)]
93	#[allow(clippy::cast_possible_truncation)]

dnd_dice_roller 0.5.1/src/dice.rs

120	/// ```
121	#[allow(clippy::cast_possible_wrap)]
122	pub fn roll_dice_from_rng<R: Rng + Sized>(&self, mut rng: R) -> RollResult {

dnd_dice_roller 0.5.1/src/dice_set.rs

50	/// ```
51	#[allow(clippy::cast_possible_wrap)]
52	pub fn roll_dice_set_from_rng<R: Rng + Sized>(&self, mut rng: R) -> DiceSetResults {

dungen_minion 0.3.2/src/reciprocate_portals_generator.rs

121	// Wrap-around is only possible with implausibly large maps.
122	#[allow(clippy::cast_possible_wrap)]
123	CardinalDirection::North => {
126	// Wrap-around is only possible with implausibly large maps.
127	#[allow(clippy::cast_possible_wrap)]
128	CardinalDirection::East => (
132	// Wrap-around is only possible with implausibly large maps.
133	#[allow(clippy::cast_possible_wrap)]
134	CardinalDirection::South => (
138	// Wrap-around is only possible with implausibly large maps.
139	#[allow(clippy::cast_possible_wrap)]
140	CardinalDirection::West => {

dungen_minion_geometry 0.3.2/src/area.rs

147	// Wrap-around is only possible with implausibly large maps.
148	#[allow(clippy::cast_possible_wrap)]
149	let output = self.position

dungen_minion_geometry 0.3.2/src/has_bottom.rs

28	// Wrap-around is only possible with implausibly large maps.
29	#[allow(clippy::cast_possible_wrap)]
30	let output = self.position().y() + (self.height() as Coord - 1).max(0);

dungen_minion_geometry 0.3.2/src/has_right.rs

28	// Wrap-around is only possible with implausibly large maps.
29	#[allow(clippy::cast_possible_wrap)]
30	let output = self.position().x() + (self.width() as Coord - 1).max(0);

dungen_minion_geometry 0.3.2/src/shape_iterator.rs

        // Only a problem on implausibly large maps.
        #[allow(clippy::cast_possible_wrap)]
        let mut local_pos = Position::new(self.local_pos_x as i32, self.local_pos_y as i32);
        #[allow(clippy::cast_possible_wrap)]
        while !self.target.intersects_local_position(local_pos) {

dungen_minion_rooms 0.3.2/src/sparse_map.rs

186	// Wrap-around is only possible with implausibly large maps.
187	#[allow(clippy::cast_possible_wrap)]
188	CardinalRotation::Right90 => Position::new(0, (self.area().width() as i32 - 1).max(0)),
189	// Wrap-around is only possible with implausibly large maps.
190	#[allow(clippy::cast_possible_wrap)]
191	CardinalRotation::Full180 => Position::new(
195	// Wrap-around is only possible with implausibly large maps.
196	#[allow(clippy::cast_possible_wrap)]
197	CardinalRotation::Left90 => Position::new((self.area().height() as i32 - 1).max(0), 0),

edn-rs 0.17.4/src/edn/mod.rs

396	Edn::Int(i) => Some(*i as isize),
397	#[allow(clippy::cast_possible_wrap)]
398	Edn::UInt(u) if isize::try_from(u).is_ok() => Some(u as isize),

elem 0.1.3/src/main.rs

49	winuser::GWL_STYLE,
50	#[allow(clippy::cast_possible_wrap)]
51	{

embedded-msgpack 0.3.1/src/decode/mod.rs

261	}
262	#[allow(clippy::cast_possible_wrap)]
263	Marker::I8 => {

embedded-msgpack 0.3.1/src/ext/timestamp.rs

99	}
100	#[allow(clippy::cast_possible_wrap)]
101	8 => {

embedded-msgpack 0.3.1/src/marker.rs

49	/// Construct a msgpack marker from a single byte.
50	#[allow(clippy::cast_possible_wrap)]
51	pub const fn from_u8(n: u8) -> Marker {

eosio 0.3.1/src/varint/signed.rs

73	#[inline]
74	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
75	fn read(bytes: &[u8], pos: &mut usize) -> Result<Self, ReadError> {

eosio_cdt 0.3.1/src/time.rs

6	#[inline]
7	#[allow(clippy::cast_possible_wrap)]
8	pub fn current_time_point() -> TimePoint {
29	#[inline]
30	#[allow(clippy::cast_possible_wrap)]
31	pub fn publication() -> TimePoint {

esbat 0.1.0/src/calendar.rs

36	#[allow(clippy::cast_possible_wrap)]
37	pub(crate) fn fixed_from_gregorian(year: i32, month: u32, day: u32) -> i32 {

eva-common 0.1.185/src/cache.rs

37	impl TtlCache {
38	#[allow(clippy::cast_possible_wrap)]
39	pub async fn create(
89	}
90	#[allow(clippy::cast_possible_wrap)]
91	pub async fn set<V: Serialize>(&self, key: &str, value: &V) -> EResult<()> {

eva-ics 3.99.0/src/logs.rs

533	#[allow(clippy::cast_possible_wrap)]
534	#[allow(clippy::implicit_hasher)]

fiona 0.1.0/src/probe.rs

56	#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
57	pub fn print_supported() {

firestore-serde-timestamp 0.1.2/src/lib.rs

13	{
14	#[allow(clippy::cast_possible_wrap)]
15	let c = Timestamp {

flexi_syslog 0.5.1/src/log_writer.rs

276	#[allow(clippy::cast_possible_wrap)]
277	fn is_char_boundary(b: u8) -> bool {

fontfor 0.3.1/src/ft/font_face.rs

90	let ret = unsafe {
91	#[allow(clippy::cast_possible_wrap)] // flag enum value is small enough
92	ft::FT_Load_Char(self.face, c, flag as ft::FT_Int)

formula 0.1.0/src/parsers/date_and_time.rs

257	.map_err(\|_\| Error::Parser(rule_name.to_owned()))?;
258	#[allow(clippy::cast_possible_wrap)]
259	Ok(NaiveDate::from_ymd(mdy[2] as i32, mdy[0], mdy[1]))
282	let year = date.year() + (months / 12);
283	#[allow(clippy::cast_possible_wrap)]
284	let month = (date.month() as i32 + (months % 12)) as u32;

fudd 0.1.4/src/analysis/count.rs

29	#[allow(clippy::cast_possible_wrap)]
30	pub fn minus(&self, number: usize) -> usize {

genesys-dice-roller 0.2.3/src/dice.rs

77	/// ```
78	#[allow(clippy::cast_possible_wrap)]
79	pub fn roll_dice_from_rng<R: Rng + Sized>(&self, mut rng: R) -> RollResult {

genesys-dice-roller 0.2.3/src/dice_set.rs

50	/// ```
51	#[allow(clippy::cast_possible_wrap)]
52	pub fn roll_dice_set_from_rng<R: Rng + Sized>(&self, mut rng: R) -> DiceSetResults {

girt-core 2.2.1/src/modules/window_size_error/mod.rs

110	)]
111	#[allow(clippy::cast_possible_wrap)]
112	fn build_view_data(#[case] width: usize, #[case] height: usize, #[case] expected: &str) {

grass_compiler 0.12.2/src/selector/extend/functions.rs

270	/// it should return the element to include in the return value.
271	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
272	fn longest_common_subsequence<T: PartialEq + Clone>(

gunzip-split 0.1.1/src/sendfile.rs

43	fn sendfile_native(file: &mut File, offset: u64, length: usize, output: &mut File) -> Result<u64> {
44	#[allow(clippy::cast_possible_wrap)]
45	let mut offset: off64_t = offset as off64_t;

gurgle 0.5.0/src/roll.rs

119	match self {
120	#[allow(clippy::cast_possible_wrap)] // because out number can't be so big
121	Self::Dice(dice) => dice.value() as i64,

hashbrown 0.13.2/src/raw/sse2.rs

77	#[allow(
78	clippy::cast_possible_wrap, // byte: u8 as i8
79	// byte: i32 as u16
134	#[allow(
135	clippy::cast_possible_wrap, // byte: 0x80_u8 as i8
136	)]

hashbrown_tstd 0.7.1/src/raw/sse2.rs

74	#[allow(
75	clippy::cast_possible_wrap, // byte: u8 as i8
76	// byte: i32 as u16
131	#[allow(
132	clippy::cast_possible_wrap, // byte: 0x80_u8 as i8
133	)]

hdbconnect 0.24.0/src/protocol/part.rs

170	#[allow(clippy::cast_possible_truncation)]
171	#[allow(clippy::cast_possible_wrap)]
172	pub fn emit(

hdbconnect 0.24.0/src/protocol/parts/authfields.rs

32	#[allow(clippy::cast_possible_truncation)]
33	#[allow(clippy::cast_possible_wrap)]
34	w.write_i16::<LittleEndian>(self.0.len() as i16)?;

hdbconnect 0.24.0/src/protocol/parts/hdb_value.rs

606	#[allow(clippy::cast_possible_truncation)]
607	#[allow(clippy::cast_possible_wrap)]
608	fn emit_length_and_bytes(v: &[u8], w: &mut dyn std::io::Write) -> std::io::Result<()> {

hdbconnect 0.24.0/src/protocol/parts/option_value.rs

125	#[allow(clippy::cast_possible_truncation)]
126	#[allow(clippy::cast_possible_wrap)]
127	fn emit_length_and_bytes(v: &[u8], w: &mut dyn std::io::Write) -> std::io::Result<()> {

hdbconnect 0.24.0/src/protocol/parts/xat_options.rs

18	pub(crate) fn set_flags(&mut self, flag: Flags) {
19	#[allow(clippy::cast_possible_wrap)]
20	self.insert(XatOptionId::Flags, OptionValue::INT(flag.bits() as i32));

hdbconnect 0.24.0/src/protocol/request.rs

48	#[allow(clippy::cast_possible_truncation)]
49	#[allow(clippy::cast_possible_wrap)]
50	pub fn emit(

hedera 0.9.0/src/query/payment_transaction.rs

88	impl ToTransactionDataProtobuf for PaymentTransactionData {
89	#[allow(clippy::cast_possible_wrap)]
90	fn to_transaction_data_protobuf(

hexx 0.1.1/src/hex.rs

338	#[allow(clippy::cast_possible_wrap)]
339	/// Retrieves all [`Hex`] around `self` in a given `range`
354	#[must_use]
355	#[allow(clippy::cast_possible_wrap)]
356	/// Retrieves one [`Hex`] ring around `self` in a given `range`.
387	#[must_use]
388	#[allow(clippy::cast_possible_wrap)]
389	/// Retrieves one [`Hex`] ring around `self` in a given `range`.
483	#[must_use]
484	#[allow(clippy::cast_possible_wrap)]
485	pub const fn wraparound_mirrors(radius: u32) -> [Self; 6] {

hexx 0.1.1/src/lib.rs

83	/// To offset the map, apply the offset to each `Item` of the returned iterator
84	#[allow(clippy::cast_possible_wrap)]
85	pub fn triangle(size: u32) -> impl Iterator<Item = Hex> {

holodex 0.3.1/src/client.rs

720	#[cfg(feature = "streams")]
721	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
722	fn stream_endpoint<'a>(

holodex 0.3.1/src/model/id.rs

423	#[cfg(feature = "streams")]
424	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
425	fn stream_channel_video_type(

horde 0.1.1/src/raw/sse2.rs

81	#[allow(
82	clippy::cast_possible_wrap, // byte: u8 as i8
83	// byte: i32 as u16

html5gum 0.5.2/src/reader.rs

393

        needle_arr[..needle.len()].copy_from_slice(needle);

394

        #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]

395

        jetscii::Bytes::new(needle_arr, needle.len() as i32, |b| needle.contains(&b)).find(haystack)

in-place-string-map 0.1.0/src/lib.rs

119	// we intentionally wrap here
120	#[allow(clippy::cast_possible_wrap)]
121	const fn is_char_start(byte: u8) -> bool {

jiao-web 0.2.1/src/paint_device.rs

    pub fn size(&self) -> Size {
        #[allow(clippy::cast_possible_wrap)]
        let width = self.canvas.width() as i32;
        #[allow(clippy::cast_possible_wrap)]
        let height = self.canvas.height() as i32;

kludgine 0.4.0/src/tilemap/mod.rs

218	impl TileProvider for PersistentTileProvider {
219	#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
220	fn tile(&mut self, location: Point<i32>) -> Option<Tile<'_>> {

kludgine-core 0.4.0/src/sprite.rs

364	#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
365	fn next_frame(&mut self) -> crate::Result<usize> {

lair 0.6.0/src/blas/dot.rs

36	/// `isize::MAX`, inclusive.
37	#[allow(clippy::cast_possible_wrap)]
38	unsafe fn inner<T>(n: usize, x: const T, inc_x: isize, y: const T, inc_y: isize) -> T

lair 0.6.0/src/blas/gerc.rs

3	#[allow(
4	clippy::cast_possible_wrap,
5	clippy::similar_names,

lair 0.6.0/src/blas/iamax.rs

4	#[allow(clippy::cast_possible_wrap)]
5	pub(crate) unsafe fn iamax<A>(n: usize, x: *const A, incx: isize) -> (usize, A::Real)

lair 0.6.0/src/blas/trsm.rs

4	#[allow(clippy::cast_possible_wrap)]
5	pub unsafe fn trsm<A>(a: *const A, row_stride: isize, col_stride: isize, mut b: ArrayViewMut2<A>)

lair 0.6.0/src/lapack/getrf.rs

41	/// * `pivots.len()` must be greater than or equal to the smaller dimension of `a`.
42	#[allow(clippy::cast_possible_wrap)] // The number of elements in the matrix does not exceed `isize::MAX`.
43	unsafe fn getrf_row_major<A: Scalar>(
122	/// * Every element of `pivots` must be a valid row index for `a`.
123	#[allow(clippy::cast_possible_wrap)] // The number of elements in the matrix does not exceed `isize::MAX`.
124	#[allow(clippy::too_many_lines)]
212	#[allow(clippy::cast_possible_wrap)]
213	unsafe fn recursive_inner<A>(mut a: ArrayViewMut2<A>, pivots: &mut [usize]) -> Result<(), Singular>

lair 0.6.0/src/lapack/laswp.rs

3	#[allow(clippy::cast_possible_wrap)]
4	pub unsafe fn laswp<T>(

libafl 0.9.0/src/bolts/core_affinity.rs

396	#[allow(clippy::cast_ptr_alignment)]
397	#[allow(clippy::cast_possible_wrap)]
398	pub fn get_num_logical_cpus_ex_windows() -> Option<usize> {

libafl 0.9.0/src/executors/forkserver.rs

const FORKSRV_FD: i32 = 198;
#[allow(clippy::cast_possible_wrap)]
const FS_OPT_ENABLED: i32 = 0x80000001_u32 as i32;
#[allow(clippy::cast_possible_wrap)]
const FS_OPT_MAPSIZE: i32 = 0x40000000_u32 as i32;
#[allow(clippy::cast_possible_wrap)]
const FS_OPT_SHDMEM_FUZZ: i32 = 0x01000000_u32 as i32;
#[allow(clippy::cast_possible_wrap)]
const FS_OPT_AUTODICT: i32 = 0x10000000_u32 as i32;
    #[allow(trivial_numeric_casts, clippy::cast_possible_wrap)]
    fn setlimit(&mut self, memlimit: u64) -> &mut Self {

libafl 0.9.0/src/schedulers/accounting.rs

184	#[allow(clippy::unused_self)]
185	#[allow(clippy::cast_possible_wrap)]
186	pub fn update_accounting_score(

libafl 0.9.0/src/schedulers/minimizer.rs

192	#[allow(clippy::unused_self)]
193	#[allow(clippy::cast_possible_wrap)]
194	pub fn update_score(&self, state: &mut CS::State, idx: CorpusId) -> Result<(), Error> {

libafl 0.9.0/src/stages/mutational.rs

106	/// Runs this (mutational) stage for the given testcase
107	#[allow(clippy::cast_possible_wrap)] // more than i32 stages on 32 bit system - highly unlikely...
108	fn perform_mutational(

libafl 0.9.0/src/stages/power.rs

74	#[allow(clippy::cast_possible_wrap)]
75	fn perform_mutational(

libafl_frida 0.9.0/src/asan/asan_rt.rs

1141	#[allow(clippy::cast_possible_wrap)]
1142	let mut fault_address =
1884	#[allow(clippy::similar_names)]
1885	#[allow(clippy::cast_possible_wrap)]
1886	#[allow(clippy::too_many_lines)]
1973	#[allow(clippy::similar_names)] // We allow things like dword and qword
1974	#[allow(clippy::cast_possible_wrap)]
1975	#[allow(clippy::too_many_lines)]
2495	);
2496	#[allow(clippy::cast_possible_wrap)]
2497	let redzone_size = frida_gum_sys::GUM_RED_ZONE_SIZE as i32;

libafl_frida 0.9.0/src/cmplog_rt.rs

51	#[cfg(all(feature = "cmplog", target_arch = "aarch64"))]
52	#[allow(clippy::cast_possible_wrap)]
53	fn gum_red_zone_size_i32() -> i32 {

libafl_qemu 0.9.0/src/emu.rs

695	envp.push(null());
696	#[allow(clippy::cast_possible_wrap)]
697	let argc = argv.len() as i32;
732	#[must_use]
733	#[allow(clippy::cast_possible_wrap)]
734	#[allow(clippy::cast_sign_loss)]
749	#[must_use]
750	#[allow(clippy::cast_possible_wrap)]
751	pub fn cpu_from_index(&self, index: usize) -> CPU {

libafl_targets 0.9.0/src/libfuzzer.rs

24	assert!(argv.len() < i32::MAX as usize);
25	#[allow(clippy::cast_possible_wrap)]
26	let argc = argv.len() as i32;

libpd-rs 0.1.9/src/send.rs

362	#[allow(clippy::cast_possible_wrap)]
363	#[allow(clippy::cast_possible_truncation)]
413	#[allow(clippy::cast_possible_wrap)]
414	#[allow(clippy::cast_possible_truncation)]

mangadex-home 0.5.3/src/cache/disk.rs

262	// This is intentional.
263	#[allow(clippy::cast_possible_wrap)]
264	let casted_size = size as i64;

mimir 0.3.5/src/context/params.rs

312	/// triggers, for example. The default value is NULL.
313	#[cfg_attr(feature = "cargo-clippy", allow(cast_possible_wrap))]
314	pub fn get_app_context(&self) -> Result<Vec<AppContext>> {

modbot 0.5.3/src/commands/mods.rs

405	}
406	#[allow(clippy::cast_possible_wrap)]
407	fn dates(m: &Mod) -> EmbedField {

modio-logger 0.5.2/src/logger.rs

133	// if time wraps we have another problem.
134	#[allow(clippy::cast_possible_wrap)]
135	let db_when = when as i64;
155	// if time wraps we have another problem.
156	#[allow(clippy::cast_possible_wrap)]
157	let db_when = when as i64;
204	// if it wraps, that is fine.
205	#[allow(clippy::cast_possible_wrap)]
206	let t_id = t_id as i64;
218	// if it wraps, that is fine.
219	#[allow(clippy::cast_possible_wrap)]
220	let t_id = t_id as i64;

modio-logger-db 0.5.2/src/buffer.rs

100	// If time wraps we have a bigger problem...
101	#[allow(clippy::cast_possible_wrap)]
102	Ok(n) => n.as_secs() as i64,

modio-logger-db 0.5.2/src/datastore.rs

426	// if it wraps its ok, then time is far ahead
427	#[allow(clippy::cast_possible_wrap)]
428	let new_when = when as i64;

modio-logger-db 0.5.2/src/types.rs

22	// Legacy type was u64, but we want i64 in the database due to SQLite.
23	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
24	Self {
33	// Legacy type for timestamp was u64, but we want i64 in the database due to SQLite.
34	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
35	Self {
77	// interface.
78	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
79	Self {

moneta 0.3.2/src/lib.rs

448	#[inline]
449	#[allow(clippy::cast_possible_wrap)]
450	fn new(amount: AmountT, unit: Self::UnitType) -> Self {
725	#[test]
726	#[allow(clippy::cast_possible_wrap)]
727	fn test_money_exceed_minor_unit() {

nc 0.8.13/src/platform/freebsd-types/sys/resource.rs

114	#[allow(clippy::cast_possible_wrap)]
115	pub const RLIM_INFINITY: rlim_t = ((1_u64 << 63) - 1) as rlim_t;

nebari 0.5.4/src/transaction/log.rs

350	// load the transaction at this location
351	#[allow(clippy::cast_possible_wrap)]
352	let scan_forward = guessed_location >= upper_location;

necessist-core 0.1.0-beta.6/src/offset_based_rewriter/impls.rs

63	#[allow(clippy::cast_possible_wrap)]
64	#[allow(clippy::expect_used)]

neodyn_xc 0.4.0/src/de/binary.rs

40	/// Sign extend the payload from something less than 8 bits to a full byte.
41	#[allow(clippy::cast_possible_wrap)]
42	const fn decode_small_int(b: u8) -> i8 {
133	/// Helper for `read_value_header()`.
134	#[allow(clippy::cast_possible_wrap, clippy::map_err_ignore)]
135	fn read_big_value_header(tag: u8, buf: &[u8]) -> Result<ValueHeader, Error> {

netcdf 0.7.0/src/variable.rs

874	}
875	#[allow(clippy::cast_possible_wrap)]
876	for (((d, &start), &count), &stride) in self
1101	}
1102	#[allow(clippy::cast_possible_wrap)]
1103	let end = start as isize + (count as isize - 1) * stride;

netcorehost 0.13.1/src/error/hosting_result.rs

17	/// Creates a new [`HostingResult`] from the raw status code.
18	#[allow(clippy::cast_possible_wrap)]
19	pub fn from_status_code(code: u32) -> Self {
100	impl From<HostingResult> for i32 {
101	#[allow(clippy::cast_possible_wrap)]
102	fn from(code: HostingResult) -> Self {

nokhwa 0.10.3/src/backends/capture/opencv_backend.rs

100	/// If the API u32 -> i32 fails this will error
101	#[allow(clippy::cast_possible_wrap)]
102	pub fn new(index: &CameraIndex, cam_fmt: RequestedFormat) -> Result<Self, NokhwaError> {
482	#[allow(clippy::cast_possible_wrap)]
483	fn open_stream(&mut self) -> Result<(), NokhwaError> {

nokhwa-bindings-linux 0.1.0/src/lib.rs

605	#[allow(clippy::cast_possible_wrap)]
606	fn camera_controls(&self) -> Result<Vec<CameraControl>, NokhwaError> {

nokhwa-core 0.1.0/src/buffer.rs

115	#[cfg_attr(feature = "docs-features", doc(cfg(feature = "opencv-mat")))]
116	#[allow(clippy::cast_possible_wrap)]
117	pub fn decode_opencv_mat<F: FormatDecoder>(

nokhwa-core 0.1.0/src/types.rs

153	}
154	#[allow(clippy::cast_possible_wrap)]
155	RequestedFormatType::Closest(c) => {

nonogrid 0.7.3/src/solver/line.rs

104	#[allow(clippy::cast_possible_wrap)]
105	#[allow(clippy::cast_sign_loss)]

nss-gk-api 0.2.1/src/ssl.rs

58	// Cast is safe here because SSLOptions are within the i32 range
59	#[allow(clippy::cast_possible_wrap)]
60	pub(crate) fn as_int(self) -> PRInt32 {

oic 0.1.0/src/context/params.rs

286	pub fn get_app_context(&self) -> Vec<AppContext> {
287	#[cfg_attr(feature = "cargo-clippy", allow(cast_possible_wrap))]
288	let len = self.conn.num_app_context as isize;

openair 0.2.0/src/lib.rs

239	#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)] // Impossible, since the RegEx limits length
240	fn parse_component(val: &str) -> Result<f64, ()> {

pam-client 0.5.0/src/context.rs

366	#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
367	let xauthdata = XAuthData {

pam-client 0.5.0/src/ffi.rs

78	#[cfg(not(target_os = "solaris"))]
79	#[allow(clippy::cast_possible_wrap)]
80	const fn max_msg_num() -> isize {
85	#[cfg(target_os = "solaris")]
86	#[allow(clippy::cast_possible_wrap)]
87	const fn max_msg_num() -> isize {

pathfinding 4.2.1/src/utils.rs

43	#[must_use]
44	#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
45	pub fn move_in_direction(

pdbtbx 0.10.1/src/read/mmcif/lexer.rs

275	}
276	#[allow(clippy::cast_possible_wrap)]
277	if exp_minus {

pdbtbx 0.10.1/src/read/mmcif/parser.rs

396	parse_column!(get_text, ATOM_COMP_ID).expect("Residue name should be provided");
397	#[allow(clippy::cast_possible_wrap)]
398	let residue_number = parse_column!(get_isize, ATOM_AUTH_SEQ_ID).unwrap_or_else(\|\| {

pdbtbx 0.10.1/src/read/pdb/validate.rs

8	clippy::comparison_chain,
9	clippy::cast_possible_wrap,
10	clippy::cast_sign_loss

portable-atomic-util 0.1.0/src/arc.rs

797	clippy::transmutes_expressible_as_ptr_casts,
798	clippy::cast_possible_wrap
799	)]

pot 1.0.2/src/format.rs

508	// clippy::checked_conversions: try_from isn't const, and it would demote this from a const fn.
509	#[allow(clippy::cast_possible_wrap)]
510	#[allow(clippy::checked_conversions)]
541	/// Returns the contained value as an i16, or an error if the value is unable to fit.
542	#[allow(clippy::cast_possible_wrap)]
543	#[allow(clippy::checked_conversions)]
594	/// Returns the contained value as an i32, or an error if the value is unable to fit.
595	#[allow(clippy::cast_possible_wrap)]
596	#[allow(clippy::checked_conversions)]
653	/// Returns the contained value as an i64, or an error if the value is unable to fit.
654	#[allow(clippy::cast_possible_wrap)]
655	#[allow(clippy::checked_conversions)]
676	/// Returns the contained value as an i64, or an error if the value is unable to fit.
677	#[allow(clippy::cast_possible_wrap)]
678	pub const fn as_i128(&self) -> Result<i128, Error> {

process-memory 0.5.0/src/data_member.rs

111	let test = 4_i32;
112	#[allow(clippy::cast_possible_wrap)]
113	let handle = (std::process::id() as crate::Pid)
128	let test = 3_i64;
129	#[allow(clippy::cast_possible_wrap)]
130	let handle = (std::process::id() as crate::Pid)
145	let test = 0_usize;
146	#[allow(clippy::cast_possible_wrap)]
147	let handle = (std::process::id() as crate::Pid)

process-memory 0.5.0/src/linux.rs

28	fn try_into_process_handle(&self) -> std::io::Result<ProcessHandle> {
29	#[allow(clippy::cast_possible_wrap)]
30	Ok((self.id() as Pid, Architecture::from_native()))

process-memory 0.5.0/src/macos.rs

52	fn try_into_process_handle(&self) -> std::io::Result<ProcessHandle> {
53	#[allow(clippy::cast_possible_wrap)]
54	Pid::try_into_process_handle(&(self.id() as _))

pwner 0.1.8/src/process.rs

537	// Allowed because we are already assuming *nix
538	#[allow(clippy::cast_possible_wrap)]
539	#[cfg(unix)]

pwner 0.1.8/src/tokio.rs

692	// Allowed because we are already assuming *nix
693	#[allow(clippy::cast_possible_wrap)]
694	#[cfg(unix)]

py-marshal 0.3.3/src/lib.rs

483	fn r_pylong(p: &mut RFile<impl Read>) -> Result<BigInt> {
484	#[allow(clippy::cast_possible_wrap)]
485	let n = r_long(p)? as i32;
575	};
576	#[allow(clippy::cast_possible_wrap)]
577	let retval = match type_ {

py27-marshal 0.3.4/src/read.rs

100	fn r_pylong(p: &mut RFile<impl Read>) -> ParseResult<BigInt> {
101	#[allow(clippy::cast_possible_wrap)]
102	let n = r_long(p)? as i32;
195	};
196	#[allow(clippy::cast_possible_wrap)]
197	let retval = match type_ {

qcs 0.10.0-rc.1/src/qpu/runner.rs

175	#[allow(clippy::cast_possible_wrap)]
176	impl TryFrom<Buffer> for Register {

quirs 0.1.1/src/info.rs

21	/// Returns the version number of the code, in the range `1...40`.
22	#[cfg_attr(feature = "cargo-clippy", allow(cast_possible_truncation, cast_possible_wrap))]
23	pub fn version(&self) -> u8 {
27	/// Returns the mask ID of the code, in the range `0...7`.
28	#[cfg_attr(feature = "cargo-clippy", allow(cast_possible_truncation, cast_possible_wrap))]
29	pub fn mask_id(&self) -> u8 {
33	/// Returns the ECI assignment number, in the range `0...30`.
34	#[cfg_attr(feature = "cargo-clippy", allow(cast_possible_truncation, cast_possible_wrap))]
35	pub fn eci(&self) -> u8 {

quirs 0.1.1/src/util.rs

8	/// Attempts to convert a `usize` to an `int` without overflow.
9	#[cfg_attr(feature = "cargo-clippy", allow(if_same_then_else, cast_possible_truncation, cast_possible_wrap))]
10	pub fn usize_to_int(n: usize) -> Result<c_int> {
20	/// Attempts to convert an `int` to a `usize` without under- or overflow.
21	#[cfg_attr(feature = "cargo-clippy", allow(if_same_then_else, cast_possible_truncation, cast_possible_wrap))]
22	pub fn int_to_usize(n: c_int) -> Result<usize> {

ranged_type 0.1.0/src/arith_helpers.rs

47	pub const fn wrapping_offset_to_value(offset: u32, base: i32) -> i32 {
48	#[allow(clippy::cast_possible_wrap)]
49	match offset <= (i32::max_value() as u32) {

ranged_type 0.1.0/src/ranged_i32/overflowing/overflowing_sub.rs

12	#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
13	match overflow {

redb 0.12.1/src/tree_store/page_store/xxh3.rs

300	#[allow(clippy::cast_possible_wrap)]
301	let xxh_i64 = 0u64.wrapping_sub(seed) as i64;
302	#[allow(clippy::cast_possible_wrap)]
303	let seed = seed as i64;

relearn 0.3.1/src/torch/packed.rs

311	#[allow(clippy::cast_possible_wrap)]
312	fn inplace_discounted_cumsum_from_end<I, T>(

rexsgdata 0.12.0/src/sglist.rs

45	/// Iterates over `&iovec` stored in this `SgList`
46	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
47	pub unsafe fn iter(&self) -> impl Iterator<Item = &iovec> {
51	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
52	pub unsafe fn into_iter(self) -> impl Iterator<Item = iovec> {

rhymuproc 1.1.2/src/macos.rs

349	#[allow(clippy::cast_possible_truncation)]
350	#[allow(clippy::cast_possible_wrap)]
351	proc_listallpids(
379	#[allow(clippy::cast_possible_truncation)]
380	#[allow(clippy::cast_possible_wrap)]
381	proc_pidfdinfo(

rhymuproc 1.1.2/src/unix.rs

101	#[allow(clippy::cast_possible_truncation)]
102	#[allow(clippy::cast_possible_wrap)]
103	unsafe {

ril 0.9.0/src/draw.rs

219	#[allow(clippy::cast_precision_loss, clippy::cast_possible_wrap)]
220	impl<F: IntoFill> Line<F> {
562	#[allow(clippy::cast_precision_loss, clippy::cast_possible_wrap)]
563	impl<F: IntoFill> Polygon<F> {
1168	// Used when there is no border
1169	#[allow(clippy::cast_possible_wrap)]
1170	fn rasterize_filled_circle(&self, image: &mut Image<F::Pixel>) {
1211	// Used when there is no border
1212	#[allow(clippy::cast_possible_wrap, clippy::cast_precision_loss)]
1213	fn rasterize_filled_ellipse(&self, image: &mut Image<F::Pixel>) {
1280	// Standard, slower brute force algorithm that iterates through all pixels
1281	#[allow(clippy::cast_possible_wrap)]
1282	fn render_circle(&self, image: &mut Image<F::Pixel>) {

ril 0.9.0/src/encodings/webp.rs

54	#[allow(clippy::cast_lossless, clippy::cast_possible_wrap)]
55	fn encode_image<P: Pixel>(&self, image: &Image<P>) -> crate::Result<libwebp::WebPData> {
133	#[allow(clippy::cast_lossless, clippy::cast_possible_wrap)]
134	impl Encoder for WebPEncoder {

rlimit 0.9.1/src/windows.rs

19	// It is safe even if the return value is wrong.
20	#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
21	unsafe {

rpds 0.12.0/src/vector/mod.rs

688	fn new(node: &Node<T, P>, backwards: bool) -> IterStackElement<'_, T, P> {
689	#[allow(clippy::cast_possible_wrap)]
690	IterStackElement { node, index: if backwards { node.used() as isize - 1 } else { 0 } }

rust-uci 0.1.5/src/lib.rs

67	#[allow(clippy::cast_possible_wrap)]
68	const UCI_OK: i32 = libuci_sys::UCI_OK as i32;

rustfmt_if_chain 0.1.4/src/offset_based_rewriter/impls.rs

58	#[allow(clippy::cast_possible_wrap)]
59	fn rewrite(&mut self, start: usize, end: usize, replacement: &str) {

simd-json 0.7.0/src/avx2/deser.rs

26	clippy::cast_ptr_alignment,
27	clippy::cast_possible_wrap,
28	clippy::if_not_else,

simd-json 0.7.0/src/avx2/stage1.rs

74	#[cfg_attr(not(feature = "no-inline"), inline(always))]
75	#[allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
76	fn cmp_mask_against_input(&self, m: u8) -> u64 {
177	#[allow(
178	clippy::cast_possible_wrap,
179	clippy::cast_ptr_alignment,

simd-json 0.7.0/src/neon/stage1.rs

185	#[allow(
186	clippy::cast_possible_wrap,
187	clippy::cast_ptr_alignment,

simd-json 0.7.0/src/numberparse/approx.rs

76	clippy::cast_sign_loss,
77	clippy::cast_possible_wrap,
78	clippy::cast_precision_loss,
224	#[inline(never)]
225	#[allow(clippy::cast_possible_wrap)]
226	fn parse_large_integer(idx: usize, buf: &[u8], negative: bool) -> Result<StaticNode> {
285	#[inline(never)]
286	#[allow(clippy::cast_possible_wrap)]
287	fn parse_large_integer(idx: usize, buf: &[u8], negative: bool) -> Result<StaticNode> {
358	clippy::cast_precision_loss,
359	clippy::cast_possible_wrap,
360	clippy::too_many_lines

simd-json 0.7.0/src/numberparse/correct.rs

36	unused_unsafe,
37	clippy::cast_possible_wrap,
38	clippy::cast_possible_truncation,
177	#[cold]
178	#[allow(clippy::cast_possible_wrap)]
179	fn parse_large_integer(start_idx: usize, buf: &[u8], negative: bool) -> Result<StaticNode> {

simdutf8 0.1.4/src/implementation/aarch64/neon.rs

16	#[allow(clippy::too_many_arguments)]
17	#[allow(clippy::cast_possible_wrap)]
18	unsafe fn from_32_cut_off_leading(
59	#[allow(clippy::too_many_arguments)]
60	#[allow(clippy::cast_possible_wrap)]
61	unsafe fn repeat_16(
133	#[inline]
134	#[allow(clippy::cast_possible_wrap)]
135	unsafe fn splat(val: u8) -> Self {
139	#[inline]
140	#[allow(clippy::cast_possible_wrap)]
141	unsafe fn splat0() -> Self {

simdutf8 0.1.4/src/implementation/wasm32/simd128.rs

19	#[allow(clippy::too_many_arguments)]
20	#[allow(clippy::cast_possible_wrap)]
21	#[allow(clippy::cast_ptr_alignment)]
63	#[allow(clippy::too_many_arguments)]
64	#[allow(clippy::cast_possible_wrap)]
65	#[allow(clippy::cast_ptr_alignment)]
126	#[inline]
127	#[allow(clippy::cast_possible_wrap)]
128	unsafe fn splat(val: u8) -> Self {
132	#[inline]
133	#[allow(clippy::cast_possible_wrap)]
134	unsafe fn splat0() -> Self {

simdutf8 0.1.4/src/implementation/x86/avx2.rs

62	) -> Self {
63	#[allow(clippy::cast_possible_wrap)]
64	Self::from(_mm256_setr_epi8(
91	) -> Self {
92	#[allow(clippy::cast_possible_wrap)]
93	Self::from_32_cut_off_leading(

stellar-xdr 0.0.12/src/next/scval_conversions.rs

287	#[inline(always)]
288	#[allow(clippy::inline_always, clippy::cast_possible_wrap)]
289	pub fn i128_from_u128(u: u128) -> i128 {

stork-lib 1.6.0/src/index_v3/search/entry_and_intermediate_excerpts.rs

23	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
24	impl From<EntryAndIntermediateExcerpts> for Result {

swarm-bot 0.3.4/src/storage/blocks.rs

1	#![allow(clippy::cast_sign_loss, unused, clippy::cast_possible_wrap)]
50	#[allow(clippy::cast_possible_wrap)]
51	BlockLocation::new(i32::from(x) + start_x, y as i16, i32::from(z) + start_z)

tagged-rendezvous 0.1.1/src/lib.rs

1400	/// [Github issue]: https://github.com/rust-lang/rust/issues/72599
1401	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
1402	fn f64_total_ordering(left: f64, right: f64) -> Ordering {

tensorgraph-math 0.1.11/src/tensor/matrix.rs

189	#[allow(
190	clippy::cast_possible_wrap,
191	clippy::cast_possible_truncation,
300	#[allow(
301	clippy::cast_possible_wrap,
302	clippy::cast_possible_truncation,
351	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
352	fn lead(s: [usize; 2]) -> (MatrixOp, i32) {

tensorgraph-math 0.1.11/src/tensor/vector.rs

44	/// If the vectors do not have the same length
45	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
46	pub fn dot_using<C: BLASContext<Device = S::Device>>(
91	#[allow(
92	clippy::cast_possible_wrap,
93	clippy::cast_possible_truncation,
147	/// Vector scaling, using the specified [`BLASContext`]
148	#[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
149	pub fn scale_using<C: BLASContext<Device = S::Device>>(&mut self, alpha: S::T, ctx: C)
162	#[allow(
163	clippy::cast_possible_wrap,
164	clippy::cast_possible_truncation,

terminal-emulator 0.1.0/src/grid/storage.rs

265	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
266	pub fn rotate(&mut self, count: isize) {

termusic 0.7.8/src/discord.rs

18	impl Default for Rpc {
19	#[allow(clippy::cast_possible_wrap)]
20	fn default() -> Self {
129	#[allow(clippy::cast_possible_wrap)]
130	pub fn resume(&mut self, time_pos: i64) {

termusic 0.7.8/src/player/gstreamer_backend.rs

195	#[allow(clippy::cast_precision_loss)]
196	#[allow(clippy::cast_possible_wrap)]
197	fn get_progress(&self) -> Result<()> {
313	#[allow(clippy::cast_sign_loss)]
314	#[allow(clippy::cast_possible_wrap)]
315	fn seek(&mut self, secs: i64) -> Result<()> {
336	#[allow(clippy::cast_sign_loss)]
337	#[allow(clippy::cast_possible_wrap)]
338	fn seek_to(&mut self, last_pos: Duration) {

termusic 0.7.8/src/player/mpv_backend/mod.rs

278	#[allow(clippy::cast_possible_wrap)]
279	fn seek_to(&mut self, last_pos: Duration) {

termusic 0.7.8/src/player/rusty_backend/conversions/sample.rs

85	#[allow(
86	clippy::cast_possible_wrap,
87	clippy::cast_sign_loss,
116	#[allow(
117	clippy::cast_possible_wrap,
118	clippy::cast_possible_truncation,

termusic 0.7.8/src/player/rusty_backend/mod.rs

9	clippy::cast_lossless,
10	clippy::cast_possible_wrap,
11	clippy::doc_markdown,
96	#[allow(
97	clippy::cast_possible_wrap,
98	clippy::cast_precision_loss,

test-fuzz-macro 3.0.5/src/lib.rs

360	.count();
361	#[allow(clippy::cast_possible_wrap)]
362	let n_missing_lifetime_args =

token_server 0.1.15/src/token_server/token_store.rs

122	// let's assume no wrap occurs, otherwise funny debug log
123	#[allow(clippy::cast_possible_wrap)]
124	DumpEntry::new(

tremor-script 0.13.0-rc.11/src/interpreter.rs

359	clippy::cast_sign_loss,
360	clippy::cast_possible_wrap
361	)]

tremor-script 0.13.0-rc.11/src/std_lib/math.rs

42	// ALLOW: Until we have u64 support in clippy
43	#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
44	pub fn load(registry: &mut Registry) {

tremor-script 0.13.0-rc.11/src/std_lib/range.rs

19	// ALLOW: Until we have u64 support in clippy
20	#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
21	pub fn load(registry: &mut Registry) {

tremor-value 0.13.0-rc.11/src/serde/value/se.rs

125	#[inline]
126	#[allow(clippy::cast_possible_wrap)]
127	fn serialize_u64(self, value: u64) -> Result<Value<'static>> {

tsukuyomi 0.5.3/src/fs.rs

275	#[allow(clippy::cast_possible_wrap)]
276	fn last_modified(&self) -> Result<String, time::ParseError> {

twilight-util 0.15.0-rc.1/src/snowflake.rs

59	/// ```
60	#[allow(clippy::cast_possible_wrap)]
61	fn timestamp(&self) -> i64 {

twilight-validate 0.15.0-rc.1/src/request.rs

586	/// # Errors
587	#[allow(clippy::cast_possible_wrap)] // casting of unix timestamp should never wrap
588	pub fn communication_disabled_until(timestamp: Timestamp) -> Result<(), ValidationError> {
1150	fn communication_disabled_until_max() {
1151	#[allow(clippy::cast_possible_wrap)]
1152	let now = SystemTime::now()

unix-print 0.1.0/src/lib.rs

80	/// Should be private but needs to be exposed for the macro to work
81	#[allow(clippy::cast_possible_wrap)]
82	#[must_use]

utcnow 0.2.2/src/impl_wasi.rs

10	#[allow(clippy::cast_possible_truncation)]
11	#[allow(clippy::cast_possible_wrap)]
12	pub(crate) fn utcnow() -> Result<UtcTime> {

utcnow 0.2.2/src/lib.rs

294	#[must_use]
295	#[allow(clippy::cast_possible_wrap)]
296	#[const_fn::const_fn("1.56")]

value-trait 0.5.1/src/generator.rs

257	#[inline(always)]
258	#[allow(clippy::cast_possible_wrap, clippy::cast_ptr_alignment)]
259	/// Writes a string with simd-acceleration
323	#[inline(always)]
324	#[allow(clippy::cast_possible_wrap, clippy::cast_ptr_alignment)]
325	/// Writes a string with simd-acceleration

value-trait 0.5.1/src/node/from.rs

89	#[must_use]
90	#[allow(clippy::cast_possible_wrap)]
91	fn from(i: u64) -> Self {

vaporetto 0.6.1/src/char_scorer/boundary_scorer.rs

91	#[allow(clippy::cast_possible_wrap)]
92	#[inline(always)]

vaporetto 0.6.1/src/char_scorer/boundary_tag_scorer.rs

128	#[allow(clippy::cast_possible_truncation)]
129	#[allow(clippy::cast_possible_wrap)]
130	#[inline(always)]

vaporetto 0.6.1/src/type_scorer/boundary_scorer.rs

62	#[allow(clippy::cast_possible_wrap)]
63	#[inline(always)]

vaporetto 0.6.1/src/type_scorer/boundary_tag_scorer.rs

102	#[allow(clippy::cast_possible_truncation)]
103	#[allow(clippy::cast_possible_wrap)]
104	#[inline(always)]

vason 0.0.3/src/canvas.rs

14	/// This function panics if the supplied width and height does not match the buffer size.
15	#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
16	#[must_use]

visual-odometry-rs 0.1.0/src/core/candidates/dso.rs

280	#[allow(clippy::cast_precision_loss)]
281	#[allow(clippy::cast_possible_wrap)]
282	#[allow(clippy::cast_sign_loss)]

w32-error 1.0.0/src/lib.rs

238	impl From<W32Error> for io::Error {
239	#[allow(clippy::cast_possible_wrap)]
240	fn from(other: W32Error) -> Self {

wasm-msgpack 0.3.2/src/decode/mod.rs

278	}
279	#[allow(clippy::cast_possible_wrap)]
280	Marker::I8 => {

wasm-msgpack 0.3.2/src/ext/timestamp.rs

139	}
140	#[allow(clippy::cast_possible_wrap)]
141	8 => {

wasm-msgpack 0.3.2/src/marker.rs

48	/// Construct a msgpack marker from a single byte.
49	#[allow(clippy::cast_possible_wrap)]
50	pub const fn from_u8(n: u8) -> Marker {

wealthy 0.2.0/src/filesize.rs

25	#[allow(clippy::cast_possible_truncation)]
26	#[allow(clippy::cast_possible_wrap)]
27	pub(crate) fn decimal(size: f32, precision: Option<usize>, separator: Option<&str>) -> String {
66	#[allow(clippy::cast_possible_truncation)]
67	#[allow(clippy::cast_possible_wrap)]
68	fn pick_unit_and_suffix(size: u32, suffixes: &[&str], base: u32) -> (u32, String) {

wealthy 0.2.0/src/ratio.rs

58	#[allow(clippy::cast_sign_loss)]
59	#[allow(clippy::cast_possible_wrap)]
60	fn ratio_resolve<E: HasEdge>(total: u32, edges: &[E]) -> Vec<u32> {

yata 0.6.1/src/indicators/woodies_cci.rs

152	#[allow(clippy::cast_possible_wrap)]
153	let s1 = (self.s1_count.abs() == self.cfg.s1_lag as isize) as i8 * s1_cross;

zkp-stark 0.2.1/src/algebraic_dag.rs

513	// Sizes are small enough
514	#[allow(clippy::cast_possible_wrap)]
515	let n = trace_table.num_rows() as isize;
517	// Sizes are small enough
518	#[allow(clippy::cast_possible_wrap)]
519	let trace_blowup = self.trace_blowup as isize;
520	// Sizes are small enough
521	#[allow(clippy::cast_possible_wrap)]
522	let row = (self.row + i) as isize;

zkp-stark 0.2.1/src/component/fold.rs

72	// Reductions should be small enough
73	#[allow(clippy::cast_possible_wrap)]
74	Trace(

zune-jpeg 0.2.0/src/color_convert/avx.rs

344	#[inline]
345	#[allow(clippy::cast_possible_wrap)]
346	#[target_feature(enable = "avx2")]

zune-jpeg 0.2.0/src/huffman.rs

68	clippy::cast_possible_truncation,
69	clippy::cast_possible_wrap,
70	clippy::cast_sign_loss,

aerospike 1.2.0/src/lib.rs

27	clippy::cast_possible_truncation,
28	clippy::cast_possible_wrap,
29	clippy::cast_sign_loss,

Aetherus 0.1.1/src/lib.rs

13	clippy::cast_possible_truncation,
14	clippy::cast_possible_wrap,
15	clippy::cast_precision_loss,

alpha-shell 0.3.0/src/main.rs

2	#![allow(clippy::cast_sign_loss)]
3	#![allow(clippy::cast_possible_wrap)]
4	#![allow(clippy::cast_possible_truncation)]

alt_serde 1.0.119/src/lib.rs

110	cast_possible_truncation,
111	cast_possible_wrap,
112	cast_sign_loss,

alt_serde_json 1.0.61/src/lib.rs

326	clippy::cast_possible_truncation,
327	clippy::cast_possible_wrap,
328	clippy::cast_precision_loss,

arn-language 1.2.1/src/main.rs

10	// I don't care about this
11	clippy::cast_possible_wrap,
12	clippy::cast_sign_loss,

auto_enums 0.8.0/tests/auto_enum.rs

11	#![allow(
12	clippy::cast_possible_wrap,
13	clippy::let_and_return,

av-scenechange 0.8.1/src/lib.rs

4	#![allow(clippy::cast_possible_truncation)]
5	#![allow(clippy::cast_possible_wrap)]
6	#![allow(clippy::cast_precision_loss)]

av-scenechange 0.8.1/src/main.rs

4	#![allow(clippy::cast_possible_truncation)]
5	#![allow(clippy::cast_possible_wrap)]
6	#![allow(clippy::cast_precision_loss)]

av1-grain 0.2.2/src/lib.rs

13	#![allow(clippy::cast_possible_truncation)]
14	#![allow(clippy::cast_possible_wrap)]
15	#![allow(clippy::cast_precision_loss)]

av1an-core 0.4.0/src/lib.rs

9	#![allow(clippy::too_many_lines)]
10	#![allow(clippy::cast_possible_wrap)]
11	#![allow(clippy::if_not_else)]

babbage 0.1.1/src/lib.rs

14	clippy::cast_possible_truncation,
15	clippy::cast_possible_wrap,
16	clippy::cast_precision_loss,

base64-simd 0.8.0/src/lib.rs

41	clippy::cast_lossless,
42	clippy::cast_possible_wrap,
43	clippy::items_after_statements,

beehive 0.1.1/src/lib.rs

47	clippy::cast_possible_truncation,
48	clippy::cast_possible_wrap,
49	clippy::cast_precision_loss,

boa_cli 0.16.0/src/main.rs

47	clippy::cast_precision_loss,
48	clippy::cast_possible_wrap,
49	clippy::cast_ptr_alignment,

boa_engine 0.16.0/src/lib.rs

58	clippy::cast_precision_loss,
59	clippy::cast_possible_wrap,
60	clippy::cast_ptr_alignment,

boa_interner 0.16.0/src/lib.rs

58	clippy::cast_precision_loss,
59	clippy::cast_possible_wrap,
60	clippy::cast_ptr_alignment,

boa_unicode 0.16.0/src/lib.rs

55	clippy::cast_precision_loss,
56	clippy::cast_possible_wrap,
57	clippy::cast_ptr_alignment,

bpaf 0.7.7/src/batteries.rs

28	pub fn verbose_and_quiet_by_number(offset: isize, min: isize, max: isize) -> impl Parser<isize> {
29	#![allow(clippy::cast_possible_wrap)]
30	let verbose = short('v')
85	) -> impl Parser<T> {
86	#![allow(clippy::cast_possible_wrap)]
87	#![allow(clippy::cast_sign_loss)]

byteio 0.2.3/src/lib.rs

94	#![no_std]
95	#![allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
96	#![deny(missing_docs)]

cactusref 0.3.0/src/lib.rs

12	#![warn(clippy::cargo)]
13	#![allow(clippy::cast_possible_wrap)]
14	#![allow(clippy::inline_always)]

cafebabe 0.6.1/src/constant_pool.rs

444	) -> Result<ConstantPoolEntry<'a>, ParseError> {
445	#![allow(clippy::cast_possible_wrap)] // Wrapping is allowed and desired.
446	Ok(ConstantPoolEntry::Integer(read_u4(bytes, ix)? as i32))
461	) -> Result<ConstantPoolEntry<'a>, ParseError> {
462	#![allow(clippy::cast_possible_wrap)] // Wrapping is allowed and desired.
463	Ok(ConstantPoolEntry::Long(read_u8(bytes, ix)? as i64))

cargo-coverage-annotations 0.4.3/src/main.rs

26	#![allow(clippy::cast_possible_truncation)]
27	#![allow(clippy::cast_possible_wrap)]

cartograph 0.1.2/src/lib.rs

14	clippy::cast_possible_truncation,
15	clippy::cast_possible_wrap,
16	clippy::cast_precision_loss,

cat-box 22.6.21/src/physics.rs

5	#![allow(clippy::cast_possible_wrap)]

ciff 0.3.1/src/lib.rs

47	clippy::default_trait_access,
48	clippy::cast_possible_wrap,
49	clippy::cast_possible_truncation,

config-loader 2.2.3/src/main.rs

15	clippy::cast_possible_truncation,
16	clippy::cast_possible_wrap,
17	clippy::cast_precision_loss,

core_arch 0.1.5/src/lib.rs

43	clippy::cast_lossless,
44	clippy::cast_possible_wrap,
45	clippy::cast_possible_truncation,

coresimd 0.1.2/src/lib.rs

52	cast_lossless,
53	cast_possible_wrap,
54	cast_possible_truncation,

cpclib 0.6.0/src/lib.rs

27	clippy::cast_sign_loss,
28	clippy::cast_possible_wrap,
29	clippy::module_inception,

cxx 1.0.88/tests/test.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_possible_wrap,
6	clippy::float_cmp,

deranged-macros 0.1.0/src/lib.rs

31	clippy::cast_possible_truncation,
32	clippy::cast_possible_wrap,
33	clippy::cast_sign_loss,

diffuse 0.1.1/src/lib.rs

14	clippy::cast_possible_truncation,
15	clippy::cast_possible_wrap,
16	clippy::cast_precision_loss,

diskit 0.1.1/src/lib.rs

35	clippy::cast_lossless,
36	clippy::cast_possible_wrap
37	)]

dissimilar 1.0.6/src/lib.rs

43	clippy::bool_to_int_with_if,
44	clippy::cast_possible_wrap,
45	clippy::cast_sign_loss,

dma-heap 0.2.1/src/lib.rs

11	#![deny(clippy::cargo)]
12	#![allow(clippy::cast_possible_wrap)]
13	#![allow(clippy::cast_sign_loss)]

dotnetdll 0.0.1/src/lib.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_possible_wrap,
6	clippy::cast_precision_loss,

dragonbox 0.1.4/src/lib.rs

54	clippy::cast_possible_truncation,
55	clippy::cast_possible_wrap,
56	clippy::cast_sign_loss,

drone-core 0.14.3/src/lib.rs

51	clippy::cast_possible_truncation,
52	clippy::cast_possible_wrap,
53	clippy::cast_sign_loss,

drone-core-macros 0.14.3/src/lib.rs

6	#![warn(clippy::pedantic)]
7	#![allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::similar_names)]

dryip 0.6.0/src/maths.rs

1	#![allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]

electrs-rocksdb 0.15.1-rc1/src/lib.rs

59	// Next `cast_*` lints don't give alternatives.
60	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
61	// Next lints produce too much noise/false positives.

espeakng 0.1.1/src/lib.rs

32	#![allow(
33	clippy::cast_sign_loss, clippy::cast_possible_wrap, // Simple `as` conversions that will not fail.
34	clippy::unused_self, // Speaker needs to take self to keep thread safe.

essence 0.3.3/src/lib.rs

6	clippy::cast_lossless,
7	clippy::cast_possible_wrap,
8	clippy::cast_sign_loss,

exacl 0.10.0/src/sys.rs

123	pub mod sg {
124	#![allow(clippy::cast_possible_wrap)]

exonum 1.0.0/src/lib.rs

86	// Next `cast_*` lints don't give alternatives.
87	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
88	// Next lints produce too much noise/false positives.

exonum-cli 1.0.0/src/lib.rs

122	// Next `cast_*` lints don't give alternatives.
123	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
124	// Next lints produce too much noise/false positives.

exonum-crypto 1.0.0/src/lib.rs

31	// Next `cast_*` lints don't give alternatives.
32	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
33	// Next lints produce too much noise/false positives.

exonum-explorer 1.0.0/src/lib.rs

40	// Next `cast_*` lints don't give alternatives.
41	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
42	// Next lints produce too much noise/false positives.

exonum-explorer-service 1.0.0/src/lib.rs

70	// Next `cast_*` lints don't give alternatives.
71	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
72	// Next lints produce too much noise/false positives.

exonum-keys 1.0.0/src/lib.rs

46	// Next `cast_*` lints don't give alternatives.
47	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
48	// Next lints produce too much noise/false positives.

exonum-merkledb 1.0.0/src/lib.rs

151	// Next `cast_*` lints don't give alternatives.
152	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
153	// Next lints produce too much noise/false positives.

exonum-middleware-service 1.0.0/src/lib.rs

44	// Next `cast_*` lints don't give alternatives.
45	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
46	// Next lints produce too much noise/false positives.

exonum-node 1.0.0/src/lib.rs

46	// Next `cast_*` lints don't give alternatives.
47	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
48	// Next lints produce too much noise/false positives.

exonum-proto 1.0.0/src/lib.rs

45	// Next `cast_*` lints don't give alternatives.
46	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
47	// Next lints produce too much noise/false positives.

exonum-rust-runtime 1.0.0/src/lib.rs

311	// Next `cast_*` lints don't give alternatives.
312	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
313	// Next lints produce too much noise/false positives.

exonum-supervisor 1.0.0/src/lib.rs

137	// Next `cast_*` lints don't give alternatives.
138	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
139	// Next lints produce too much noise/false positives.

exonum-system-api 1.0.0/src/lib.rs

84	// Next `cast_*` lints don't give alternatives.
85	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
86	// Next lints produce too much noise/false positives.

exonum-testkit 1.0.0/src/lib.rs

103	// Next `cast_*` lints don't give alternatives.
104	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
105	// Next lints produce too much noise/false positives.

exonum-time 1.0.0/src/lib.rs

107	// Next `cast_*` lints don't give alternatives.
108	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
109	// Next lints produce too much noise/false positives.

fast-float 0.2.0/src/lib.rs

36	clippy::cast_possible_truncation,
37	clippy::cast_possible_wrap,
38	clippy::cast_sign_loss,

ffsvm 0.8.0/src/lib.rs

78	#![allow(clippy::cast_precision_loss)]
79	#![allow(clippy::cast_possible_wrap)]
80	#![allow(clippy::module_name_repetitions)] // We do that way too often

flacenc 0.1.0/src/lib.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_precision_loss,

flacenc 0.1.0/src/main.rs

19	clippy::cast_possible_truncation,
20	clippy::cast_possible_wrap,
21	clippy::cast_precision_loss,

fsevent-stream 0.2.3/src/stream.rs

3	clippy::non_send_fields_in_send_ty,
4	clippy::cast_possible_wrap,
5	clippy::borrow_interior_mutable_const,

fsevent-stream 0.2.3/src/tests.rs

1	#![allow(clippy::borrow_interior_mutable_const, clippy::cast_possible_wrap)]

funspace 0.4.0/src/space_mpi/decomp2d/mod.rs

38	#![allow(clippy::cast_sign_loss)]
39	#![allow(clippy::cast_possible_wrap)]
40	#![allow(clippy::cast_possible_truncation)]

goff 0.1.0/src/lib.rs

23	clippy::panic_in_result_fn, // Should be removed asap
24	clippy::cast_possible_wrap, // Should be considered but not removed.
25	// Casts are only used in a safe context.

grav1synth 0.1.0-beta.5/src/main.rs

4	#![allow(clippy::cast_possible_truncation)]
5	#![allow(clippy::cast_possible_wrap)]
6	#![allow(clippy::cast_precision_loss)]

hcl-rs 0.12.3/src/lib.rs

6	clippy::cast_possible_truncation,
7	clippy::cast_possible_wrap,
8	clippy::cast_precision_loss,

hedera 0.9.0/src/lib.rs

36	#![allow(
37	clippy::cast_possible_wrap,
38	clippy::cast_possible_truncation,

heh 0.2.0/src/label.rs

3	#![allow(clippy::cast_possible_wrap)]
4	use std::ops::Index;

hex-simd 0.8.0/src/lib.rs

38	clippy::wildcard_imports,
39	clippy::cast_possible_wrap,
40	clippy::cast_possible_truncation,

hexchat 0.6.3/src/lib.rs

23	clippy::cast_possible_truncation,
24	clippy::cast_possible_wrap,
25	clippy::module_name_repetitions

iced_aw 0.3.0/src/lib.rs

40	clippy::cast_sign_loss,
41	clippy::cast_possible_wrap,
42	clippy::module_name_repetitions,

iced_focus 0.1.1/src/lib.rs

42	clippy::cast_sign_loss,
43	clippy::cast_possible_wrap,
44	clippy::module_name_repetitions

iced_focus_derive 0.1.1/src/lib.rs

37	clippy::cast_sign_loss,
38	clippy::cast_possible_wrap,
39	clippy::module_name_repetitions,

imgui-glow-renderer 0.10.0/src/lib.rs

354	) -> Result<(), RenderError> {
355	#![allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
468	clippy::cast_possible_truncation,
469	clippy::cast_possible_wrap
470	)]
1051	) -> Result<GlTexture, InitError> {
1052	#![allow(clippy::cast_possible_wrap)]

interim 0.1.0/src/lib.rs

90	clippy::cast_possible_truncation,
91	clippy::cast_possible_wrap,
92	clippy::cast_sign_loss

io-extras 0.17.1/src/os/windows/stdio.rs

6	clippy::cast_possible_truncation,
7	clippy::cast_possible_wrap,
8	clippy::shadow_reuse,

leftwm-core 0.4.1/src/lib.rs

11	clippy::cast_possible_truncation,
12	clippy::cast_possible_wrap,
13	clippy::cast_sign_loss,

libafl_qemu 0.9.0/src/asan.rs

1	#![allow(clippy::cast_possible_wrap)]

lofty 0.11.0/src/lib.rs

119	clippy::cast_sign_loss,
120	clippy::cast_possible_wrap,
121	clippy::cast_possible_truncation,

lsd 0.23.1/src/main.rs

4	clippy::match_same_arms,
5	clippy::cast_possible_wrap
6	)]

luacells 0.1.4/src/main.rs

4	clippy::cast_sign_loss,
5	clippy::cast_possible_wrap,
6	clippy::needless_range_loop

matterdb 1.2.0/src/lib.rs

97	// Next `cast_*` lints don't give alternatives.
98	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
99	// Next lints produce too much noise/false positives.

mca-cuboids 0.2.0/src/lib.rs

1	#![deny(clippy::all, clippy::pedantic, clippy::cognitive_complexity)]
2	#![allow(clippy::cast_possible_wrap)]
3	#![feature(test)]

memedsn 0.1.0/src/lib.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_precision_loss,

memega 0.1.0/src/lib.rs

25	clippy::cast_possible_truncation,
26	clippy::cast_possible_wrap,
27	clippy::cast_precision_loss,

memegeom 0.1.0/src/lib.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_precision_loss,

memeroute 0.1.0/src/lib.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_precision_loss,

memeroute-gui 0.1.0/src/lib.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_precision_loss,

memestat 0.1.0/src/lib.rs

25	clippy::cast_possible_truncation,
26	clippy::cast_possible_wrap,
27	clippy::cast_precision_loss,

memestr 0.1.0/src/lib.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_precision_loss,

metaldb 1.0.0/src/lib.rs

97	// Next `cast_*` lints don't give alternatives.
98	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
99	// Next lints produce too much noise/false positives.

mhrono 0.1.0/src/lib.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_precision_loss,

microserde 0.1.13/src/lib.rs

138	// Pedantic.
139	clippy::cast_possible_wrap,
140	clippy::cast_precision_loss,

miniserde 0.1.28/src/lib.rs

148	// Pedantic.
149	clippy::cast_possible_wrap,
150	clippy::cast_precision_loss,

miniserde-miku 0.1.23/src/lib.rs

147	// Pedantic.
148	clippy::cast_possible_wrap,
149	clippy::cast_precision_loss,

moldenfile 0.1.0/src/lib.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_precision_loss,

nc 0.8.13/src/call_header.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/platform/darwin-x86_64/call.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/platform/freebsd-x86_64/call.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/platform/linux-aarch64/call.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/platform/linux-arm/call.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/platform/linux-loongarch64/call.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/platform/linux-mips/call.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/platform/linux-mips64/call.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/platform/linux-ppc64/call.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

nixpacks 1.1.1/src/lib.rs

5	clippy::unreadable_literal,
6	clippy::cast_possible_wrap,
7	clippy::wildcard_imports,

nng 1.0.1/src/lib.rs

152

#![allow(clippy::module_name_repetitions)] // Doesn't recognize public re-exports.

153

#![allow(clippy::cast_possible_wrap)]

154

// I want to enable this but it requires bumping the Rustc version and I don't want to do that just

nnv-rs 0.6.1/src/tensorshape.rs

1	#![allow(clippy::cast_possible_wrap, clippy::cast_sign_loss)]
2	use serde::{Deserialize, Serialize};

notifier 0.1.3/src/timer.rs

1	#![allow(clippy::module_inception, clippy::option_option, clippy::cast_sign_loss, clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_lossless)]

packed_simd_2 0.3.8/src/lib.rs

232	clippy::cast_lossless,
233	clippy::cast_possible_wrap,
234	clippy::cast_precision_loss,

parsley 0.10.0/src/primitives/num.rs

2	clippy::cast_possible_truncation,
3	clippy::cast_possible_wrap,
4	clippy::cast_precision_loss,

pb-jelly 0.0.11/src/lib.rs

3	#![allow(clippy::cast_possible_truncation)]
4	#![allow(clippy::cast_possible_wrap)]

pixel_engine_draw 0.7.0/src/traits.rs

168	clippy::cast_precision_loss,
169	clippy::cast_possible_wrap,
170	clippy::cast_sign_loss
543	clippy::cast_precision_loss,
544	clippy::cast_possible_wrap,
545	clippy::cast_sign_loss
604	clippy::cast_precision_loss,
605	clippy::cast_possible_wrap,
606	clippy::cast_sign_loss

polyfuse-tokio 0.2.3/src/channel.rs

3	#![allow(
4	clippy::cast_possible_wrap,
5	clippy::cast_possible_truncation,

portier_broker 0.5.2/src/main.rs

3	clippy::cast_possible_truncation,
4	clippy::cast_possible_wrap,
5	clippy::cast_sign_loss,

prettyplease 0.1.23/src/lib.rs

323	#![allow(
324	clippy::cast_possible_wrap,
325	clippy::cast_sign_loss,

pyxel-core 1.9.11/src/lib.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_possible_wrap,
6	clippy::cast_precision_loss,

pyxel-engine 1.8.2/src/lib.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_possible_wrap,
6	clippy::cast_precision_loss,

pyxel-extension 1.9.11/src/lib.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_possible_wrap,
6	clippy::cast_sign_loss,

pyxel-wrapper 1.8.2/src/lib.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_possible_wrap,
6	clippy::cast_sign_loss,

render_cerke_board 0.1.18/src/lib.rs

3	clippy::cast_precision_loss,
4	clippy::cast_possible_wrap,
5	clippy::cast_possible_truncation,

reversi-game 0.3.3/src/lib.rs

4	#![allow(clippy::missing_panics_doc)]
5	#![allow(clippy::cast_possible_wrap)]
6	#![allow(clippy::cast_possible_truncation)]

rocksdb 0.19.0/src/lib.rs

59	// Next `cast_*` lints don't give alternatives.
60	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
61	// Next lints produce too much noise/false positives.

rocksdbx 0.19.0/src/lib.rs

59	// Next `cast_*` lints don't give alternatives.
60	clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss,
61	// Next lints produce too much noise/false positives.

rofi-mode 0.2.4/src/lib.rs

82	clippy::cast_possible_truncation,
83	clippy::cast_possible_wrap
84	)]

rtop_dev 1.1.0/src/lib.rs

67	clippy::default_numeric_fallback,
68	clippy::cast_possible_wrap,
69	clippy::cast_sign_loss,

rtop-rs 1.1.1/src/lib.rs

26	clippy::default_numeric_fallback,
27	clippy::cast_possible_wrap,
28	clippy::cast_sign_loss,

ryu 1.0.12/src/lib.rs

87	clippy::cast_possible_truncation,
88	clippy::cast_possible_wrap,
89	clippy::cast_sign_loss,

ryu 1.0.12/tests/common_test.rs

23	clippy::approx_constant,
24	clippy::cast_possible_wrap,
25	clippy::cast_sign_loss,

ryu 1.0.12/tests/d2s_table_test.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_sign_loss,

ryu 1.0.12/tests/s2d_test.rs

25	clippy::cast_possible_truncation,
26	clippy::cast_possible_wrap,
27	clippy::cast_sign_loss,

ryu 1.0.12/tests/s2f_test.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_possible_wrap,
27	clippy::cast_sign_loss,

ryu-js 0.2.2/src/lib.rs

61	clippy::cast_possible_truncation,
62	clippy::cast_possible_wrap,
63	clippy::cast_sign_loss,

ryu-js 0.2.2/tests/common_test.rs

23	clippy::approx_constant,
24	clippy::cast_possible_wrap,
25	clippy::cast_sign_loss,

ryu-js 0.2.2/tests/d2s_table_test.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_sign_loss,

ryu-js 0.2.2/tests/s2d_test.rs

26	clippy::cast_possible_truncation,
27	clippy::cast_possible_wrap,
28	clippy::cast_sign_loss,

ryu-js 0.2.2/tests/s2f_test.rs

24	clippy::cast_possible_truncation,
25	clippy::cast_possible_wrap,
26	clippy::cast_possible_wrap,
27	clippy::cast_sign_loss,

scientific 0.2.0/src/lib.rs

5	#![allow(clippy::cast_possible_truncation)]
6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]

serde 1.0.152/src/lib.rs

115	cast_possible_truncation,
116	cast_possible_wrap,
117	cast_sign_loss,

serde_json 1.0.91/src/lib.rs

333	clippy::cast_possible_truncation,
334	clippy::cast_possible_wrap,
335	clippy::cast_precision_loss,

serde_json 1.0.91/tests/lexical.rs

3	clippy::cast_possible_truncation,
4	clippy::cast_possible_wrap,
5	clippy::cast_precision_loss,

serde_json_experimental 1.0.29-rc1/src/lib.rs

331	cast_possible_truncation,
332	cast_possible_wrap,
333	cast_precision_loss,

serde_json_lenient 0.1.4/src/lib.rs

334	clippy::cast_possible_truncation,
335	clippy::cast_possible_wrap,
336	clippy::cast_precision_loss,

serde_json_v8 0.1.1/src/lib.rs

305	// integer and float ser/de requires these sorts of casts
306	cast_possible_wrap,
307	cast_precision_loss,

serde_jsonrc 0.1.0/src/lib.rs

318	// integer and float ser/de requires these sorts of casts
319	cast_possible_wrap,
320	cast_precision_loss,

serde_partiql 1.1.65/src/lib.rs

326	clippy::cast_possible_truncation,
327	clippy::cast_possible_wrap,
328	clippy::cast_precision_loss,

serde_yaml 0.9.17/src/lib.rs

142	clippy::cast_possible_truncation,
143	clippy::cast_possible_wrap,
144	clippy::cast_precision_loss,

serde_yaml 0.9.17/tests/test_de.rs

2	clippy::cast_lossless,
3	clippy::cast_possible_wrap,
4	clippy::derive_partial_eq_without_eq,

serde_yaml_with_quirks 0.8.24/src/lib.rs

88	clippy::blocks_in_if_conditions,
89	clippy::cast_possible_wrap,
90	clippy::cast_precision_loss,

serde_yaml_with_quirks 0.8.24/tests/test_de.rs

2	clippy::cast_lossless,
3	clippy::cast_possible_wrap,
4	clippy::derive_partial_eq_without_eq

serenity 0.11.5/src/lib.rs

65	clippy::unreadable_literal,
66	clippy::cast_possible_wrap,
67	clippy::wildcard_imports,

slice-deque 0.3.0/src/lib.rs

135	clippy::shadow_reuse,
136	clippy::cast_possible_wrap,
137	clippy::cast_sign_loss,

slice-ring-buffer 0.3.2/src/lib.rs

135	clippy::shadow_reuse,
136	clippy::cast_possible_wrap,
137	clippy::cast_sign_loss,

sparkle-cache-postgres 0.14.1/src/backend.rs

3	clippy::as_conversions,
4	clippy::cast_possible_wrap,
5	clippy::integer_arithmetic,

sparkle-cache-postgres 0.14.1/src/cache.rs

4	clippy::integer_arithmetic,
5	clippy::cast_possible_wrap,
6	clippy::cast_sign_loss,

sponsor-block 0.6.1/src/lib.rs

59	clippy::cast_possible_truncation,
60	clippy::cast_possible_wrap,
61	clippy::cast_precision_loss,

sqlx-migrate 0.6.0/src/lib.rs

10	clippy::cast_possible_truncation,
11	clippy::cast_possible_wrap,
12	clippy::cast_sign_loss,

ssimulacra2 0.3.0/src/lib.rs

4	#![allow(clippy::cast_possible_truncation)]
5	#![allow(clippy::cast_possible_wrap)]
6	#![allow(clippy::cast_precision_loss)]

store 0.1.0-alpha.3/src/lib.rs

63	clippy::cast_possible_truncation,
64	clippy::cast_possible_wrap,
65	clippy::cast_sign_loss,

sts_profile_auth 0.7.1/src/lib.rs

7	#![allow(clippy::cast_possible_truncation)]
8	#![allow(clippy::cast_possible_wrap)]
9	#![allow(clippy::similar_names)]

swarm-bot 0.3.4/src/main.rs

66	clippy::cast_precision_loss,
67	clippy::cast_possible_wrap,
68	clippy::default_trait_access

swarm-bot 0.3.4/src/storage/chunk.rs

1	#![allow(clippy::unwrap_used, clippy::cast_possible_wrap)]

syn 1.0.107/src/lib.rs

259	clippy::cast_possible_truncation,
260	clippy::cast_possible_wrap,
261	clippy::cast_ptr_alignment,

syn-pub-items 0.15.30/src/lib.rs

250	cast_possible_truncation,
251	cast_possible_wrap,
252	empty_enum,

time-macros-impl 0.1.2/src/lib.rs

35	clippy::cast_possible_truncation,
36	clippy::cast_possible_wrap,
37	clippy::cast_precision_loss,

tinydeque 0.1.1/src/lib.rs

6	#![allow(clippy::redundant_pattern_matching)]
7	#![allow(clippy::cast_possible_wrap)]
8	#![forbid(unsafe_code)]

tremor-script 0.13.0-rc.11/src/std_lib/datetime.rs

17	clippy::cast_sign_loss,
18	clippy::cast_possible_wrap
19	)]

unsafe-libyaml 0.2.5/src/bin/run-emitter-test-suite.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_possible_wrap,
6	clippy::cast_sign_loss,

unsafe-libyaml 0.2.5/src/bin/run-parser-test-suite.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_possible_wrap,
6	clippy::cast_sign_loss,

unsafe-libyaml 0.2.5/src/lib.rs

14	clippy::cast_possible_truncation,
15	clippy::cast_possible_wrap,
16	clippy::cast_ptr_alignment,

uv_patch_packed_simd 0.3.5/src/lib.rs

218	clippy::cast_lossless,
219	clippy::cast_possible_wrap,
220	clippy::cast_precision_loss,

video-resize 0.1.1/src/lib.rs

4	#![allow(clippy::cast_possible_truncation)]
5	#![allow(clippy::cast_possible_wrap)]
6	#![allow(clippy::cast_precision_loss)]

vsimd 0.8.0/src/lib.rs

30	clippy::cast_sign_loss,
31	clippy::cast_possible_wrap,
32	clippy::cast_lossless,

yuv2rgb 0.0.2/src/lib.rs

6	#![allow(clippy::cast_possible_truncation)]
7	#![allow(clippy::cast_possible_wrap)]
8	#![allow(clippy::cast_precision_loss)]

yuvxyb 0.3.0/src/lib.rs

4	#![allow(clippy::cast_possible_truncation)]
5	#![allow(clippy::cast_possible_wrap)]
6	#![allow(clippy::cast_precision_loss)]

zune-jpeg 0.2.0/src/color_convert.rs

5	clippy::cast_sign_loss,
6	clippy::cast_possible_wrap,
7	clippy::too_many_arguments,

30	// Only a problem on implausibly large maps.
31	#[allow(clippy::cast_possible_wrap)]
32	let mut local_pos = Position::new(self.local_pos_x as i32, self.local_pos_y as i32);
33	#[allow(clippy::cast_possible_wrap)]
34	while !self.target.intersects_local_position(local_pos) {

51	pub fn size(&self) -> Size {
52	#[allow(clippy::cast_possible_wrap)]
53	let width = self.canvas.width() as i32;
54	#[allow(clippy::cast_possible_wrap)]
55	let height = self.canvas.height() as i32;

45	const FORKSRV_FD: i32 = 198;
46	#[allow(clippy::cast_possible_wrap)]
47	const FS_OPT_ENABLED: i32 = 0x80000001_u32 as i32;
48	#[allow(clippy::cast_possible_wrap)]
49	const FS_OPT_MAPSIZE: i32 = 0x40000000_u32 as i32;
50	#[allow(clippy::cast_possible_wrap)]
51	const FS_OPT_SHDMEM_FUZZ: i32 = 0x01000000_u32 as i32;
52	#[allow(clippy::cast_possible_wrap)]
53	const FS_OPT_AUTODICT: i32 = 0x10000000_u32 as i32;
148	#[allow(trivial_numeric_casts, clippy::cast_possible_wrap)]
149	fn setlimit(&mut self, memlimit: u64) -> &mut Self {