actors-rs 0.1.4/src/actor/actor_cell.rs

689	let delay = std::cmp::max(time.timestamp() - Utc::now().timestamp(), 0 as i64);
690	#[allow(clippy::cast_sign_loss)]
691	let delay = Duration::from_secs(delay as u64);

actors-rs 0.1.4/src/system/mod.rs

356	/// Returns the number of seconds since the system started
357	#[allow(clippy::cast_sign_loss)]
358	pub fn uptime(&self) -> u64 {
747	let delay = std::cmp::max(time.timestamp() - Utc::now().timestamp(), 0 as i64);
748	#[allow(clippy::cast_sign_loss)]
749	let delay = Duration::from_secs(delay as u64);

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

132	#[allow(clippy::cast_sign_loss)]
133	pub fn integrate_dvs_events<F: Fn(i64, i64) -> bool + Send + 'static + std::marker::Sync>(

afe4404 0.2.2/src/clock/mod.rs

33	ClockConfiguration::InternalToOutput { division_ratio } => {
34	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
35	let reg_ratio = f32::from(division_ratio).log2().round() as u8;

afe4404 0.2.2/src/led_current/low_level.rs

65	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
66	let values = [
118	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
119	let values = [
195	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
196	let value = (
229	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
230	let value = (
322	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
323	let values = [

afe4404 0.2.2/src/led_current/mod.rs

63	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
64	let values = [
137	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
138	let values: [(u8, bool); 4] = [
256	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
257	let values = [
328	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
329	let values: [(u8, bool); 4] = [

alloc-wg 0.9.0/src/vec.rs

2892	#[must_use]
2893	#[allow(clippy::cast_sign_loss)]
2894	fn size_hint(&self) -> (usize, Option<usize>) {

alloc-wg 0.9.0/tests/vec.rs

1123	#[allow(clippy::cast_sign_loss)]
1124	const MAX_CAP: usize = isize::max_value() as usize;
1228	#[allow(clippy::cast_sign_loss)]
1229	const MAX_CAP: usize = isize::max_value() as usize;

amadeus-aws 0.4.3/src/cloudfront.rs

215	};
216	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
217	let time_taken =

amadeus-core 0.4.3/src/util.rs

228	clippy::cast_possible_truncation,
229	clippy::cast_sign_loss,
230	clippy::cast_precision_loss
237	clippy::cast_possible_truncation,
238	clippy::cast_sign_loss,
239	clippy::cast_precision_loss,

amadeus-streaming 0.4.3/src/lib.rs

82	clippy::cast_possible_truncation,
83	clippy::cast_sign_loss,
84	clippy::cast_precision_loss,
93	clippy::cast_possible_truncation,
94	clippy::cast_sign_loss,
95	clippy::cast_precision_loss

amethyst_tiles 0.15.3/src/map.rs

306	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
307	fn to_tile(
343	} else {
344	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
345	Ok(Point3::new(

amethyst_tiles 0.15.3/src/pass.rs

415	clippy::cast_possible_truncation,
416	clippy::cast_sign_loss,
417	clippy::cast_precision_loss,

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

57	// upper 16-bits of the i32 are zeroed:
58	clippy::cast_sign_loss,
59	clippy::cast_possible_truncation
74	// upper 16-bits of the i32 are zeroed:
75	clippy::cast_sign_loss,
76	clippy::cast_possible_truncation

ascii 1.1.0/src/ascii_char.rs

877	// the sign, as long as negative numbers are mapped outside ascii range.
878	#[allow(clippy::cast_sign_loss)]
879	impl ToAsciiChar for i8 {

astral-util 0.0.5/src/hash/nop_hasher.rs

120	#[allow(clippy::cast_sign_loss)]
121	#[test]

astrotime 0.1.0/src/calendar.rs

136	/// Panics on assertions that should only fail if there is a bug.
137	#[allow(clippy::cast_sign_loss)]
138	#[allow(clippy::cast_possible_truncation)]

astrotime 0.1.0/src/date_time.rs

104	/// are not defined.
105	#[allow(clippy::cast_sign_loss)]
106	#[allow(clippy::cast_lossless)]
188	#[must_use]
189	#[allow(clippy::cast_sign_loss)]
190	#[allow(clippy::cast_possible_truncation)]
289	#[allow(clippy::cast_precision_loss)]
290	#[allow(clippy::cast_sign_loss)]
291	pub fn from_day_number_and_fraction(day_number: i64, day_fraction: f64)
437	#[inline]
438	#[allow(clippy::cast_sign_loss)]
439	pub fn set_year(&mut self, year: i32) {
446	#[inline]
447	#[allow(clippy::cast_sign_loss)]
448	pub fn set_year_bc(&mut self, year_bc: i32) {

attheme 0.3.0/src/parser.rs

11	// -1 will become 0xffffffff, just like needed here.
12	#[allow(clippy::cast_sign_loss)]
13	let value = value as u32;

atuin 12.0.0/src/command/client/history.rs

81	#[allow(clippy::cast_sign_loss)]
82	pub fn print_list(h: &[History], list_mode: ListMode) {
95	#[allow(clippy::cast_sign_loss)]
96	pub fn print_human_list(w: &mut StdoutLock, h: &[History]) {
107	#[allow(clippy::cast_sign_loss)]
108	pub fn print_regular(w: &mut StdoutLock, h: &[History]) {

atuin-client 12.0.0/src/import/resh.rs

109	#[allow(clippy::cast_possible_truncation)]
110	#[allow(clippy::cast_sign_loss)]
111	let timestamp = {
116	#[allow(clippy::cast_possible_truncation)]
117	#[allow(clippy::cast_sign_loss)]
118	let duration = {

au 0.10.0/src/transfer_function/discretization.rs

154	/// Common operations for discretization
155	#[allow(clippy::cast_sign_loss)]
156	fn discr_impl<T: Float>(tf: &Tf<T>, s_num: &Poly<T>, s_den: &Poly<T>) -> Tfz<T> {

automatica 1.0.0/src/complex.rs

155	#[allow(clippy::cast_sign_loss)]
156	fn powi(&self, exp: i32) -> Self {

automatica 1.0.0/src/transfer_function/discretization.rs

173	/// Common operations for discretization
174	#[allow(clippy::cast_sign_loss)]
175	fn discr_impl<T>(tf: &Tf<T>, s_num: &Poly<PWrapper<T>>, s_den: &Poly<PWrapper<T>>) -> Tfz<T>

avml 0.10.0/src/disk_usage.rs

99	/// 2. The value is explicitly truncated and clamped to the integer value
100	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
101	fn f64_to_u64(value: f64) -> Result<u64> {

babycat 0.0.14/src/backend/decoder/ffmpeg.rs

37	#[allow(clippy::cast_possible_truncation)]
38	#[allow(clippy::cast_sign_loss)]
39	fn estimate_num_frames_inner(

babycat 0.0.14/src/backend/resample/babycat_lanczos.rs

27	#[allow(clippy::cast_possible_truncation)]
28	#[allow(clippy::cast_sign_loss)]
29	fn compute_sample(

babycat 0.0.14/src/backend/resample/babycat_sinc.rs

17	#[allow(clippy::cast_possible_truncation)]
18	#[allow(clippy::cast_sign_loss)]
19	#[allow(clippy::cast_precision_loss)]
68	#[allow(clippy::cast_possible_truncation)]
69	#[allow(clippy::cast_sign_loss)]
70	#[allow(clippy::cast_precision_loss)]

babycat 0.0.14/src/backend/resample/common.rs

46	#[allow(clippy::cast_precision_loss)]
47	#[allow(clippy::cast_sign_loss)]
48	pub fn get_num_output_frames(

bee-crypto 0.3.0/src/ternary/bigint/split_integer.rs

28

    #[allow(clippy::cast_possible_truncation)] // Truncation is used to remove the high part of the integer.

29

    #[allow(clippy::cast_sign_loss)] // Sign loss is expected as `Self::Low` represents the lower part of the integer.

30

    fn lo(self) -> Self::Low {

bee-crypto 0.3.0/src/ternary/bigint/u384/mod.rs

357	#[allow(clippy::cast_sign_loss)] // This is a slice of `UTrit`s, so `binary_trit` is always positive.
358	let new_extent = accumulator.add_digit_inplace(*binary_trit as u32);

bee-crypto 0.3.0/src/ternary/sponge/curlp/mod.rs

76	unsafe fn truth_table_get(state: &Trits, p: usize, q: usize) -> Btrit {
77	#[allow(clippy::cast_sign_loss)] // Reason: "`BTrit`'s repr is between `-1` and `1`
78	*TRUTH_TABLE

beehive 0.1.1/src/line.rs

32	// length is known to be non-negative
33	#[allow(clippy::cast_sign_loss)]
34	let mut steps = delta.length() as usize + 1;

belgium 0.2.0/src/alu.rs

76	NOT => (!val_right, false),
77	#[allow(clippy::cast_sign_loss)]
78	#[allow(clippy::cast_possible_wrap)]

bevy_fundsp 0.2.0/src/backend/bevy_audio.rs

36	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
37	fn sample_rate(&self) -> u32 {

bevy_fundsp 0.2.0/src/backend/oddio.rs

28	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
29	fn convert_to_audio_source(dsp_source: DspSource) -> Self::StaticAudioSource {
49	impl DspSource {
50	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
51	pub(crate) fn into_exact_size_iter(

bevy_fundsp 0.2.0/src/dsp_source.rs

124	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
125	fn advance(&self, dt: f32) {

bevy_oddio 0.3.0/src/loader/mp3_loader.rs

49	#[allow(clippy::cast_sign_loss)]
50	let frames = oddio::Frames::from_iter(current_sample_rate as u32, samples);

bevy_particle_systems 0.7.1/src/systems.rs

29	#[allow(
30	clippy::cast_sign_loss,
31	clippy::cast_precision_loss,

bevy_save 0.3.0/src/rollbacks.rs

32	#[allow(clippy::cast_possible_wrap)]
33	#[allow(clippy::cast_sign_loss)]
34	pub fn rollback(&mut self, checkpoints: isize) -> Option<&RollbackSnapshot> {

binrw 0.10.0/src/io/bufreader.rs

165	// Lint: The sign is checked in precondition above
166	#[allow(clippy::cast_sign_loss)]
167	old.checked_add(rel_n as u64)

blockchain_contracts 0.4.1/tests/bitcoin_helper/mod.rs

194	#[allow(clippy::cast_sign_loss)] // it is just for the tests
195	unspent

bma-benchmark 0.0.20/src/lib.rs

501	#[allow(clippy::cast_sign_loss)]
502	#[allow(clippy::cast_possible_truncation)]
508	#[allow(clippy::cast_sign_loss)]
509	#[allow(clippy::cast_possible_truncation)]

bme280-rs 0.1.0/src/calibration.rs

137	#[allow(clippy::cast_sign_loss)] // Using reference algorithm
138	#[allow(clippy::cast_possible_truncation)] // Acceptable truncation
173	#[allow(clippy::cast_sign_loss)] // Using reference algorithm
174	let humidity = humidity as u32;

bocu1 0.1.0/src/delta_encoding.rs

107	/// for malformed inputs.
108	#[allow(clippy::cast_sign_loss)]
109	pub fn decode_char<'a>(

bocu1 0.1.0/src/trailing_byte_selection.rs

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

bocu1 0.1.0/src/variable_length_code.rs

85	#[inline]
86	#[allow(clippy::cast_sign_loss)]
87	#[allow(clippy::cast_possible_truncation)]

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

45	/// cannot be done without losing data, an error will be returned.
46	#[allow(clippy::cast_sign_loss)]
47	pub fn into_u64(self) -> Result<Option<u64>, Error> {
99	/// overflows will be allowed during conversion.
100	#[allow(clippy::cast_sign_loss)]
101	pub fn into_u64_lossy(self, saturating: bool) -> Result<Option<u64>, Error> {
210	/// cannot be done without losing data, an error will be returned.
211	#[allow(clippy::cast_sign_loss)]
212	pub async fn into_u64(self) -> Result<Option<u64>, Error> {
264	/// overflows will be allowed during conversion.
265	#[allow(clippy::cast_sign_loss)]
266	pub async fn into_u64_lossy(self, saturating: bool) -> Result<Option<u64>, Error> {

bonsaidb-core 0.4.1/src/keyvalue.rs

588	#[must_use]
589	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
590	pub fn as_u64(&self) -> Option<u64> {
607	#[must_use]
608	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
609	pub fn as_u64_lossy(&self, saturating: bool) -> u64 {

boreal 0.1.0/src/evaluator/mod.rs

751	} else {
752	#[allow(clippy::cast_sign_loss)]
753	let value = { value as u64 };

boreal 0.1.0/src/module/math.rs

229	// numbers...
230	#[allow(clippy::cast_sign_loss)]
231	{
250	// numbers...
251	#[allow(clippy::cast_sign_loss)]
252	{
283	#[allow(clippy::cast_possible_truncation)]
284	#[allow(clippy::cast_sign_loss)]
285	let byte: u8 = byte as u8;

boreal 0.1.0/src/module/pe.rs

23	#[allow(clippy::cast_possible_truncation)]
24	#[allow(clippy::cast_sign_loss)]
25	mod signatures;

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

22	/// Convert a Point (x/y) to an array index. Defaults to a Z, Y, X striding.
23	#[allow(clippy::cast_sign_loss)]
24	fn point3d_to_index(&self, pt: Point3) -> usize {

braque 0.1.0/src/shuffle.rs

34	clippy::cast_precision_loss,
35	clippy::cast_sign_loss,
36	clippy::cast_possible_truncation

brunch 0.4.0/src/math.rs

157	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
158	/// # Quantile.

busrt 0.3.6/src/common.rs

88	#[cfg(feature = "broker")]
89	#[allow(clippy::cast_sign_loss)]
90	/// # Panics

cargo-cache 0.8.3/src/commands/trim.rs

99	#[allow(clippy::cast_lossless)]
100	#[allow(clippy::cast_sign_loss)]
101	#[allow(clippy::cast_possible_truncation)]

cargo-show-asm 0.2.12/src/lib.rs

53	#[allow(clippy::cast_sign_loss)]
54	#[allow(clippy::cast_precision_loss)]

cargo-trim 0.10.1/src/utils.rs

90	clippy::cast_possible_truncation,
91	clippy::cast_sign_loss
92	)]

cdtoc 0.1.5/src/time.rs

209	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
210	#[must_use]

checksec 0.0.9/src/main.rs

256	if json {
257	#[allow(clippy::cast_sign_loss)]
258	procs.append(&mut vec![Process::new(
313	if json {
314	#[allow(clippy::cast_sign_loss)]
315	json_print(
353	if json {
354	#[allow(clippy::cast_sign_loss)]
355	procs.append(&mut vec![Process::new(

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

235	impl From<u8x4> for (u8, u8, u8, u8) {
236	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
237	#[cfg_attr(not(debug_assertions), inline(always))]
251	impl From<&u8x4> for (u8, u8, u8, u8) {
252	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
253	#[cfg_attr(not(debug_assertions), inline(always))]
267	impl From<u8x4> for [u8; 4] {
268	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
269	#[cfg_attr(not(debug_assertions), inline(always))]
283	impl From<&u8x4> for [u8; 4] {
284	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
285	#[cfg_attr(not(debug_assertions), inline(always))]
561	impl From<u32x4> for (u32, u32, u32, u32) {
562	#[allow(clippy::cast_sign_loss)]
563	#[cfg_attr(not(debug_assertions), inline(always))]

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

235	impl From<u8x4> for (u8, u8, u8, u8) {
236	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
237	#[cfg_attr(not(debug_assertions), inline(always))]
251	impl From<&u8x4> for (u8, u8, u8, u8) {
252	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
253	#[cfg_attr(not(debug_assertions), inline(always))]
267	impl From<u8x4> for [u8; 4] {
268	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
269	#[cfg_attr(not(debug_assertions), inline(always))]
283	impl From<&u8x4> for [u8; 4] {
284	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
285	#[cfg_attr(not(debug_assertions), inline(always))]
561	impl From<u32x4> for (u32, u32, u32, u32) {
562	#[allow(clippy::cast_sign_loss)]
563	#[cfg_attr(not(debug_assertions), inline(always))]

classygroup 0.0.5/src/hash/primality/mod.rs

98	/// Note that `p` does not show up in the code because it is set to 1.
99	#[allow(clippy::cast_sign_loss)]
100	fn compute_lucas_sequences(

cloth_bumpmap 0.1.6/src/lib.rs

223	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
224	fn clamp_to_u8(a: f32) -> u8 {
228	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
229	fn multiply_channel(a: u8, b: u8) -> u8 {
233	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
234	fn stretch_contrast(min: u8, max: u8, data: u8) -> u8 {

completion 0.2.1/src/future/join/all/base.rs

109	let shared = unsafe { &*self.base };
110	#[allow(clippy::cast_sign_loss)]
111	let index = unsafe {

completion 0.2.1/src/future/join/tuple/base.rs

109	let shared = unsafe { &*self.base };
110	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
111	let index = unsafe {

constellation-internal 0.2.0-alpha.2/src/units.rs

368	}
369	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
370	fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>

cotton-netif 0.0.2/src/linux_netlink.rs

86	#[allow(clippy::cast_sign_loss)]
87	fn translate_link_message(
117	#[allow(clippy::cast_sign_loss)]
118	fn translate_addr_message(

cpclib-disc 0.6.0/src/edsk.rs

17	#[allow(clippy::cast_possible_truncation)]
18	#[allow(clippy::cast_sign_loss)]
19	pub fn convert_real_sector_size_to_fdc_sector_size(mut size: u16) -> u8 {

cpclib-z80emu 0.6.0/src/emul.rs

415	#[allow(clippy::cast_sign_loss)]
416	fn eval_expr(&self, expr: &Expr) -> Option<u16> {

cvr 0.1.2/src/convert.rs

145	#[must_use]
146	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
147	pub fn linear_to_srgb(u: f32) -> u8 {

dactyl 0.4.7/src/nice_elapsed/mod.rs

120	#[allow(clippy::cast_precision_loss)] // It fits.
121	#[allow(clippy::cast_sign_loss)] // It is positive.
122	fn from(src: Duration) -> Self {
319	#[allow(clippy::cast_possible_truncation)] // We're checking first.
320	#[allow(clippy::cast_sign_loss)] // Values are unsigned.
321	#[allow(clippy::similar_names)] // It's that or the names become tedious.

daml-grpc 0.2.2/src/util.rs

9	#[allow(clippy::cast_sign_loss)]
10	pub fn from_grpc_timestamp(timestamp: &prost_types::Timestamp) -> DateTime<Utc> {
22	#[allow(clippy::cast_sign_loss)]
23	pub fn from_grpc_duration(duration: &prost_types::Duration) -> Duration {

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

78	// upper 16-bits of the i32 are zeroed:
79	clippy::cast_sign_loss,
80	clippy::cast_possible_truncation
102	// upper 16-bits of the i32 are zeroed:
103	clippy::cast_sign_loss,
104	clippy::cast_possible_truncation

dbgen 0.8.0/src/schemagen_cli.rs

309	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
310	fn append_to(
362	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
363	fn gen_table(dialect: Dialect, rng: &mut dyn RngCore, target_size: f64) -> Table {

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

415	// Checked: we want to reinterpret the bits
416	#[allow(clippy::cast_sign_loss)]
417	let uv_res = _mm256_extract_epi64(permuted, 0) as u64;

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 {
47	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
48	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
49	pub const fn i32_to_i16(x: i32) -> i16 {

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

420	// Checked: we want to reinterpret the bits
421	#[allow(clippy::cast_sign_loss)]
422	let uv_res = _mm_cvtsi128_si32(packed_to_16) as u32;

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

107	// Checked: we want the lower 8 bits
108	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
109	if (fix & !((256 << frac_bits) - 1)) == 0 {
164	/// Truncate and interleave 2 int to 2 uchar
165	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
166	unsafe fn pack_i32x2(image: *mut u8, x: i32, y: i32) {
359	// Checked: this is proved to not go outside the 8-bit boundary
360	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
361	{
413	// Checked: this is proved to not go outside the 8-bit boundary
414	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
415	{
818	clippy::cast_possible_truncation,
819	clippy::cast_sign_loss,
820	clippy::cast_possible_wrap

den 0.3.0/src/lib.rs

866	clippy::cast_precision_loss,
867	clippy::cast_sign_loss
868	)]

dexios-domain 1.0.1/src/hash.rs

83	#[allow(
84	clippy::cast_sign_loss,
85	clippy::cast_possible_truncation,

divrem 1.0.0/tests/lib.rs

179	fn div_ceil(x: u32, y: u32) -> u32 {
180	#[allow(clippy::cast_sign_loss)] // ∀x,y>=0 ⌈x/y⌉>=0.
181	#[allow(clippy::cast_possible_truncation)] // ⌈x/y⌉ is an integer <=x.
186	fn div_rem_ceil(x: Wrapping<u32>, y: Wrapping<u32>) -> (Wrapping<u32>, Wrapping<u32>) {
187	#[allow(clippy::cast_sign_loss)] // ∀n,m>=0 ⌈n/m⌉>=0
188	#[allow(clippy::cast_possible_truncation)] // ⌈x/y⌉ is an integer <=x.

docuum 0.21.1/src/run.rs

742	clippy::cast_possible_truncation,
743	clippy::cast_sign_loss
744	)]

dungen_minion_geometry 0.3.2/src/area.rs

45	// As this returns if a coordinate is less than zero, sign loss is not a problem.
46	#[allow(clippy::cast_sign_loss)]
47	if position.x() < 0
114	// As this returns if a coordinate is less than zero, sign loss is not a problem.
115	#[allow(clippy::cast_sign_loss)]
116	!(position.x() < 0

dungen_minion_geometry 0.3.2/src/has_bottom.rs

37	// Since the minimum is zero, there is no sign loss to worry about.
38	#[allow(clippy::cast_sign_loss)]
39	let height = height_coord.max(0) as Length;

dungen_minion_geometry 0.3.2/src/has_right.rs

37	// Since the minimum is zero, there is no sign loss to worry about.
38	#[allow(clippy::cast_sign_loss)]
39	let width = width_coord.max(0) as Length;

dungen_minion_geometry 0.3.2/src/size.rs

51	// As this returns if a coordinate is less than zero, sign loss is not a problem.
52	#[allow(clippy::cast_sign_loss)]
53	if position.x() < 0
87	// As this returns if a coordinate is less than zero, sign loss is not a problem.
88	#[allow(clippy::cast_sign_loss)]
89	!(position.x() < 0

dungen_minion_rooms 0.3.2/src/sparse_map.rs

260	// Since the minimum is zero, there is no sign loss to worry about.
261	#[allow(clippy::cast_sign_loss)]
262	{

dungen_minion_rooms_abstract 0.3.2/src/map.rs

51	// As this returns if a coordinate is less than zero, sign loss is not a problem.
52	#[allow(clippy::cast_sign_loss)]
53	!(position.x() < 0

dwm-status 1.8.1/src/features/battery/notifier.rs

104	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
105	fn notify(&mut self, battery: &SimpleBattery) {

dwm-status 1.8.1/src/utils.rs

3	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
4	#[cfg_attr(all(test, feature = "mocking"), mocktopus::macros::mockable)]

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

411	Edn::Str(s) => s.parse::<usize>().ok(),
412	#[allow(clippy::cast_sign_loss)]
413	Edn::Int(i) if i > &0 => Some(*i as usize),
416	{
417	#[allow(clippy::cast_sign_loss)]
418	#[allow(clippy::cast_possible_truncation)]
422	{
423	#[allow(clippy::cast_sign_loss)]
424	#[allow(clippy::cast_possible_truncation)]

elastic-elgamal 0.2.1/src/proofs/range.rs

137	clippy::cast_precision_loss,
138	clippy::cast_sign_loss
139	)]

elbus 0.2.21/src/common.rs

88	#[cfg(feature = "broker")]
89	#[allow(clippy::cast_sign_loss)]
90	/// # Panics

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

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

entab 0.3.1/src/parsers/flow.rs

242	let range = v.trim().parse::<f64>()?;
243	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
244	{

entropycli 1.0.8/src/cosmos/network.rs

126	#[allow(clippy::cast_possible_truncation)]
127	#[allow(clippy::cast_sign_loss)]
128	// We can safely cast here because we know that the gas price won't be

entropycli 1.0.8/src/cosmos/utils.rs

10	#[allow(clippy::cast_possible_truncation)]
11	#[allow(clippy::cast_sign_loss)]
12	let gas = gas as u64;

eosio 0.3.1/src/time/block_timestamp.rs

52	#[inline]
53	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
54	fn from(tp: TimePoint) -> Self {
73	#[inline]
74	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
75	fn from(tps: TimePointSec) -> Self {
84	#[inline]
85	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
86	fn from(bt: BlockTimestamp) -> Self {
147	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
148	#[test]

eosio 0.3.1/src/time/time_point.rs

62	#[must_use]
63	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
64	pub const fn as_time_point_sec(&self) -> TimePointSec {

eosio 0.3.1/src/time/time_point_sec.rs

58	#[must_use]
59	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
60	fn from(t: TimePoint) -> Self {

eosio 0.3.1/src/varint/signed.rs

56	#[must_use]
57	#[allow(clippy::cast_sign_loss)]
58	fn num_bytes(&self) -> usize {
92	#[inline]
93	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
94	fn write(

eosio_cdt 0.3.1/src/table_primary.rs

        let size = unsafe { db_get_i64(self.value, nullptr, 0) };
        #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
        let mut bytes = vec![0_u8; size as usize];
        let ptr: *mut c_void = &mut bytes[..] as *mut _ as *mut c_void;
        #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
        unsafe {

eosio_cdt 0.3.1/src/table_secondary.rs

628	ptr,
629	#[allow(clippy::cast_sign_loss)]
630	{

esbat 0.1.0/src/util.rs

21	#[allow(clippy::cast_sign_loss)]
22	pub(crate) fn nonneg(x: i32) -> u32 {

eva-common 0.1.185/src/time.rs

47	#[inline]
48	#[allow(clippy::cast_sign_loss)]
49	pub fn now() -> Self {
62	}
63	#[allow(clippy::cast_sign_loss)]
64	#[allow(clippy::cast_possible_truncation)]
111	/// Will panic if the monotonic clock is not available
112	#[allow(clippy::cast_sign_loss)]
113	pub fn monotonic() -> u64 {
121	/// Will panic if the monotonic clock is not available
122	#[allow(clippy::cast_sign_loss)]
123	pub fn monotonic_ns() -> u64 {
130	/// Will panic if the system clock is not available
131	#[allow(clippy::cast_sign_loss)]
132	pub fn now() -> u64 {

eva-common 0.1.185/src/tools.rs

260	#[allow(clippy::cast_possible_truncation)]
261	#[allow(clippy::cast_sign_loss)]
262	pub fn de_float_as_duration_us<'de, D>(deserializer: D) -> Result<Duration, D::Error>
271	#[allow(clippy::cast_possible_truncation)]
272	#[allow(clippy::cast_sign_loss)]
273	pub fn de_opt_float_as_duration_us<'de, D>(deserializer: D) -> Result<Option<Duration>, D::Error>

eva-common 0.1.185/src/value/mod.rs

313	#[allow(clippy::cast_possible_truncation)]
314	#[allow(clippy::cast_sign_loss)]

eva-ics 3.99.0/src/core.rs

1063	}
1064	#[allow(clippy::cast_sign_loss)]
1065	#[inline]

eva-ics 3.99.0/src/logs.rs

453	#[allow(clippy::cast_possible_truncation)]
454	#[allow(clippy::cast_sign_loss)]
455	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

eva-ics 3.99.0/src/time.rs

59	#[inline]
60	#[allow(clippy::cast_sign_loss)]
61	pub fn now() -> Self {
74	}
75	#[allow(clippy::cast_sign_loss)]
76	#[allow(clippy::cast_possible_truncation)]
111	/// Will panic if the monotonic clock is not available
112	#[allow(clippy::cast_sign_loss)]
113	pub fn monotonic() -> u64 {
121	/// Will panic if the monotonic clock is not available
122	#[allow(clippy::cast_sign_loss)]
123	pub fn monotonic_ns() -> u64 {
130	/// Will panic if the system clock is not available
131	#[allow(clippy::cast_sign_loss)]
132	pub fn now() -> u64 {

eva-ics 3.99.0/src/tools.rs

21	#[allow(clippy::cast_possible_truncation)]
22	#[allow(clippy::cast_sign_loss)]
23	pub fn de_float_as_duration_us<'de, D>(deserializer: D) -> Result<Duration, D::Error>

eva-sdk 0.1.111/src/transform.rs

140	#[allow(clippy::cast_sign_loss)]
141	#[allow(clippy::cast_possible_truncation)]

fair-rate-limiter 0.1.0/src/lib.rs

193	/// `global_max_cost` and `global_max_cost`/keys.
194	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
195	fn max_cost(sources_max: u32, recent_cost: u32, keys: u32) -> u32 {
438	) -> Result<FairRateLimiter<IpAddrKey, 1000>, String> {
439	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
440	let other_max = max((max_cost_per_sec * 0.20) as u32, 1);
441	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
442	let sources_max = (max_cost_per_sec as u32).saturating_sub(other_max);

fancy-prompt 0.2.1/src/prompt.rs

124	let color = battery_discharge_color(battery_usage, charging);
125	#[allow(clippy::cast_sign_loss)]
126	#[allow(clippy::cast_possible_truncation)]

fend-core 1.1.4/src/num/bigrat.rs

161	clippy::cast_possible_truncation,
162	clippy::cast_sign_loss,
163	clippy::cast_precision_loss

fend-core 1.1.4/src/num/dist.rs

87	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
88	pub(crate) fn sample<I: Interrupt>(
109	clippy::cast_possible_truncation,
110	clippy::cast_sign_loss,
111	clippy::too_many_arguments

feroxfuzz 1.0.0-rc.8/src/corpora/range.rs

226	#[allow(clippy::similar_names)]
227	#[allow(clippy::cast_sign_loss)]
228	#[allow(clippy::cast_possible_truncation)]

feroxfuzz 1.0.0-rc.8/src/mutators/wordlist_token.rs

89	#[allow(clippy::cast_possible_truncation)]
90	#[allow(clippy::cast_sign_loss)]
91	#[instrument(skip_all, fields(?self.keyword), level = "trace")]

feroxfuzz 1.0.0-rc.8/src/schedulers/ordered.rs

156	#[allow(clippy::cast_possible_truncation)]
157	#[allow(clippy::cast_sign_loss)]
158	pub fn new(state: SharedState) -> Result<Self, FeroxFuzzError> {

feroxfuzz 1.0.0-rc.8/src/schedulers/product.rs

265	#[allow(clippy::cast_possible_truncation)]
266	#[allow(clippy::cast_sign_loss)]
267	pub fn new<'a, I>(corpus_order: I, state: SharedState) -> Result<Self, FeroxFuzzError>

feroxfuzz 1.0.0-rc.8/src/schedulers/random.rs

169	#[allow(clippy::cast_possible_truncation)]
170	#[allow(clippy::cast_sign_loss)]
171	pub fn new(state: SharedState) -> Result<Self, FeroxFuzzError> {

ferrous-actions 0.1.0-beta.1/src/system/rng.rs

58	let random = random * ((1u64 << f64::MANTISSA_DIGITS) as f64);
59	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
60	let random = random as u64;

ffsvm 0.8.0/src/vectors.rs

95	{
96	#[allow(clippy::cast_sign_loss)]
97	fn from(vec: &Vec<T>) -> Self {

findminhs 2.1.0/src/lower_bound.rs

60	if rounded.is_finite() {
61	#[allow(clippy::cast_sign_loss)]
62	Some(rounded as usize)

fiona 0.1.0/src/ip/tcp.rs

351	#[allow(clippy::cast_sign_loss)]
352	unsafe {

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

31	.expect("Should always be able to decode timestamp because we just encoded it.");
32	#[allow(clippy::cast_sign_loss)]
33	let datetime = Utc.timestamp(timestamp.seconds, timestamp.nanos as u32);

fontfor 0.3.1/src/fc/font_set.rs

57	assert!(fs.nfont >= 0);
58	#[allow(clippy::cast_sign_loss)]
59	let fonts_count = fs.nfont as usize;

fontfor 0.3.1/src/preview/terminal/render/ascii.rs

51

    fn gray_to_char(&self, _up: u8, _left: u8, gray: u8, _right: u8, _down: u8) -> char {

52

        #[allow(clippy::cast_sign_loss)] // gray and multiplier both positive

53

        #[allow(clippy::cast_possible_truncation)] // result small then ramp's length(usize)

fontfor 0.3.1/src/preview/terminal/render/moon.rs

44	#[allow(clippy::cast_sign_loss)] // because `255 - u8` must be non-negative
45	#[allow(clippy::cast_possible_truncation)] // result small then MOON_CHARS's length

ftzz 1.2.0/src/core/file_contents.rs

71	#[inline]
72	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
73	fn create_file(

fyi_msg 0.10.6/src/msg/mod.rs

651	#[allow(clippy::cast_possible_truncation)] // Date pieces have known values.
652	#[allow(clippy::cast_sign_loss)] // Date pieces have known values.
653	/// # Set Timestamp.

gfret 2.1.0/src/gui/dialogs/mod.rs

311	/// struct into a struct which can be serialized using serde
312	#[allow(clippy::cast_sign_loss)]
313	#[allow(clippy::cast_possible_truncation)]

gfret 2.1.0/src/gui/mod.rs

176	/// which will be used by the backend to render the svg image.
177	#[allow(clippy::cast_sign_loss)]
178	fn get_specs(&self) -> Specs {
274	/// Populates an instance of Template from the gui
275	#[allow(clippy::cast_sign_loss)]
276	fn template_from_gui(&self) -> Template {

girt-display 2.2.0/src/utils.rs

71	// Copyright (c) 2015 Alexandre Bury - MIT License
72	#[allow(clippy::cast_sign_loss, clippy::integer_division)]
73	fn find_color(color_mode: ColorMode, color: Color) -> CrosstermColor {

girt-view 2.2.0/src/render_slice/mod.rs

126	clippy::cast_possible_truncation,
127	clippy::cast_sign_loss,
128	clippy::float_arithmetic

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

51	} else {
52	#[allow(clippy::cast_sign_loss)]
53	Ok(written as u64)

gurgle 0.5.0/src/config.rs

113	}
114	#[allow(clippy::cast_sign_loss)] // because times > 0
115	if times as u64 > self.config.max_roll_times {
117	}
118	#[allow(clippy::cast_sign_loss)] // because sided > 0
119	if sided as u64 > self.config.max_dice_sides {

gurgle 0.5.0/src/expr.rs

95	#[allow(clippy::cast_sign_loss)] // because times and sided can't be negative after check_dice
96	fn from_pair(pair: Pair<'_, Rule>, limit: &mut Limit<'_>) -> Result<Self, CompileError> {

h3o 0.3.0/src/coord/faceijk.rs

40	/// coordinate system of the base cell at that coordinates.
41	#[allow(clippy::cast_sign_loss)] // Safe because components values are in [0; 2].
42	pub fn base_cell_rotation(&self) -> Rotation {

h3o 0.3.0/src/coord/ijk.rs

236	// Cannot truncate thx to check above (unit vector).
237	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
238	let bits = (value.i << 2 \| value.j << 1 \| value.k) as u8;

h3o 0.3.0/src/geom/geometry/bbox.rs

103	// Truncate on purpose.
104	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
105	let estimate = estimate as usize;

h3o 0.3.0/src/geom/geometry/polygon.rs

361	// Truncate on purpose.
362	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
363	let estimate = dist_ceil as u64;

hash_arr_map 0.4.0/src/map.rs

1195	{
1196	#[allow(clippy::cast_sign_loss)]
1197	let num = unsafe { v.as_ptr().offset_from(self.hash.as_ptr()) } as usize;
1293	}
1294	#[allow(clippy::cast_sign_loss)]
1295	Some((

hashbrown 0.13.2/src/raw/sse2.rs

81	// upper 16-bits of the i32 are zeroed:
82	clippy::cast_sign_loss,
83	clippy::cast_possible_truncation
105	// upper 16-bits of the i32 are zeroed:
106	clippy::cast_sign_loss,
107	clippy::cast_possible_truncation

hashbrown_tstd 0.7.1/src/raw/sse2.rs

78	// upper 16-bits of the i32 are zeroed:
79	clippy::cast_sign_loss,
80	clippy::cast_possible_truncation
102	// upper 16-bits of the i32 are zeroed:
103	clippy::cast_sign_loss,
104	clippy::cast_possible_truncation

hdbconnect 0.24.0/src/conn/session_state.rs

25	for (id, value) in transaction_flags {
26	#[allow(clippy::cast_sign_loss)]
27	#[allow(clippy::cast_possible_truncation)]

hdbconnect 0.24.0/src/protocol/part.rs

393	#[allow(clippy::cast_sign_loss)]
394	fn parse_part_header(

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

20	-3 => vec.push(Self::Failure(None)),
21	#[allow(clippy::cast_sign_loss)]
22	i => vec.push(Self::RowsAffected(i as usize)),

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

137	#[allow(clippy::cast_sign_loss)]
138	fn parse_length_and_binary(rdr: &mut dyn std::io::Read) -> std::io::Result<Vec<u8>> {

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

25	util::skip_bytes(3, rdr)?; // B3 (filler)
26	#[allow(clippy::cast_sign_loss)]
27	let data = util::parse_bytes(chunk_length as usize, rdr)?; // B[chunk_length]

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

99	#[allow(clippy::cast_sign_loss)]
100	pub(crate) fn parse(

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

42	#[allow(clippy::cast_sign_loss)]
43	pub(crate) fn get_transactions(&self) -> Vec<XaTransactionId> {

hdbconnect 0.24.0/src/types_impl/daydate.rs

42	#[allow(clippy::cast_possible_truncation)]
43	#[allow(clippy::cast_sign_loss)]
44	pub(crate) fn as_ymd(&self) -> (i32, u32, u32) {

hdbconnect 0.24.0/src/types_impl/hdb_decimal.rs

51	#[allow(clippy::cast_possible_truncation)]
52	#[allow(clippy::cast_sign_loss)]
53	pub fn from_bigdecimal(bigdecimal: &BigDecimal) -> Result<Self, SerializationError> {

hdbconnect 0.24.0/src/types_impl/longdate.rs

51	#[allow(clippy::cast_precision_loss)]
52	#[allow(clippy::cast_sign_loss)]
53	pub(crate) fn as_ymd_hms_f(&self) -> (i32, u8, u8, u8, u8, u8, u32) {

headless_chrome 1.0.2/src/browser/tab/mod.rs

596	let multiplier = self.slow_motion_multiplier.read().unwrap();
597	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
598	let scaled_millis = millis * *multiplier as u64;

headless_chrome_fork 1.0.2/src/browser/tab/mod.rs

624	let multiplier = self.slow_motion_multiplier.read().unwrap();
625	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
626	let scaled_millis = millis * *multiplier as u64;

hebo 0.3.3/src/session/config.rs

48	#[allow(clippy::cast_possible_truncation)]
49	#[allow(clippy::cast_sign_loss)]
50	pub fn set_keep_alive(&mut self, keep_alive: u16) -> &mut Self {

heph-rt 0.4.1/src/shared/scheduler/inactive.rs

165	fn update_length(&self, n: isize) {
166	#[allow(clippy::cast_sign_loss)]
167	match n {

hexx 0.1.1/src/hex.rs

400	#[must_use]
401	#[allow(clippy::cast_sign_loss)]
402	/// Retrieves all [`Hex`] around `self` in a given `range` but ordered as successive rings,
422	#[must_use]
423	#[allow(clippy::cast_sign_loss)]
424	/// Retrieves all [`Hex`] around `self` in a given `range` but ordered as successive rings,

horde 0.1.1/src/raw/sse2.rs

85	// upper 16-bits of the i32 are zeroed:
86	clippy::cast_sign_loss,
87	clippy::cast_possible_truncation
109	// upper 16-bits of the i32 are zeroed:
110	clippy::cast_sign_loss,
111	clippy::cast_possible_truncation

hp203b 0.3.0/src/lib.rs

346	#[allow(clippy::cast_sign_loss)]
347	#[allow(clippy::cast_possible_truncation)]

hyraigne 0.1.4/src/sites/mangakakalot/site.rs

69	// Trim the chapters list to keep only the requested chapters.
70	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
71	let mut chapters = chapters

hyraigne 0.1.4/src/sites/webtoons/site.rs

100	// Trim the chapters list to keep only the requested chapters.
101	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
102	let mut chapters = chapters

hyraigne 0.1.4/src/sites/webtoonscan/site.rs

69	// Trim the chapters list to keep only the requested chapters.
70	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
71	let mut chapters = chapters

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

177	clippy::similar_names,
178	clippy::cast_sign_loss,
179	clippy::shadow_unrelated
637	fn post_init(&mut self, gl: &Context) {
638	#[allow(clippy::cast_sign_loss)]
639	unsafe {
644	fn pre_render(&mut self, gl: &Context, gl_version: GlVersion) {
645	#[allow(clippy::cast_sign_loss)]
646	unsafe {
695	fn post_render(&mut self, gl: &Context, _gl_version: GlVersion) {
696	#![allow(clippy::cast_sign_loss)]
697	unsafe {

inside-baseball 0.1.0/src/script/statements.rs

399	Ins::JumpIf(rel) => {
400	#[allow(clippy::cast_sign_loss)]
401	let target = decoder.pos().wrapping_add(rel as isize as usize);
406	Ins::JumpUnless(rel) => {
407	#[allow(clippy::cast_sign_loss)]
408	let target = decoder.pos().wrapping_add(rel as isize as usize);
412	Ins::Jump(rel) => {
413	#[allow(clippy::cast_sign_loss)]
414	let target = decoder.pos().wrapping_add(rel as isize as usize);

instance-chart 0.2.1/src/discovery.rs

61	{
62	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
63	let cluster_majority = (f32::from(full_size) * 0.5).ceil() as usize;

instant-glicko-2 0.1.0/src/engine.rs

495	// We won't have negative elapsed_periods. Truncation this is the wanted result.
496	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
497	let periods_to_close = elapsed_periods as u32;

iota-crypto 0.15.3/src/hashes/ternary/kerl/bigint/split_integer.rs

28

    #[allow(clippy::cast_possible_truncation)] // Truncation is used to remove the high part of the integer.

29

    #[allow(clippy::cast_sign_loss)] // Sign loss is expected as `Self::Low` represents the lower part of the integer.

30

    fn lo(self) -> Self::Low {

iota-crypto 0.15.3/src/hashes/ternary/kerl/bigint/u384/mod.rs

358	#[allow(clippy::cast_sign_loss)] // This is a slice of `UTrit`s, so `binary_trit` is always positive.
359	let new_extent = accumulator.add_digit_inplace(*binary_trit as u32);

iso_11649 0.1.2/src/lib.rs

304	fn gen_checksum(check_digits: &[i8]) -> (u8, [char; 2]) {
305	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
306	let checksum = u8::try_from(
330	fn is_valid(check_digits: &[i8]) -> bool {
331	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
332	let check = u8::try_from(
454	clippy::unreadable_literal,
455	clippy::cast_sign_loss,
456	clippy::cast_possible_truncation

iso7816-tlv 0.4.2/src/ber/tag.rs

313	type Error = TlvError;
314	#[allow(clippy::cast_sign_loss)]
315	fn try_from(v: i32) -> Result<Self> {
321	type Error = TlvError;
322	#[allow(clippy::cast_sign_loss)]
323	fn try_from(v: i16) -> Result<Self> {
329	type Error = TlvError;
330	#[allow(clippy::cast_sign_loss)]
331	fn try_from(v: i8) -> Result<Self> {

julia-set 0.1.0/src/cpu.rs

90	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
91	fn compute_row(&self, params: CpuParams, pixel_row: u32) -> Vec<u8> {

julia-set 0.1.0/src/transform.rs

98	#[inline]
99	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
100	fn transform_pixel(&self, pixel: Luma<u8>) -> Self::Output {
135	clippy::cast_possible_truncation,
136	clippy::cast_sign_loss
137	)]
261	clippy::cast_precision_loss,
262	clippy::cast_sign_loss
263	)]

k8-types 0.7.1/src/int_or_string.rs

66	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
67	Ok(Int32OrString::Int(v as i32))
73	{
74	#[allow(clippy::cast_sign_loss)]
75	{
84	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
85	Ok(Int32OrString::Int(v 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/source.rs

101	let sources: Vec<_> = sources.into_iter().collect();
102	#[allow(clippy::cast_sign_loss)] // sqrt of a positive number is always positive
103	let sprites_wide = (sources.len() as f32).sqrt() as usize;

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> {

lcat 0.7.11/src/ok.rs

90	fn from(rgb: &LinRgb) -> Self {
91	#[allow(clippy::cast_sign_loss)]
92	fn from_linear_srgb(x: f32) -> u8 {

leaky-bucket-lite 0.5.2/src/sync.rs

50	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
51	let refills_since =

leaky-bucket-lite 0.5.2/src/sync_threadsafe.rs

65	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
66	let refills_since =

leaky-bucket-lite 0.5.2/src/tokio.rs

57	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
58	let refills_since =

libafl 0.9.0/src/bolts/llmp.rs

1683	/// This dereferences msg, make sure to pass a proper pointer to it.
1684	#[allow(clippy::cast_sign_loss)]
1685	pub unsafe fn msg_to_offset(&self, msg: *const LlmpMsg) -> Result<u64, Error> {

libafl 0.9.0/src/bolts/shmem.rs

1055	let fd: i32 = id.to_string().parse().unwrap();
1056	#[allow(trivial_numeric_casts, clippy::cast_sign_loss)]
1057	if ioctl(fd, ASHMEM_GET_SIZE as _) as u32 as usize != map_size {
1121	#[allow(trivial_numeric_casts)]
1122	#[allow(clippy::cast_sign_loss)]
1123	let length = ioctl(fd, ASHMEM_GET_SIZE as _) as u32;

libafl 0.9.0/src/executors/timeout.rs

49	impl Debug for Timeval {
50	#[allow(clippy::cast_sign_loss)]
51	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
272	{
273	#[allow(clippy::cast_sign_loss)]
274	fn run_target(

libafl 0.9.0/src/monitors/mod.rs

141	/// Get the calculated executions per second for this client
142	#[allow(clippy::cast_precision_loss, clippy::cast_sign_loss)]
143	#[cfg(feature = "afl_exec_sec")]
172	/// Get the calculated executions per second for this client
173	#[allow(clippy::cast_precision_loss, clippy::cast_sign_loss)]
174	#[cfg(not(feature = "afl_exec_sec"))]
248	/// Executions per second
249	#[allow(clippy::cast_sign_loss)]
250	#[inline]

libafl 0.9.0/src/monitors/prometheus.rs

98	#[allow(clippy::cast_sign_loss)]
99	fn display(&mut self, event_msg: String, sender_id: u32) {

libafl 0.9.0/src/monitors/tui/mod.rs

260	#[allow(clippy::cast_sign_loss)]
261	fn display(&mut self, event_msg: String, sender_id: u32) {

libafl_frida 0.9.0/src/alloc.rs

116	#[allow(clippy::cast_sign_loss)]
117	let page_size = ret as usize;

libafl_frida 0.9.0/src/asan/asan_rt.rs

917	#[cfg(target_arch = "x86_64")]
918	#[allow(clippy::cast_sign_loss)]
919	#[allow(clippy::too_many_lines)]
1073	#[cfg(target_arch = "aarch64")]
1074	#[allow(clippy::cast_sign_loss)] // for displacement
1075	#[allow(clippy::too_many_lines)]
2595	// emit add extended register: https://developer.arm.com/documentation/ddi0602/latest/Base-Instructions/ADD--extended-register---Add--extended-register--
2596	#[allow(clippy::cast_sign_loss)]
2597	writer.put_bytes(
2601	} else if shift_encoding != -1 {
2602	#[allow(clippy::cast_sign_loss)]
2603	writer.put_bytes(
2622	if displacement > -4096 {
2623	#[allow(clippy::cast_sign_loss)]
2624	let displacement = displacement.unsigned_abs();

libafl_frida 0.9.0/src/cmplog_rt.rs

344	//add displacement
345	#[allow(clippy::cast_sign_loss)]
346	writer.put_add_reg_reg_imm(
563	// add displacement
564	#[allow(clippy::cast_sign_loss)]
565	writer.put_add_reg_reg_imm(
629	// cbz marked as special since there is only 1 operand
630	#[allow(clippy::cast_sign_loss)]
631	let special_case = matches!(instr.mnemonic().unwrap(), "cbz" \| "cbnz");
633	#[allow(clippy::cast_sign_loss, clippy::similar_names)]
634	let operand1 = if let Arm64Operand(arm64operand) = operands.first().unwrap() {

libafl_qemu 0.9.0/src/asan.rs

187	#[must_use]
188	#[allow(clippy::cast_sign_loss)]
189	pub fn is_invalid_access(emu: &Emulator, addr: GuestAddr, n: usize) -> bool {
239	#[inline]
240	#[allow(clippy::cast_sign_loss)]
241	pub fn poison(&mut self, emu: &Emulator, addr: GuestAddr, n: usize, poison_byte: i8) -> bool {
285	#[allow(clippy::must_use_candidate)]
286	#[allow(clippy::cast_sign_loss)]
287	pub fn unpoison(emu: &Emulator, addr: GuestAddr, n: usize) -> bool {

libafl_qemu 0.9.0/src/emu.rs

493	#[must_use]
494	#[allow(clippy::cast_sign_loss)]
495	pub fn index(&self) -> usize {
733	#[allow(clippy::cast_possible_wrap)]
734	#[allow(clippy::cast_sign_loss)]
735	pub fn num_cpus(&self) -> usize {
912	#[cfg(emulation_mode = "usermode")]
913	#[allow(clippy::cast_sign_loss)]
914	fn mmap(

libafl_targets 0.9.0/src/sancov_8bit.rs

10	#[no_mangle]
11	#[allow(clippy::cast_sign_loss)]
12	#[allow(clippy::not_unsafe_ptr_arg_deref)]

libpd-rs 0.1.9/src/array.rs

179	// We check this manually in the predicate.
180	#[allow(clippy::cast_sign_loss)]
181	if destination_write_offset + source_read_amount
285	// We check this manually in the predicate.
286	#[allow(clippy::cast_sign_loss)]
287	if destination_write_offset + source_read_amount

libpd-rs 0.1.9/src/receive.rs

346	// It is practically impossible that this list will have a negative size or a size of millions so this is safe.
347	#[allow(clippy::cast_sign_loss)]
348	let atom_list = unsafe { std::slice::from_raw_parts(atom_list, list_length as usize) };
416	// It is practically impossible that this list will have a negative size or a size of millions so this is safe.
417	#[allow(clippy::cast_sign_loss)]
418	let atom_list = unsafe { std::slice::from_raw_parts(atom_list, list_length as usize) };

light-curve-feature 0.5.2/src/sorted_array.rs

63	} else {
64	#[allow(clippy::cast_sign_loss)]
65	let i = h_floor as usize;

lilv 0.2.1/src/world.rs

286	/// The number of files parsed.
287	#[allow(clippy::cast_sign_loss)]
288	#[must_use]

linux-kcapi 0.1.1/src/internal.rs

12	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
13	fn logical_cpus() -> usize {
38	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
39	fn get_page_size() -> usize {

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

82	// This is intentional.
83	#[allow(clippy::cast_sign_loss)]
84	let disk_cur_size = {
190	let mut size_freed = 0;
191	#[allow(clippy::cast_sign_loss)]
192	for item in items {

mask-text 0.1.2/src/mask.rs

49	fn with_percentage(text: String, percentage: u8, min_chars: usize, mask_char: String) -> String {
50	#[allow(clippy::cast_sign_loss)]
51	#[allow(clippy::cast_possible_truncation)]

mdbook-pdf-headless_chrome 0.1.2/src/browser/tab/mod.rs

564	let multiplier = self.slow_motion_multiplier.read().unwrap();
565	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
566	let scaled_millis = millis * *multiplier as u64;

medea 0.2.0/src/signalling/peers/metrics/quality_meter.rs

226	) {
227	#[allow(clippy::cast_sign_loss)]
228	let packets_lost =

medea-client-api-proto 0.3.0/src/stats.rs

1505	impl From<HighResTimeStamp> for SystemTime {
1506	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
1507	#[inline]

medea-jason 0.2.0/src/media/constraints.rs

1052	// that such casts are safe.
1053	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
1054	fn satisfies(this: Option<Self>, track: &sys::MediaStreamTrack) -> bool {

meiosis 0.1.0/src/algorithm/fitness.rs

808	// all values in this calculation are positive
809	#[allow(clippy::cast_sign_loss, clippy::as_conversions)]
810	let offspring =

meiosis 0.1.0/src/operators/mutation/random/multi.rs

13	// We verify `rate` to be positive, so this can never happen.
14	#[allow(clippy::cast_sign_loss)]
15	// This is intended and may be replaced by a safer way in the future.

meiosis 0.1.0/src/operators/selection/truncate.rs

77	// this is fine as the original value converted to f64 was positive anyway
78	#[allow(clippy::cast_sign_loss)]
79	// this is intended

meminterval 0.3.0/src/node.rs

40	// _max_height is at least -1, so +1 is a least 0 - and it can never be higher than usize
41	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
42	pub fn update_height(&mut self) {

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 {
53	// Once again i64 vs u64 for a timestamp
54	#[allow(clippy::cast_sign_loss)]
55	Self {
77	// interface.
78	#[allow(clippy::cast_sign_loss, clippy::cast_possible_wrap)]
79	Self {

moneta 0.3.2/src/exchange.rs

79	#[allow(clippy::cast_possible_truncation)]
80	#[allow(clippy::cast_sign_loss)]
81	Self {

moving-least-squares-image 0.1.1/src/interpolation.rs

109	#[allow(clippy::cast_possible_truncation)]
110	#[allow(clippy::cast_sign_loss)]
111	#[allow(clippy::cast_precision_loss)]

nats 0.23.1/src/fault_injection.rs

49	#[allow(clippy::cast_possible_truncation)]
50	#[allow(clippy::cast_sign_loss)]
51	thread::sleep(Duration::from_millis(duration));

natsio 0.4.1/src/fault_injection.rs

38	#[allow(clippy::cast_possible_truncation)]
39	#[allow(clippy::cast_sign_loss)]
40	thread::sleep(Duration::from_millis(duration));

nc 0.8.13/src/platform/darwin-types/sys/signal.rs

88	pub const SIG_HOLD: sighandler_t = 5;
89	#[allow(clippy::cast_sign_loss)]
90	pub const SIG_ERR: sighandler_t = -1_isize as sighandler_t;

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

119	/// Error return from `mmap()`
120	#[allow(clippy::cast_sign_loss)]
121	pub const MAP_FAILED: usize = -1_isize as usize;

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

86	pub const SIG_IGN: sighandler_t = 1;
87	#[allow(clippy::cast_sign_loss)]
88	pub const SIG_ERR: sighandler_t = -1_isize as sighandler_t;

ndarray-stats 0.5.1/src/histogram/strategies.rs

274	// casting the rounded square root from `f64` to `usize` is safe
275	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
276	let n_bins = (n_elems as f64).sqrt().round() as usize;
320	// casting the rounded cube root from `f64` to `usize` is safe
321	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
322	let n_bins = (2. * (n_elems as f64).powf(1. / 3.)).round() as usize;
366	// casting the rounded base-2 log from `f64` to `usize` is safe
367	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
368	let n_bins = (n_elems as f64).log2().round() as usize + 1;

nebari 0.5.4/src/transaction/log.rs

627	clippy::cast_possible_truncation,
628	clippy::cast_sign_loss
629	)]

nebari 0.5.4/src/tree/mod.rs

1652	clippy::cast_possible_truncation,
1653	clippy::cast_sign_loss
1654	)]

neodyn_xc 0.4.0/src/format.rs

152	/// Returns the encoded number as a single byte and `MAJOR_TYPE_SMALL_INT`.
153	#[allow(clippy::cast_sign_loss)]
154	#[must_use]

neodyn_xc 0.4.0/src/ser/binary.rs

83	/// of this crate will always be to use 2's complement.
84	#[allow(clippy::cast_sign_loss)]
85	fn encode_int(x: i64, buf: &mut [u8; 8]) -> (u8, &[u8]) {

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

148	#[allow(clippy::cast_possible_truncation)]
149	#[allow(clippy::cast_sign_loss)]
150	fn compatible_list_by_resolution(

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

183	#[allow(clippy::too_many_lines)]
184	#[allow(clippy::cast_sign_loss)]
185	fn compatible_list_by_resolution(

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

170	/// If the frame is failed to be read, this will error.
171	#[allow(clippy::cast_sign_loss)]
172	pub fn raw_frame_vec(&mut self) -> Result<Cow<[u8]>, NokhwaError> {
243	/// If the resolution is failed to be read (e.g. invalid or not supported), this will error.
244	#[allow(clippy::cast_sign_loss)]
245	#[allow(clippy::cast_possible_truncation)]
272	/// If the framerate is failed to be read (e.g. invalid or not supported), this will error.
273	#[allow(clippy::cast_sign_loss)]
274	#[allow(clippy::cast_possible_truncation)]

nokhwa 0.10.3/src/js_camera.rs

2006

    /// If the camera fails to attach to the created `<video>`, this will error.

2007

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

2008

    pub fn measure_resolution(&mut self) -> Result<(), NokhwaError> {

nokhwa-bindings-windows 0.4.0/src/lib.rs

382	#[allow(clippy::cast_sign_loss)]
383	fn kcc_to_i32(kcc: KnownCameraControl) -> Option<MFControlId> {
940	#[allow(clippy::cast_sign_loss)]
941	pub fn format_refreshed(&mut self) -> Result<CameraFormat, NokhwaError> {

nokhwa-core 0.1.0/src/pixel_format.rs

215	#[allow(clippy::cast_possible_truncation)]
216	#[allow(clippy::cast_sign_loss)]
217	#[inline]

nokhwa-core 0.1.0/src/types.rs

1709	#[allow(clippy::cast_possible_truncation)]
1710	#[allow(clippy::cast_sign_loss)]
1711	#[must_use]

nonogrid 0.7.3/src/solver/line.rs

104	#[allow(clippy::cast_possible_wrap)]
105	#[allow(clippy::cast_sign_loss)]
106	impl<B> DynamicSolver<B>

oc-wasm-opencomputers 0.10.2/src/keyboard.rs

102	// Unicode code points are 0≤N≤0x10FFFF.
103	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
104	let character = d.f64()? as u32;
120	// Keycodes are small nonnegative numbers.
121	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
122	let keycode = d.f64()? as u32;

oc-wasm-opencomputers 0.10.2/src/modem.rs

690	// OpenComputers is like that.
691	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
692	let port = d.f64()? as u16;

oc-wasm-opencomputers 0.10.2/src/screen.rs

120	#[allow(clippy::cast_possible_truncation)]
121	#[allow(clippy::cast_sign_loss)]
122	Ok(Dimension {

oc-wasm-safe 0.4.0/src/component.rs

1015	// Cast from isize to usize is safe because the match arm verifies that x ≥ 0.
1016	#[allow(clippy::cast_sign_loss)]
1017	Ok(value as usize)

oc-wasm-safe 0.4.0/src/error.rs

101	// Cast from isize to usize is safe because the match arm verifies that x ≥ 0.
102	#[allow(clippy::cast_sign_loss)]
103	Ok(value as usize)

off-rs 1.0.0/src/geometry/color.rs

78	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
79	impl TryFrom<Color> for Vec<u8> {

ord 0.4.2/src/fee_rate.rs

27	#[allow(clippy::cast_possible_truncation)]
28	#[allow(clippy::cast_sign_loss)]
29	Amount::from_sat((self.0 * vsize as f64).round() as u64)

ord 0.4.2/src/sat.rs

183	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
184	Ok(Sat(n as u64))

ord 0.4.2/src/subcommand/wallet/inscribe.rs

374	#[allow(clippy::cast_possible_truncation)]
375	#[allow(clippy::cast_sign_loss)]
376	let fee = Amount::from_sat((1.0 * (reveal_tx.vsize() as f64)).ceil() as u64);

owfs 0.0.8/src/lib.rs

87	let len_i: isize = c_val.as_bytes_with_nul().len().try_into()?;
88	#[allow(clippy::cast_sign_loss)]
89	let res = owcapi::OW_put(c_path.as_ptr(), c_val.as_ptr(), len_i as usize);

oxsdatatypes 0.1.0/src/date_time.rs

1458	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
1459	#[inline]
1528	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
1529	#[inline]
1537	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
1538	#[inline]

oxsdatatypes 0.1.0/src/parser.rs

452	// [61] secondFrag ::= ([0-5] digit) ('.' digit+)?
453	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
454	fn second_frag(input: &str) -> XsdResult<'_, Decimal> {

pacaptr 0.17.1/src/error.rs

98	fn report(self) -> ExitCode {
99	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
100	match self.0 {

pam-client 0.5.0/src/context.rs

339	#[allow(clippy::cast_sign_loss)]
340	Ok((

pam-client 0.5.0/src/ffi.rs

51	#[inline]
52	#[allow(clippy::cast_sign_loss)]
53	fn msg_to_slice(msg: &mut const PamMessage, num_msg: c_int) -> &[&PamMessage] {
68	#[inline]
69	#[allow(clippy::cast_sign_loss)]
70	fn msg_to_slice(msg: &mut const PamMessage, num_msg: c_int) -> &'static [PamMessage] {
127	/// and the PAM modules play by the rules.
128	#[allow(clippy::cast_sign_loss)]
129	unsafe fn msg_content_to_bin(msg: &*const c_char) -> (u8, &[u8]) {

pam-client 0.5.0/src/resp_buf.rs

39	1..=isize::MAX => {
40	#[allow(clippy::cast_sign_loss)]
41	let buffer = CBox::<PamResponse>::try_new_zeroed_slice(len as usize)?;

pathfinding 4.2.1/src/utils.rs

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

pdbtbx 0.10.1/src/error/context.rs

147	#[allow(
148	clippy::cast_sign_loss,
149	clippy::cast_precision_loss,

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

575	clippy::cast_possible_truncation,
576	clippy::cast_sign_loss,
577	clippy::float_cmp

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

9	clippy::cast_possible_wrap,
10	clippy::cast_sign_loss
11	)]

pineappl 0.5.9/src/convert.rs

3	#[allow(clippy::cast_possible_truncation)]
4	#[allow(clippy::cast_sign_loss)]
5	pub fn usize_from_f64(x: f64) -> usize {

pixel_engine 0.8.0/src/engine/logic.rs

161	//events.push(Events::MouseMove(x, y));
162	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
163	{

pixel_engine_console 0.1.0/src/lib.rs

367	clippy::too_many_lines,
368	clippy::cast_sign_loss,
369	clippy::cast_possible_truncation

pixel_engine_draw 0.7.0/src/graphics.rs

1	#![allow(
2	clippy::cast_sign_loss,
3	clippy::cast_precision_loss,
171	/// This will return an error if an subsprite already exists and that it overlaps
172	#[allow(clippy::cast_sign_loss)]
173	pub fn create_sub_sprite(

pot 1.0.2/src/format.rs

525	/// Returns the contained value as an u8, or an error if the value is unable to fit.
526	#[allow(clippy::cast_sign_loss)]
527	pub const fn as_u8(&self) -> Result<u8, Error> {
565	/// Returns the contained value as an u16, or an error if the value is unable to fit.
566	#[allow(clippy::cast_sign_loss)]
567	pub const fn as_u16(&self) -> Result<u16, Error> {
618	/// Returns the contained value as an u32, or an error if the value is unable to fit.
619	#[allow(clippy::cast_sign_loss)]
620	pub const fn as_u32(&self) -> Result<u32, Error> {
699	/// Returns the contained value as an u64, or an error if the value is unable to fit.
700	#[allow(clippy::cast_sign_loss)]
701	pub const fn as_u64(&self) -> Result<u64, Error> {
739	/// Returns the contained value as an u64, or an error if the value is unable to fit.
740	#[allow(clippy::cast_sign_loss)]
741	pub const fn as_u128(&self) -> Result<u128, Error> {

psrt 0.1.30/src/cli.rs

212	#[allow(clippy::cast_sign_loss)]
213	#[allow(clippy::cast_possible_truncation)]

psrt 0.1.30/src/pubsub.rs

277	#[allow(clippy::cast_sign_loss)]
278	/// # Panics

py-marshal 0.3.3/src/lib.rs

488	};
489	#[allow(clippy::cast_sign_loss)]
490	let size = n.wrapping_abs() as u32;

py27-marshal 0.3.4/src/read.rs

105	};
106	#[allow(clippy::cast_sign_loss)]
107	let size = n.wrapping_abs() as u32;

quanta 0.10.1/src/clocks/monotonic/unix.rs

4	impl Monotonic {
5	#[allow(clippy::cast_sign_loss)]
6	pub fn now(self) -> u64 {

ranged_integers 0.7.0/src/lib.rs

569	#[allow(clippy::cast_sign_loss)]
570	impl<T, const N: usize> core::ops::Index<Ranged<0, {N as i128 - 1}>> for [T; N]
581	#[allow(clippy::cast_sign_loss)]
582	impl<T, const N: usize> core::ops::IndexMut<Ranged<0, {N as i128 - 1}>> for [T; N]
592	#[allow(clippy::cast_sign_loss)]
593	impl<T, const N: usize, const MIN: irang, const MAX: irang>
607	}
608	#[allow(clippy::cast_sign_loss)]
609	impl<T, const N: usize, const MIN: irang, const MAX: irang>

ranged_type 0.1.0/src/arith_helpers.rs

    match value >= 0 {
        #[allow(clippy::cast_sign_loss)]
        true => value as u32 | I32_SIGN_BIT,
        #[allow(clippy::cast_sign_loss)]
        false => (value - i32::min_value()) as u32,

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

16	true => {
17	#[allow(clippy::cast_sign_loss)]
18	let u_rhs = rhs 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 {

ranges 0.3.3/src/domain/i128.rs

50	#[allow(clippy::cast_sign_loss)]
51	let big = (big ^ Self::MIN) as u128;
52	#[allow(clippy::cast_sign_loss)]
53	let small = (small ^ Self::MIN) as u128;

ranges 0.3.3/src/domain/i16.rs

50	#[allow(clippy::cast_sign_loss)]
51	let big = (big ^ Self::MIN) as u16;
52	#[allow(clippy::cast_sign_loss)]
53	let small = (small ^ Self::MIN) as u16;

ranges 0.3.3/src/domain/i32.rs

50	#[allow(clippy::cast_sign_loss)]
51	let big = (big ^ Self::MIN) as u32;
52	#[allow(clippy::cast_sign_loss)]
53	let small = (small ^ Self::MIN) as u32;

ranges 0.3.3/src/domain/i64.rs

50	#[allow(clippy::cast_sign_loss)]
51	let big = (big ^ Self::MIN) as u64;
52	#[allow(clippy::cast_sign_loss)]
53	let small = (small ^ Self::MIN) as u64;

ranges 0.3.3/src/domain/i8.rs

50	#[allow(clippy::cast_sign_loss)]
51	let big = (big ^ Self::MIN) as u8;
52	#[allow(clippy::cast_sign_loss)]
53	let small = (small ^ Self::MIN) as u8;

readstor 0.5.0/src/lib/models/datetime.rs

59	/// <https://www.epochconverter.com/coredata>
60	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
61	impl From<f64> for DateTimeUtc {

reddit-rs 0.1.1/src/utils.rs

77	if v.fract() == 0.0 && v > 0.0 {
78	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // checked above
79	self.visit_u64(v as u64)
123	if v.fract() == 0.0 && v > 0.0 {
124	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // checked above
125	self.visit_u64(v as u64)

relearn 0.3.1/src/agents/testing.rs

41	#[allow(clippy::cast_possible_truncation)]
42	#[allow(clippy::cast_sign_loss)]
43	pub fn eval_deterministic_bandit<T>(actor: T, env: &DeterministicBandit, threshold: f64)

relearn 0.3.1/src/spaces/index.rs

379	#[allow(clippy::cast_possible_truncation)]
380	#[allow(clippy::cast_sign_loss)] // negative f64 casts to 0.0 as desired
381	fn bernoulli_confidence_interval(p: f64, n: u64) -> RangeInclusive<u64> {

relearn 0.3.1/src/torch/packed.rs

278	/// If the type of `discount` does not match the tensor data type.
279	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
280	pub fn discounted_cumsum_from_end<T>(&self, discount: T) -> Self

relearn 0.3.1/src/utils/iter/rand.rs

144	#[allow(clippy::cast_possible_truncation)]
145	#[allow(clippy::cast_sign_loss)] // negative f64 casts to 0.0 as desired
146	fn bernoulli_confidence_interval(p: f64, n: u64) -> RangeInclusive<u64> {

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> {

rhai 1.12.0/src/eval/chaining.rs

281	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
282	let offset = index as usize;

rhai 1.12.0/src/eval/target.rs

18	#[allow(
19	clippy::cast_sign_loss,
20	clippy::absurd_extreme_comparisons,
55	#[allow(
56	clippy::cast_sign_loss,
57	clippy::cast_possible_truncation,
326	#[allow(clippy::cast_sign_loss)]
327	{

rhai 1.12.0/src/func/call.rs

601	if (0..=crate::MAX_USIZE_INT).contains(&num_params) {
602	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
603	let hash_script =
1157	return Ok(if (0..=crate::MAX_USIZE_INT).contains(&num_params) {
1158	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
1159	let hash_script = calc_fn_hash(None, &fn_name, num_params as usize);

rhai 1.12.0/src/optimizer.rs

930	#[cfg(not(feature = "no_index"))]
931	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
932	Expr::Index(x, ..) if !_chaining => match (&mut x.lhs, &mut x.rhs) {

rhai 1.12.0/src/packages/array_basic.rs

227	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
228	let len = len.min(MAX_USIZE_INT) as usize;
347	if !array.is_empty() {
348	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
349	let len = len.min(MAX_USIZE_INT) as usize;
381	if !array.is_empty() {
382	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
383	let len = len.min(MAX_USIZE_INT) as usize;

rhymuproc 1.1.2/bin/mock_subprocess.rs

112	}
113	#[allow(clippy::cast_sign_loss)]
114	let mut fds = vec![
129	}
130	#[allow(clippy::cast_sign_loss)]
131	fds.truncate(buffer_size as usize / std::mem::size_of::<proc_fdinfo>());

rhymuproc 1.1.2/src/macos.rs

345	}
346	#[allow(clippy::cast_sign_loss)]
347	let mut pids = vec![0; buffer_size as usize];
355	};
356	#[allow(clippy::cast_sign_loss)]
357	pids.truncate(buffer_size as usize);
366	};
367	#[allow(clippy::cast_sign_loss)]
368	name_chars.truncate(buffer_size as usize);
404	#[allow(clippy::cast_possible_truncation)]
405	#[allow(clippy::cast_sign_loss)]
406	Some(
423	}
424	#[allow(clippy::cast_sign_loss)]
425	let mut fds = vec![

rhymuproc 1.1.2/src/unix.rs

91	unsafe { libc::close(pipe_ends[0]) };
92	#[allow(clippy::cast_sign_loss)]
93	if read_amount as usize == std::mem::size_of::<libc::c_uint>() {

ril 0.9.0/src/pixel.rs

1412	fn from(Rgb { r, g, b }: Rgb) -> Self {
1413	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
1414	Self(f32::from(b).mul_add(0.114, f32::from(r).mul_add(0.299, f32::from(g) * 0.587)) as u8)

rio 0.9.4/src/histogram.rs

168	// inaccurate for values closer to 0 than +/- 0.51 or +/- math.Inf.
169	#[allow(clippy::cast_sign_loss)]
170	#[allow(clippy::cast_possible_truncation)]

rl_ball_sym 2.5.2/src/simulation/ball.rs

210	// We are making sure that the minimum possible value is 0 so no sign loss will occur
211	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
212	self.get_ball_prediction_struct_for_slices(game, (time / Self::SIMULATION_DT).ceil() as usize)
268	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
269	let predicted_slices = (REQUESTED_TIME / Ball::SIMULATION_DT).ceil().max(0.) as usize;

rl_ball_sym 2.5.2/src/simulation/morton.rs

48	// We have offset the values so they're all greater than 0
49	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
50	(Self::expand3(u.x as u32) \| Self::expand3(u.y as u32) << 1 \| Self::expand3(u.z as u32) << 2)
55	mod test {
56	#![allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]

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 {
37	// It is safe even if the return value is wrong.
38	#[allow(clippy::cast_sign_loss)]
39	unsafe {

rmodbus 0.6.4/src/lib.rs

117	#[allow(clippy::cast_possible_truncation)]
118	#[allow(clippy::cast_sign_loss)]
119	fn calc_lrc(frame: &[u8], data_length: u8) -> u8 {

rpds 0.12.0/src/vector/mod.rs

694	fn current_node(&self) -> &'a Node<T, P> {
695	#[allow(clippy::cast_sign_loss)]
696	match self.node {
703	fn current_elem(&self) -> &'a SharedPointer<T, P> {
704	#[allow(clippy::cast_sign_loss)]
705	match self.node {
713	fn advance(&mut self, backwards: bool) -> bool {
714	#[allow(clippy::cast_sign_loss)]
715	if backwards {

rsa-solver 0.1.0/src/lib.rs

192	#[allow(clippy::cast_sign_loss)]
193	#[inline]
198	#[allow(clippy::cast_sign_loss)]
199	#[inline]

ruint 1.7.0/src/add.rs

103	#[allow(clippy::cast_possible_truncation)] // Intentional
104	#[allow(clippy::cast_sign_loss)] // Intentional
105	for (lhs, rhs) in self.limbs.iter_mut().zip(rhs.limbs.into_iter()) {

ruint 1.7.0/src/algorithms/mul_redc.rs

60	#[allow(clippy::cast_possible_truncation)] // Intentional
61	#[allow(clippy::cast_sign_loss)] // Intentional
62	for (r, m) in zip(result.iter_mut(), m.iter().copied()) {

ruint 1.7.0/src/pow.rs

131	#[allow(clippy::cast_possible_truncation)] // exp <= BITS <= usize::MAX.
132	#[allow(clippy::cast_sign_loss)] // exp >= 0.
133	let shift = exp.trunc() as usize;
139	#[allow(clippy::cast_possible_truncation)] // fract < 1.0
140	#[allow(clippy::cast_sign_loss)] // fract >= 0.
141	let bits = (fract.exp2() * EXP2_63) as u64;

ruint 1.7.0/src/root.rs

47

        #[allow(clippy::cast_precision_loss)] // Approximation is good enough.

48

        #[allow(clippy::cast_sign_loss)] // Result should be positive.

49

        let mut result = Self::approx_pow2(self.approx_log2() / degree as f64).unwrap();

ruint 1.7.0/src/support/postgres.rs

266	let raw = &raw[8..];
267	#[allow(clippy::cast_sign_loss)] // Signs are checked
268	if digits < 0
286	}
287	#[allow(clippy::cast_sign_loss)] // Signs are checked
288	Some(digit as u64)
289	});
290	#[allow(clippy::cast_sign_loss)]
291	// Expression can not be negative due to checks above

rusty-battery 2.0.1/src/battery.rs

55	/// Refresh and return battery percentage.
56	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
57	fn refresh_percentage(&mut self) -> u8 {
168	/// Return current battery percentage of the given `battery::Battery` device.
169	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
170	fn fetch_percentage(device: &battery::Battery) -> u8 {

rustyline 10.1.1/src/keymap.rs

1101	#[allow(clippy::cast_sign_loss)]
1102	fn emacs_num_args(&mut self) -> (RepeatCount, bool) {
1115	#[allow(clippy::cast_sign_loss)]
1116	fn vi_num_args(&mut self) -> RepeatCount {

rustyline 10.1.1/src/tty/unix.rs

146	} else {
147	#[allow(clippy::cast_sign_loss)]
148	return Ok(res as usize);

rustyline-with-hint-fix 10.0.4/src/keymap.rs

1101	#[allow(clippy::cast_sign_loss)]
1102	fn emacs_num_args(&mut self) -> (RepeatCount, bool) {
1115	#[allow(clippy::cast_sign_loss)]
1116	fn vi_num_args(&mut self) -> RepeatCount {

rustyline-with-hint-fix 10.0.4/src/tty/unix.rs

146	} else {
147	#[allow(clippy::cast_sign_loss)]
148	return Ok(res as usize);

sampitor 0.0.2/src/view/chart.rs

62	// possible.
63	#[allow(clippy::cast_sign_loss)]
64	let index = channels * (*inner_index as usize) + outer_index;

seaslug 0.0.0/src/debug_delay.rs

68	#[allow(clippy::cast_possible_truncation)]
69	#[allow(clippy::cast_sign_loss)]
70	thread::sleep(Duration::from_micros(u64::from(duration)));

seaslug 0.0.0/src/histogram.rs

33	#![allow(clippy::cast_possible_truncation)]
34	#![allow(clippy::cast_sign_loss)]
176	// inaccurate for values closer to 0 than +/- 0.51 or +/- math.Inf.
177	#[allow(clippy::cast_sign_loss)]
178	#[allow(clippy::cast_possible_truncation)]

serde_yaml 0.9.17/src/number.rs

52	#[inline]
53	#[allow(clippy::cast_sign_loss)]
54	pub fn is_i64(&self) -> bool {

serde_yaml_with_quirks 0.8.24/src/number.rs

54	#[inline]
55	#[allow(clippy::cast_sign_loss)]
56	pub fn is_i64(&self) -> bool {

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

61	#[cfg_attr(not(feature = "no-inline"), inline(always))]
62	#[allow(clippy::cast_sign_loss)]
63	fn compute_quote_mask(quote_bits: u64) -> u64 {
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 {
88	#[cfg_attr(not(feature = "no-inline"), inline(always))]
89	#[allow(clippy::cast_sign_loss)]
90	fn unsigned_lteq_against_input(&self, maxval: __m256i) -> u64 {
100	#[cfg_attr(not(feature = "no-inline"), inline(always))]
101	#[allow(clippy::cast_sign_loss)]
102	fn find_whitespace_and_structurals(&self, whitespace: &mut u64, structurals: &mut u64) {

simd-json 0.7.0/src/charutils.rs

52	#[cfg_attr(not(feature = "no-inline"), inline)]
53	#[allow(clippy::cast_sign_loss)]
54	pub fn hex_to_u32_nocheck(src: &[u8]) -> u32 {

simd-json 0.7.0/src/lib.rs

286	#[cfg_attr(not(feature = "no-inline"), inline(always))]
287	#[allow(overflowing_literals, clippy::cast_sign_loss)]
288	fn find_quote_mask_and_bits(

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

108	#[cfg_attr(not(feature = "no-inline"), inline(always))]
109	#[allow(clippy::cast_sign_loss)]
110	fn find_whitespace_and_structurals(&self, whitespace: &mut u64, structurals: &mut u64) {

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

75	#[allow(
76	clippy::cast_sign_loss,
77	clippy::cast_possible_wrap,
356	clippy::cast_possible_truncation,
357	clippy::cast_sign_loss,
358	clippy::cast_precision_loss,

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

275	#[allow(
276	clippy::cast_sign_loss,
277	clippy::cast_possible_truncation,

sled 0.34.7/src/debug_delay.rs

68	#[allow(clippy::cast_possible_truncation)]
69	#[allow(clippy::cast_sign_loss)]
70	thread::sleep(Duration::from_micros(u64::from(duration)));

sled 0.34.7/src/histogram.rs

176	// inaccurate for values closer to 0 than +/- 0.51 or +/- math.Inf.
177	#[allow(clippy::cast_sign_loss)]
178	#[allow(clippy::cast_possible_truncation)]

socketstat 0.1.0/src/mac.rs

48	};
49	#[allow(clippy::cast_sign_loss)]
50	let socket_info = if len >= 0

sparkle-cache 0.14.1/src/model/message.rs

94	/// Create a cached embed from a given embed and message ID
95	#[allow(clippy::cast_sign_loss, clippy::as_conversions)]
96	#[must_use]

ssdcg 0.6.0/src/main.rs

96	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
97	fn script_splitn(s: &str, n: INT, pattern: &str) -> Vec<Dynamic> {
103	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
104	fn script_rsplitn(s: &str, n: INT, pattern: &str) -> Vec<Dynamic> {
166	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
167	fn script_require(arr: &Array, n: INT) -> ScriptResult<bool> {
268	engine.register_fn("to_string", \|this: &mut Import\| this.path.clone());
269	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
270	engine.register_fn("NL", \|count: i64\| "\n".repeat(count as usize));
271	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
272	engine.register_fn("IND", move \|count: i64\| indent.repeat(count as usize));

stateroom-wasm-host 0.2.6/src/wasm_host.rs

149	) -> Result<i32> {
150	#[allow(clippy::cast_sign_loss)]
151	let i: u32 = {

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

280	#[inline(always)]
281	#[allow(clippy::inline_always, clippy::cast_sign_loss)]
282	pub fn u128_from_i128(i: i128) -> u128 {

store-interval-tree 0.4.0/src/node.rs

63	// _max_height is at least -1, so +1 is a least 0 - and it can never be higher than usize
64	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
65	pub fn update_height(&mut self) {

streaming_algorithms 0.3.0/src/lib.rs

69	clippy::cast_possible_truncation,
70	clippy::cast_sign_loss,
71	clippy::cast_precision_loss,
80	clippy::cast_possible_truncation,
81	clippy::cast_sign_loss,
82	clippy::cast_precision_loss

structbuf 0.3.3/src/lib.rs

457	pub fn i8<T: Into<i8>>(&mut self, v: T) -> &mut Self {
458	#[allow(clippy::cast_sign_loss)]
459	self.put([v.into() as u8])

svg2polylines 0.8.1/src/lib.rs

673	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
674	let num_segments = (angle_extent.abs() * 2.0 / f64::consts::PI).ceil() as u64;

sweeper 1.0.0-rc3/src/field.rs

114

    #[cfg(feature = "generation")]

115

    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss, clippy::cast_precision_loss)]

116

    pub fn populate(&mut self, mine_percentage: f64, safe_spot: Option<FieldCoordinates>) {

swoop 0.1.0/src/minimise_scalar/bounded.rs

56	/// Will return `SwoopErrors::ArgumentError` is passed tolerance `xtol` is negative
57	#[allow(clippy::cast_sign_loss)]
58	#[allow(clippy::cast_possible_truncation)]

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 {

teleterm 0.2.0/src/session_list.rs

128	}
129	#[allow(clippy::cast_sign_loss)]
130	let mut i = i as usize;

tempergb 0.1.2/src/lib.rs

64	#[inline]
65	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
66	// Allow(clippy::cast_sign_loss, clippy::cast_possible_truncation): The bounds have been previously

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/player/gstreamer_backend.rs

313	#[allow(clippy::cast_sign_loss)]
314	#[allow(clippy::cast_possible_wrap)]
336	#[allow(clippy::cast_sign_loss)]
337	#[allow(clippy::cast_possible_wrap)]

termusic 0.7.8/src/player/mpv_backend/libmpv/mpv/events.rs

207	/// Diable all events.
208	#[allow(clippy::cast_sign_loss)]
209	pub fn disable_all_events(&self) -> Result<()> {
244	/// or `MPV_EVENT_PROPERTY_CHANGE` event failed, or if `MPV_EVENT_END_FILE` reported an error.
245	#[allow(clippy::ptr_as_ptr, clippy::cast_sign_loss)]
246	pub fn wait_event(&mut self, timeout: f64) -> Option<Result<Event<'_>>> {

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

67	#[allow(
68	clippy::cast_sign_loss,
69	clippy::cast_possible_truncation,

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

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

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

180	#[inline]
181	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
182	fn seek(&mut self, time: Duration) -> Option<Duration> {

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

6	clippy::cast_precision_loss,
7	clippy::cast_sign_loss,
8	clippy::cast_possible_truncation,
99	clippy::cast_possible_truncation,
100	clippy::cast_sign_loss
101	)]
349	#[allow(
350	clippy::cast_sign_loss,
351	clippy::cast_possible_truncation,

time_me 0.1.2/src/lib.rs

128	/// - if the provided string isn't a number
129	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
130	pub fn parse_as_minutes(unparsed: &str) -> Result<Duration, impl Error> {

tinyrand 0.5.0/src/lib.rs

87	#[allow(clippy::cast_precision_loss)]
88	#[allow(clippy::cast_sign_loss)]
89	let cutoff = (p.0 * u64::MAX as f64) as u64;

trait-based-collection 0.1.0/src/collection.rs

1224	#[allow(clippy::cast_precision_loss)]
1225	#[allow(clippy::cast_sign_loss)]
1226	#[allow(clippy::cast_possible_truncation)]

tremor-script 0.13.0-rc.11/src/ast/binary.rs

191	clippy::cast_possible_truncation,
192	clippy::cast_sign_loss,
193	clippy::too_many_arguments

tremor-script 0.13.0-rc.11/src/ast/raw.rs

193	// We allow this for casting the bits
194	#[allow(clippy::cast_sign_loss)]
195	fn up<'registry>(self, helper: &mut Helper<'script, 'registry>) -> Result<Self::Target> {

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

19	#[allow(clippy::cast_sign_loss)]
20	pub fn _parse(datetime: &str, input_fmt: &str, has_timezone: bool) -> Result<u64> {

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

358	clippy::cast_possible_truncation,
359	clippy::cast_sign_loss,
360	clippy::cast_possible_wrap

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

619	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
620	let v = v as u64; // TODO add f64 support to HDR Histogram create - oss

tremor-value 0.13.0-rc.11/src/value/cmp.rs

20	#[allow(clippy::cast_sign_loss, clippy::default_trait_access)]
21	impl<'value> PartialEq for Value<'value> {

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

133	clippy::cast_precision_loss,
134	clippy::cast_sign_loss
135	)]
445	#[must_use]
446	#[allow(clippy::cast_sign_loss)]
447	fn as_u64(&self) -> Option<u64> {

trillium-http 0.2.8/src/body.rs

138	#[allow(
139	clippy::cast_sign_loss,
140	clippy::cast_possible_truncation,

tsukuyomi 0.5.3/src/fs.rs

225	impl NamedFileResponse {
226	#[allow(clippy::cast_sign_loss)]
227	fn is_modified(&self, headers: &HeaderMap) -> Result<bool, Error> {

twilight-cache-any-backend 0.13.0/src/model/message.rs

96	/// Create a cached embed from a given embed and message ID
97	#[allow(clippy::cast_sign_loss, clippy::as_conversions)]
98	#[must_use]

twilight-gateway 0.15.0-rc.2/src/ratelimiter.rs

111	// Round up to be on the safe side.
112	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
113	let heartbeats_per_reset = heartbeats_per_reset.ceil() as u8;

twilight-http-ratelimiting 0.15.0-rc.1/src/headers.rs

489	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
490	reset.replace((reset_value * 1000.).ceil() as u64);
495	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
496	reset_after.replace((reset_after_value * 1000.).ceil() as u64);

twilight-lavalink 0.15.0-rc.1/src/player.rs

153	OutgoingEvent::Volume(event) => {
154	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
155	self.volume.store(event.volume, Ordering::Release);

ub 0.1.0/src/lib.rs

163	fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
164	#[allow(clippy::cast_sign_loss)]
165	match pos {

under 0.3.5/src/request/remote.rs

262	if index < 0 {
263	#[allow(clippy::cast_sign_loss)]
264	let index = (index.checked_abs()? as usize).checked_sub(1)?;
266	} else if index >= 0 {
267	#[allow(clippy::cast_sign_loss)]
268	ip.nth(index as usize).and_then(\|s\| s.parse().ok())
317	if index < 0 {
318	#[allow(clippy::cast_sign_loss)]
319	let index = (index.checked_abs()? as usize).checked_sub(1)?;
321	} else if index >= 0 {
322	#[allow(clippy::cast_sign_loss)]
323	ffor.nth(index as usize).and_then(parse_ip)

unix-print 0.1.0/src/lib.rs

89	#[allow(clippy::cast_sign_loss)]
90	fn try_print(fd: usize, msg: &str) -> core::fmt::Result {

ur 0.3.0/src/sampler.rs

54	#[allow(clippy::cast_sign_loss)]
55	pub fn next(&mut self, xoshiro: &mut crate::xoshiro::Xoshiro256) -> u32 {

ur 0.3.0/src/xoshiro.rs

36	#[allow(clippy::cast_sign_loss)]
37	pub fn next_int(&mut self, low: u64, high: u64) -> u64 {

utcnow 0.2.2/src/impl_libc.rs

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

utcnow 0.2.2/src/impl_rustix.rs

12	#[allow(clippy::cast_possible_truncation)]
13	#[allow(clippy::cast_sign_loss)]
14	#[allow(clippy::unnecessary_cast)]

utcnow 0.2.2/src/impl_web.rs

9	#[allow(clippy::cast_possible_truncation)]
10	#[allow(clippy::cast_sign_loss)]
11	#[allow(clippy::unnecessary_wraps)]

utcnow 0.2.2/src/lib.rs

440	/// ```
441	#[allow(clippy::cast_sign_loss)]
442	#[const_fn::const_fn("1.58")]

value-trait 0.5.1/src/node.rs

170	#[must_use]
171	#[allow(clippy::cast_sign_loss)]
172	fn as_u64(&self) -> Option<u64> {
182	#[must_use]
183	#[allow(clippy::cast_sign_loss)]
184	fn as_u64(&self) -> Option<u64> {
195	#[must_use]
196	#[allow(clippy::cast_sign_loss)]
197	fn as_u128(&self) -> Option<u128> {
276	#[allow(clippy::cast_sign_loss, clippy::default_trait_access)]
277	impl PartialEq for StaticNode {

vason 0.0.3/src/canvas.rs

131	/// ```
132	#[allow(clippy::cast_sign_loss)]
133	pub fn fill_rect(&mut self, x: i32, y: i32, w: i32, h: i32, color: impl Into<Color>) {
154	/// ```
155	#[allow(clippy::cast_sign_loss)]
156	pub fn outline_rect(&mut self, x: i32, y: i32, w: i32, h: i32, color: impl Into<Color>) {
213	/// ```
214	#[allow(clippy::cast_sign_loss)]
215	pub fn thick_outline_rect(
300	/// ```
301	#[allow(clippy::cast_sign_loss, clippy::many_single_char_names)]
302	pub fn fill_circle(&mut self, x: i32, y: i32, mut r: i32, color: impl Into<Color>) {
352	/// ```
353	#[allow(clippy::cast_sign_loss, clippy::many_single_char_names)]
354	pub fn outline_circle(&mut self, x: i32, y: i32, mut r: i32, color: impl Into<Color>) {

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

95	#[allow(clippy::cast_possible_truncation)]
96	#[allow(clippy::cast_sign_loss)]
97	#[allow(clippy::cast_precision_loss)]
281	#[allow(clippy::cast_possible_wrap)]
282	#[allow(clippy::cast_sign_loss)]
283	#[allow(clippy::cast_possible_truncation)]

visual-odometry-rs 0.1.0/src/core/gradient.rs

36	#[allow(clippy::cast_possible_truncation)]
37	#[allow(clippy::cast_sign_loss)]
38	pub fn squared_norm(grad_x: &na::DMatrix<i16>, grad_y: &na::DMatrix<i16>) -> na::DMatrix<u16> {
47	#[allow(clippy::cast_possible_truncation)]
48	#[allow(clippy::cast_sign_loss)]
49	pub fn squared_norm_direct(im: &na::DMatrix<u8>) -> na::DMatrix<u16> {
100	#[allow(clippy::cast_possible_truncation)]
101	#[allow(clippy::cast_sign_loss)]
102	pub fn bloc_squared_norm(a: u8, b: u8, c: u8, d: u8) -> u16 {

visual-odometry-rs 0.1.0/src/core/inverse_depth.rs

35	#[allow(clippy::cast_possible_truncation)]
36	#[allow(clippy::cast_sign_loss)]
37	pub fn to_depth(scale: Float, idepth: InverseDepth) -> u16 {

visual-odometry-rs 0.1.0/src/core/track/lm_optimizer.rs

224	#[allow(clippy::cast_possible_truncation)]
225	#[allow(clippy::cast_sign_loss)]
226	#[allow(clippy::cast_precision_loss)]

visual-odometry-rs 0.1.0/src/misc/colormap.rs

15	#[allow(clippy::cast_possible_truncation)]
16	#[allow(clippy::cast_sign_loss)]
17	fn to_u8(x: f32) -> u8 {

visual-odometry-rs 0.1.0/src/misc/view.rs

73	/// - `WithVariance`: viridis colormap
74	#[allow(clippy::cast_sign_loss)]
75	#[allow(clippy::cast_possible_truncation)]

vsdbsled 0.34.7-patched/src/debug_delay.rs

68	#[allow(clippy::cast_possible_truncation)]
69	#[allow(clippy::cast_sign_loss)]
70	thread::sleep(Duration::from_micros(u64::from(duration)));

vsdbsled 0.34.7-patched/src/histogram.rs

176	// inaccurate for values closer to 0 than +/- 0.51 or +/- math.Inf.
177	#[allow(clippy::cast_sign_loss)]
178	#[allow(clippy::cast_possible_truncation)]

w32-error 1.0.0/src/lib.rs

135	#[cfg(feature = "std")]
136	#[allow(clippy::cast_sign_loss)]
137	/// Wraps the error code from an `io::Error` if it has one.

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

38	pub const fn nanoseconds(&self) -> u32 { self.nanoseconds }
39	#[allow(clippy::cast_sign_loss)]
40	#[allow(clippy::cast_possible_truncation)]
77	impl SerializeIntoSlice for Timestamp {
78	#[allow(clippy::cast_sign_loss)]
79	#[allow(clippy::cast_possible_truncation)]

wealthy 0.2.0/src/filesize.rs

94	#[allow(clippy::cast_possible_truncation)]
95	#[allow(clippy::cast_sign_loss)]
96	#[allow(clippy::cast_precision_loss)]

wealthy 0.2.0/src/ratio.rs

57	#[allow(clippy::cast_possible_truncation)]
58	#[allow(clippy::cast_sign_loss)]
59	#[allow(clippy::cast_possible_wrap)]

weather_util_rust 0.15.1/src/angle.rs

92	#[must_use]
93	#[allow(clippy::cast_sign_loss)]
94	pub fn from_deg(deg: f64) -> Self {

web-audio-api 0.28.0/src/io/mod.rs

199	// buffer_size is always positive and truncation is the desired behavior
200	#[allow(clippy::cast_sign_loss)]
201	#[allow(clippy::cast_possible_truncation)]

wotw_seedgen 0.2.1/src/generator/mod.rs

103	for (item, amount) in header.item_pool_changes {
104	#[allow(clippy::cast_sign_loss)]
105	match amount.cmp(&0) {

wotw_seedgen 0.2.1/src/util/mod.rs

237	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
238	pub(crate) fn float_to_int(float: f32) -> Result<u32, String> {

wotw_seedgen 0.2.1/src/world/player.rs

201	// the game rounds to even
202	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation, clippy::float_cmp)]
203	if value % 1. == 0.5 && value as u8 % 2 == 0 {
267	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
268	weapons.sort_unstable_by_key(\|&weapon\| (weapon.damage_per_energy(self.settings.difficulty) * 10.0) as u16);
285	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
286	weapons.sort_unstable_by_key(\|&weapon\| (weapon.damage_per_energy(self.settings.difficulty) * 10.0) as u16);
297	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
298	weapons.sort_unstable_by_key(\|&weapon\| (weapon.damage_per_energy(self.settings.difficulty) * 10.0) as u16);

xlang_abi 0.2.0/src/alloc.rs

231	/// Returns a [`LayoutError`] if x, times the size of T, exceeds [`isize::MAX`]
232	#[allow(clippy::cast_sign_loss)]
233	pub fn array<T>(x: usize) -> Result<Self, LayoutError> {

xlang_abi 0.2.0/src/hash.rs

146	#[allow(clippy::cast_sign_loss)]
147	fn write_i8(&mut self, i: i8) {

xlang_abi 0.2.0/src/string.rs

395	#[must_use]
396	#[allow(clippy::cast_sign_loss)] // offset_from can never be negative
397	pub fn len(&self) -> usize {
421	#[must_use]
422	#[allow(clippy::cast_sign_loss)] // allocation size is `[0,isize::MAX)` so this can never possibly overflow
423	pub fn as_byte_span(self) -> Span<'a, u8> {

xterm-js-sys 4.6.0-alpha1/src/lib.rs

66	/// -1 indicates an error/lack of an element).
67	#[allow(clippy::cast_sign_loss)]
68	fn idx_to_opt(idx: i32) -> Option<u32> {

xterm-js-sys 4.6.0-alpha1/src/readonly_array.rs

600	/// Typed version of [`Array::keys`].
601	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
602	pub fn typed_keys(&self) -> impl Iterator<Item = u32> {

yata 0.6.1/src/core/action.rs

171	#[allow(clippy::cast_possible_truncation)]
172	#[allow(clippy::cast_sign_loss)]
173	fn from_normalized_f64_to_bounded(value: f64) -> SignalType {

yata 0.6.1/src/methods/hma.rs

70	#[allow(clippy::cast_possible_truncation)]
71	#[allow(clippy::cast_sign_loss)]
72	match length {
124	#[allow(clippy::cast_possible_truncation)]
125	#[allow(clippy::cast_sign_loss)]
126	(2..255).for_each(\|length\| {

yata 0.6.1/src/methods/renko.rs

333	#[allow(clippy::cast_possible_truncation)]
334	#[allow(clippy::cast_sign_loss)]
335	#[allow(clippy::suboptimal_flops)]

yatima-rustyline 0.2.0/src/keymap.rs

1101	#[allow(clippy::cast_sign_loss)]
1102	fn emacs_num_args(&mut self) -> (RepeatCount, bool) {
1115	#[allow(clippy::cast_sign_loss)]
1116	fn vi_num_args(&mut self) -> RepeatCount {

yatima-rustyline 0.2.0/src/tty/unix.rs

146	} else {
147	#[allow(clippy::cast_sign_loss)]
148	return Ok(res as usize);

yedb 0.4.11/src/yedb-cli.rs

51	#[allow(clippy::cast_possible_truncation)]
52	#[allow(clippy::cast_sign_loss)]
53	async fn benchmark(

zkp-elliptic-curve 0.2.0/src/wnaf.rs

116	// Signs are explicitly handled
117	#[allow(clippy::cast_sign_loss)]
118	#[must_use]
144	// Signs are explicitly handled
145	#[allow(clippy::cast_sign_loss)]
146	#[must_use]
186	// Signs are explicitly handled
187	#[allow(clippy::cast_sign_loss)]
188	// TODO: [refactor] [beginner] [small] rewrite
210	// Signs are explicitly handled
211	#[allow(clippy::cast_sign_loss)]
212	// Rebind naf_table after affine batch conversion

zkp-logging-allocator 0.2.0/src/size_bytes.rs

15	// We have no negative numbers here (not even .log10() < 0).
16	#[allow(clippy::cast_sign_loss)]
17	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

zkp-stark 0.2.1/src/algebraic_dag.rs

524	// Sizes are small enough
525	#[allow(clippy::cast_sign_loss)]
526	let row = row as usize;

zkp-stark 0.2.1/src/solidity_verifier.rs

604	// TODO - Remove this when we support negatives
605	#[allow(clippy::cast_sign_loss)]
606	RationalExpression::Trace(_, j) => *j as usize,

zkp-u256 0.2.1/src/conversion.rs

120	// We want twos-complement casting
121	#[allow(clippy::cast_sign_loss)]
122	// We want truncation here

zune-jpeg 0.2.0/src/bitstream.rs

5	clippy::doc_markdown,
6	clippy::cast_sign_loss,
7	clippy::cast_possible_truncation
267	clippy::cast_possible_truncation,
268	clippy::cast_sign_loss,
269	clippy::unwrap_used
310	clippy::cast_possible_truncation,
311	clippy::cast_sign_loss
312	)]

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

5	#[inline]
6	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss, dead_code)]
7	fn clamp(a: i16) -> u8

zune-jpeg 0.2.0/src/huffman.rs

69	clippy::cast_possible_wrap,
70	clippy::cast_sign_loss,
71	clippy::too_many_lines

zune-jpeg 0.2.0/src/worker.rs

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

aerospike 1.2.0/src/lib.rs

28	clippy::cast_possible_wrap,
29	clippy::cast_sign_loss,
30	clippy::checked_conversions,

Aetherus 0.1.1/src/lib.rs

15	clippy::cast_precision_loss,
16	clippy::cast_sign_loss,
17	clippy::default_numeric_fallback,

alpha-shell 0.3.0/src/main.rs

1	#![warn(clippy::pedantic)]
2	#![allow(clippy::cast_sign_loss)]
3	#![allow(clippy::cast_possible_wrap)]

alt_serde 1.0.119/src/lib.rs

111	cast_possible_wrap,
112	cast_sign_loss,
113	// things are often more readable this way

alt_serde_json 1.0.61/src/lib.rs

328	clippy::cast_precision_loss,
329	clippy::cast_sign_loss,
330	// correctly used

arctk 2.0.7/src/lib.rs

16	clippy::cast_precision_loss,
17	clippy::cast_sign_loss,
18	clippy::default_numeric_fallback,

argv 0.1.7/src/lib.rs

37	#![allow(
38	clippy::cast_sign_loss,
39	clippy::must_use_candidate,

arn-language 1.2.1/src/main.rs

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

asciiframe 1.2.0/src/bin/asc/main.rs

3	#![warn(clippy::all, clippy::pedantic)]
4	#![allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
5	use clap::Parser;

asciiframe 1.2.0/src/lib.rs

3	#![warn(clippy::all, clippy::pedantic)]
4	#![allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
5	mod converter;

async-graphql 5.0.5/src/lib.rs

163	#![allow(clippy::too_many_lines)]
164	#![allow(clippy::cast_sign_loss)]
165	#![allow(clippy::unused_self)]

av-scenechange 0.8.1/src/lib.rs

6	#![allow(clippy::cast_precision_loss)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::default_trait_access)]

av-scenechange 0.8.1/src/main.rs

6	#![allow(clippy::cast_precision_loss)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::default_trait_access)]

av1-grain 0.2.2/src/lib.rs

15	#![allow(clippy::cast_precision_loss)]
16	#![allow(clippy::cast_sign_loss)]
17	#![allow(clippy::default_trait_access)]

av1an-core 0.4.0/src/lib.rs

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

babbage 0.1.1/src/lib.rs

16	clippy::cast_precision_loss,
17	clippy::cast_sign_loss,
18	clippy::else_if_without_else,

base64-simd 0.8.0/src/lib.rs

38	clippy::module_name_repetitions,
39	clippy::cast_sign_loss,
40	clippy::cast_possible_truncation,

beehive 0.1.1/src/collections/direction_map.rs

75	{
76	#![allow(clippy::cast_sign_loss)]

better-as 0.2.0/src/lib.rs

12	clippy::as_conversions,
13	clippy::cast_sign_loss,
14	clippy::cast_possible_truncation,

boa_cli 0.16.0/src/main.rs

45	clippy::cast_possible_truncation,
46	clippy::cast_sign_loss,
47	clippy::cast_precision_loss,

boa_engine 0.16.0/src/lib.rs

56	clippy::cast_possible_truncation,
57	clippy::cast_sign_loss,
58	clippy::cast_precision_loss,

boa_interner 0.16.0/src/lib.rs

56	clippy::cast_possible_truncation,
57	clippy::cast_sign_loss,
58	clippy::cast_precision_loss,

boa_unicode 0.16.0/src/lib.rs

53	clippy::cast_possible_truncation,
54	clippy::cast_sign_loss,
55	clippy::cast_precision_loss,

bpaf 0.7.7/src/batteries.rs

86	#![allow(clippy::cast_possible_wrap)]
87	#![allow(clippy::cast_sign_loss)]
88	verbose_and_quiet_by_number(offset as isize, 0, items.len() as isize - 1)

bve 0.0.1/src/lib.rs

15	// Annoying regular clippy warnings
16	#![allow(clippy::cast_sign_loss)] // Annoying
17	#![allow(clippy::cast_precision_loss)] // Annoying

bve-derive 0.0.1/src/lib.rs

17	#![allow(clippy::cast_precision_loss)] // Annoying
18	#![allow(clippy::cast_sign_loss)] // Annoying
19	#![allow(clippy::cognitive_complexity)] // This is dumb

bve-native 0.0.1/src/lib.rs

55	// Annoying regular clippy warnings
56	#![allow(clippy::cast_sign_loss)] // Annoying
57	#![allow(clippy::cast_precision_loss)] // Annoying

byteio 0.2.3/src/lib.rs

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

cameleon-genapi 0.1.8/src/formula.rs

5	#![allow(
6	clippy::cast_sign_loss,
7	clippy::cast_precision_loss,

cameleon-genapi 0.1.8/src/lib.rs

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

cargo-build-dist 0.1.0/src/lib.rs

19	clippy::cast_possible_truncation,
20	clippy::cast_sign_loss,
21	clippy::if_not_else,

cargo-build-dist 0.1.0/src/main.rs

14	clippy::cast_possible_truncation,
15	clippy::cast_sign_loss,
16	clippy::if_not_else,

cargo-monorepo 0.2.0/src/lib.rs

19	clippy::cast_possible_truncation,
20	clippy::cast_sign_loss,
21	clippy::if_not_else,

cargo-monorepo 0.2.0/src/main.rs

14	clippy::cast_possible_truncation,
15	clippy::cast_sign_loss,
16	clippy::if_not_else,

cargo-tally 1.0.22/src/lib.rs

7	clippy::cast_ptr_alignment,
8	clippy::cast_sign_loss,
9	clippy::items_after_statements,

cartograph 0.1.2/src/lib.rs

16	clippy::cast_precision_loss,
17	clippy::cast_sign_loss,
18	clippy::else_if_without_else,

cl-generic-vec 0.4.0/src/iter/raw_cursor.rs

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

classygroup 0.0.5/src/uint.rs

5	//! because there may be bugs we did not catch.
6	#![allow(clippy::cast_sign_loss)]

colorous 1.0.9/src/lib.rs

278	clippy::cast_precision_loss,
279	clippy::cast_sign_loss,
280	clippy::doc_markdown,

config-loader 2.2.3/src/main.rs

17	clippy::cast_precision_loss,
18	clippy::cast_sign_loss,
19	clippy::doc_markdown,

core_arch 0.1.5/src/lib.rs

41	clippy::too_many_arguments,
42	clippy::cast_sign_loss,
43	clippy::cast_lossless,

coresimd 0.1.2/src/lib.rs

50	too_many_arguments,
51	cast_sign_loss,
52	cast_lossless,

cpclib 0.6.0/src/lib.rs

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

crypt4ghfs 0.3.0/src/lib.rs

6	clippy::module_name_repetitions,
7	clippy::cast_sign_loss,
8	clippy::cast_possible_truncation,

crystalorb 0.3.0/src/lib.rs

14	clippy::cast_lossless, // TODO: Fix these. See issue #1
15	clippy::cast_sign_loss, // TODO: Fix these. See issue #1
16	clippy::cast_possible_truncation, // TODO: Fix these. See issue #1

cxx-build 1.0.88/src/lib.rs

48	#![allow(
49	clippy::cast_sign_loss,
50	clippy::default_trait_access,

cxx-gen 0.7.88/src/lib.rs

12	#![allow(
13	clippy::cast_sign_loss,
14	clippy::default_trait_access,

cxxbridge-cmd 1.0.88/src/main.rs

1	#![allow(
2	clippy::cast_sign_loss,
3	clippy::cognitive_complexity,

cxxbridge-macro 1.0.88/src/lib.rs

1	#![allow(
2	clippy::cast_sign_loss,
3	clippy::default_trait_access,

daml-codegen 0.2.2/src/lib.rs

5	clippy::use_self,
6	clippy::cast_sign_loss,
7	clippy::must_use_candidate,

daml-darn 0.2.2/src/main.rs

7	clippy::missing_errors_doc,
8	clippy::cast_sign_loss
9	)]

daml-lf 0.2.2/src/lib.rs

82	clippy::use_self,
83	clippy::cast_sign_loss,
84	clippy::must_use_candidate,

db-dump-concat 0.1.1/main.rs

19	clippy::cast_lossless,
20	clippy::cast_sign_loss,
21	clippy::let_underscore_drop,

der 0.6.1/src/asn1/real.rs

5	clippy::cast_lossless,
6	clippy::cast_sign_loss,
7	clippy::integer_arithmetic

deranged-macros 0.1.0/src/lib.rs

32	clippy::cast_possible_wrap,
33	clippy::cast_sign_loss,
34	clippy::missing_errors_doc,

diffuse 0.1.1/src/lib.rs

16	clippy::cast_precision_loss,
17	clippy::cast_sign_loss,
18	clippy::else_if_without_else,

diskit 0.1.1/src/lib.rs

32	clippy::cast_possible_truncation,
33	clippy::cast_sign_loss,
34	clippy::cast_precision_loss,

dissimilar 1.0.6/src/lib.rs

44	clippy::cast_possible_wrap,
45	clippy::cast_sign_loss,
46	clippy::cloned_instead_of_copied, // https://github.com/rust-lang/rust-clippy/issues/7127

dma-heap 0.2.1/src/lib.rs

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

dotnetdll 0.0.1/src/lib.rs

6	clippy::cast_precision_loss,
7	clippy::cast_sign_loss,
8	clippy::enum_glob_use,

dragonbox 0.1.4/src/lib.rs

55	clippy::cast_possible_wrap,
56	clippy::cast_sign_loss,
57	clippy::comparison_chain,

drone 0.14.0/src/lib.rs

37	clippy::cast_precision_loss,
38	clippy::cast_sign_loss,
39	clippy::doc_markdown,

drone-core 0.14.3/src/lib.rs

52	clippy::cast_possible_wrap,
53	clippy::cast_sign_loss,
54	clippy::missing_errors_doc,

dryip 0.6.0/src/arrays.rs

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

dtoa 1.0.5/src/lib.rs

38	clippy::cast_possible_truncation,
39	clippy::cast_sign_loss,
40	clippy::doc_markdown,

easytime 0.2.4/src/lib.rs

87	clippy::cast_precision_loss,
88	clippy::cast_sign_loss,
89	clippy::manual_map, // Option::map is not const

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.

esri_ascii_grid 0.1.2/src/lib.rs

73	clippy::module_name_repetitions,
74	clippy::cast_sign_loss,
75	clippy::similar_names,

essence 0.3.3/src/lib.rs

7	clippy::cast_possible_wrap,
8	clippy::cast_sign_loss,
9	clippy::missing_errors_doc,

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

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

flacenc 0.1.0/src/lib.rs

26	clippy::cast_precision_loss,
27	clippy::cast_sign_loss,
28	clippy::multiple_crate_versions,

flacenc 0.1.0/src/main.rs

21	clippy::cast_precision_loss,
22	clippy::cast_sign_loss,
23	clippy::multiple_crate_versions,

ftzz 1.2.0/src/core/tasks.rs

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

ftzz 1.2.0/src/generator.rs

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

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

37	//! ```
38	#![allow(clippy::cast_sign_loss)]
39	#![allow(clippy::cast_possible_wrap)]

git_function_history 0.7.0/src/lib.rs

5	clippy::cast_possible_truncation,
6	clippy::cast_sign_loss,
7	clippy::cognitive_complexity,

gonk 0.1.2/src/main.rs

7	clippy::cast_possible_truncation,
8	clippy::cast_sign_loss,
9	clippy::cast_precision_loss

grass 0.12.2/src/lib.rs

71	// todo:
72	clippy::cast_sign_loss,
73	clippy::cast_lossless,

grass_compiler 0.12.2/src/lib.rs

71	// todo:
72	clippy::cast_sign_loss,
73	clippy::cast_lossless,

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

6	#![allow(clippy::cast_precision_loss)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::default_trait_access)]

guess-that-lang 1.0.20/src/main.rs

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

hcl-rs 0.12.3/src/lib.rs

8	clippy::cast_precision_loss,
9	clippy::cast_sign_loss,
10	clippy::enum_glob_use,

headless_chrome 1.0.2/src/lib.rs

75	clippy::cast_possible_truncation, // for types.rs:189 & 190
76	clippy::cast_sign_loss, // for tab/element/mod.rs:492 & 493
77	clippy::cast_lossless, // for tab/element/mod.rs:492 & 493

hedera 0.9.0/src/lib.rs

38	clippy::cast_possible_truncation,
39	clippy::cast_sign_loss,
40	clippy::enum_glob_use,

hex_color 2.0.0/src/serde.rs

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

hex-simd 0.8.0/src/lib.rs

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

hexchat 0.6.3/src/lib.rs

21	stable_features,
22	clippy::cast_sign_loss,
23	clippy::cast_possible_truncation,

iced_aw 0.3.0/src/lib.rs

39	clippy::cast_possible_truncation,
40	clippy::cast_sign_loss,
41	clippy::cast_possible_wrap,

iced_focus 0.1.1/src/lib.rs

41	clippy::cast_possible_truncation,
42	clippy::cast_sign_loss,
43	clippy::cast_possible_wrap,

iced_focus_derive 0.1.1/src/lib.rs

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

imdl 0.1.12/src/bytes.rs

45	clippy::as_conversions,
46	clippy::cast_sign_loss,
47	clippy::cast_possible_truncation

imdl 0.1.12/src/piece_length_picker.rs

12	clippy::as_conversions,
13	clippy::cast_sign_loss,
14	clippy::cast_precision_loss,

interim 0.1.0/src/lib.rs

91	clippy::cast_possible_wrap,
92	clippy::cast_sign_loss
93	)]

jiao 0.2.1/src/painting/color.rs

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

leftwm-core 0.4.1/src/lib.rs

12	clippy::cast_possible_wrap,
13	clippy::cast_sign_loss,
14	clippy::must_use_candidate,

legacygui 0.1.0/src/lib.rs

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

legacygui 0.1.0/src/main.rs

12	clippy::cast_possible_truncation,
13	clippy::cast_sign_loss,
14	clippy::cast_precision_loss,

legacylisten 0.2.0/src/lib.rs

244	clippy::cast_possible_truncation,
245	clippy::cast_sign_loss,
246	clippy::cast_precision_loss,

legacytranslate 0.2.0/src/lib.rs

67	clippy::cast_possible_truncation,
68	clippy::cast_sign_loss,
69	clippy::cast_precision_loss,

libredefender 0.6.0/src/lib.rs

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

lofty 0.11.0/src/lib.rs

118	clippy::cast_precision_loss,
119	clippy::cast_sign_loss,
120	clippy::cast_possible_wrap,

lrumap 0.1.0/src/lib.rs

15	clippy::module_name_repetitions,
16	clippy::cast_sign_loss,
17	clippy::cast_possible_truncation

lsd 0.23.1/src/main.rs

2	clippy::cast_precision_loss,
3	clippy::cast_sign_loss,
4	clippy::match_same_arms,

luacells 0.1.4/src/main.rs

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

mach 0.3.2/src/lib.rs

9	clippy::module_name_repetitions,
10	clippy::cast_sign_loss,
11	clippy::cast_possible_truncation,

mach2 0.4.1/src/lib.rs

6	clippy::module_name_repetitions,
7	clippy::cast_sign_loss,
8	clippy::cast_possible_truncation,

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.

mdbook-pdf-headless_chrome 0.1.2/src/lib.rs

75	clippy::cast_possible_truncation, // for types.rs:189 & 190
76	clippy::cast_sign_loss, // for tab/element/mod.rs:492 & 493
77	clippy::cast_lossless, // for tab/element/mod.rs:492 & 493

mee6 0.0.3/src/lib.rs

5	clippy::cast_precision_loss,
6	clippy::cast_sign_loss,
7	clippy::cast_possible_truncation

memedsn 0.1.0/src/lib.rs

26	clippy::cast_precision_loss,
27	clippy::cast_sign_loss,
28	clippy::items_after_statements,

memega 0.1.0/src/lib.rs

27	clippy::cast_precision_loss,
28	clippy::cast_sign_loss,
29	clippy::items_after_statements,

memegeom 0.1.0/src/lib.rs

26	clippy::cast_precision_loss,
27	clippy::cast_sign_loss,
28	clippy::items_after_statements,

memeroute 0.1.0/src/lib.rs

26	clippy::cast_precision_loss,
27	clippy::cast_sign_loss,
28	clippy::expl_impl_clone_on_copy,

memeroute-gui 0.1.0/src/lib.rs

26	clippy::cast_precision_loss,
27	clippy::cast_sign_loss,
28	clippy::items_after_statements,

memestat 0.1.0/src/lib.rs

27	clippy::cast_precision_loss,
28	clippy::cast_sign_loss,
29	clippy::items_after_statements,

memestr 0.1.0/src/lib.rs

26	clippy::cast_precision_loss,
27	clippy::cast_sign_loss,
28	clippy::items_after_statements,

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

26	clippy::cast_precision_loss,
27	clippy::cast_sign_loss,
28	clippy::items_after_statements,

moldenfile 0.1.0/src/lib.rs

26	clippy::cast_precision_loss,
27	clippy::cast_sign_loss,
28	clippy::items_after_statements,

monostate 0.1.2/src/lib.rs

56	clippy::cast_lossless,
57	clippy::cast_sign_loss,
58	clippy::expl_impl_clone_on_copy,

nano-leb128 0.1.0/src/lib.rs

76	#![allow(clippy::cast_possible_truncation)]
77	#![allow(clippy::cast_sign_loss)]

nc 0.8.13/src/call_header.rs

6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::missing_errors_doc)]

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

6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::missing_errors_doc)]

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

6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::missing_errors_doc)]

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

6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::missing_errors_doc)]

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

6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::missing_errors_doc)]

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

6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::missing_errors_doc)]

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

6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::missing_errors_doc)]

netcorehost 0.13.1/src/lib.rs

13	clippy::doc_markdown,
14	clippy::cast_sign_loss,
15	clippy::shadow_unrelated,

nixpacks 1.1.1/src/lib.rs

7	clippy::wildcard_imports,
8	clippy::cast_sign_loss,
9	clippy::cast_precision_loss,

nng 1.0.1/src/lib.rs

148	// library, which means the types are a little bit up-in-the-air.
149	#![allow(clippy::cast_sign_loss)]
150	#![allow(clippy::empty_enum)] // Revisit after RFC1861 and RFC1216.

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)]

ordered-varint 1.0.1/src/lib.rs

16	clippy::module_name_repetitions,
17	clippy::cast_sign_loss,
18	clippy::cast_possible_truncation

para-cli 0.1.0/src/ppm.rs

4	#![allow(clippy::cast_sign_loss)]

parsley 0.10.0/src/primitives/num.rs

4	clippy::cast_precision_loss,
5	clippy::cast_sign_loss
6	)]

pb-jelly 0.0.11/src/lib.rs

1	#![warn(rust_2018_idioms)]
2	#![allow(clippy::cast_sign_loss)]
3	#![allow(clippy::cast_possible_truncation)]

pixel_engine_draw 0.7.0/src/traits.rs

169	clippy::cast_possible_wrap,
170	clippy::cast_sign_loss
171	)]
544	clippy::cast_possible_wrap,
545	clippy::cast_sign_loss
546	)]
605	clippy::cast_possible_wrap,
606	clippy::cast_sign_loss
607	)]

polyfuse-tokio 0.2.3/src/channel.rs

5	clippy::cast_possible_truncation,
6	clippy::cast_sign_loss
7	)]

portier_broker 0.5.2/src/main.rs

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

prettyplease 0.1.23/src/lib.rs

324	clippy::cast_possible_wrap,
325	clippy::cast_sign_loss,
326	clippy::derive_partial_eq_without_eq,

profqu_neat 0.1.1/src/lib.rs

15	#![allow(clippy::cast_possible_truncation)]
16	#![allow(clippy::cast_sign_loss)]
17	#![allow(clippy::ptr_arg)]

pyxel-core 1.9.11/src/lib.rs

6	clippy::cast_precision_loss,
7	clippy::cast_sign_loss,
8	clippy::float_cmp,

pyxel-engine 1.8.2/src/lib.rs

6	clippy::cast_precision_loss,
7	clippy::cast_sign_loss,
8	clippy::fn_params_excessive_bools,

pyxel-extension 1.9.11/src/lib.rs

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

pyxel-wrapper 1.8.2/src/lib.rs

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

rdenticon 0.1.3/src/lib.rs

4	clippy::cast_possible_truncation,
5	clippy::cast_sign_loss
6	)]

render_cerke_board 0.1.18/src/lib.rs

5	clippy::cast_possible_truncation,
6	clippy::cast_sign_loss
7	)]

reui 0.0.2/src/lib.rs

5	clippy::module_name_repetitions,
6	clippy::cast_sign_loss,
7	clippy::cast_possible_truncation,

rgba_simple 0.8.0/src/lib.rs

1	#![warn(clippy::all, clippy::pedantic)]
2	#![allow(clippy::cast_sign_loss)]
3	#![allow(clippy::cast_possible_truncation)]

ril 0.9.0/src/lib.rs

256	clippy::cast_possible_truncation,
257	clippy::cast_sign_loss,
258	clippy::module_name_repetitions,

rl_ball_sym 2.5.2/src/simulation/bvh.rs

230	mod test {
231	#![allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]

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

80	#![allow(
81	clippy::cast_sign_loss,
82	clippy::cast_possible_truncation,

rtop_dev 1.1.0/src/lib.rs

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

rtop-rs 1.1.1/src/lib.rs

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

rustycpp 0.1.6/src/utils/antlrlexerwrapper.rs

1	//! Wrapper over a token collection for antlr consumption.
2	#![allow(clippy::unused_self, clippy::cast_sign_loss, clippy::borrowed_box)]
3	use antlr_rust::atn_simulator::IATNSimulator;

ryu 1.0.12/src/lib.rs

88	clippy::cast_possible_wrap,
89	clippy::cast_sign_loss,
90	clippy::checked_conversions,

ryu 1.0.12/tests/common_test.rs

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

ryu 1.0.12/tests/d2s_table_test.rs

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

ryu 1.0.12/tests/s2d_test.rs

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

ryu 1.0.12/tests/s2f_test.rs

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

ryu-js 0.2.2/src/lib.rs

62	clippy::cast_possible_wrap,
63	clippy::cast_sign_loss,
64	clippy::checked_conversions,

ryu-js 0.2.2/tests/common_test.rs

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

ryu-js 0.2.2/tests/d2s_table_test.rs

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

ryu-js 0.2.2/tests/s2d_test.rs

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

ryu-js 0.2.2/tests/s2f_test.rs

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

scientific 0.2.0/src/lib.rs

6	#![allow(clippy::cast_possible_wrap)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::explicit_iter_loop)]

serde 1.0.152/src/lib.rs

116	cast_possible_wrap,
117	cast_sign_loss,
118	// things are often more readable this way

serde_json 1.0.91/src/lib.rs

335	clippy::cast_precision_loss,
336	clippy::cast_sign_loss,
337	// correctly used

serde_json 1.0.91/tests/lexical.rs

5	clippy::cast_precision_loss,
6	clippy::cast_sign_loss,
7	clippy::comparison_chain,

serde_json_experimental 1.0.29-rc1/src/lib.rs

333	cast_precision_loss,
334	cast_sign_loss,
335	// string ser/de uses indexing and slicing

serde_json_lenient 0.1.4/src/lib.rs

336	clippy::cast_precision_loss,
337	clippy::cast_sign_loss,
338	// correctly used

serde_json_v8 0.1.1/src/lib.rs

307	cast_precision_loss,
308	cast_sign_loss,
309	// things are often more readable this way

serde_jsonrc 0.1.0/src/lib.rs

320	cast_precision_loss,
321	cast_sign_loss,
322	// things are often more readable this way

serde_partiql 1.1.65/src/lib.rs

328	clippy::cast_precision_loss,
329	clippy::cast_sign_loss,
330	// correctly used

serde_yaml 0.9.17/src/lib.rs

144	clippy::cast_precision_loss,
145	clippy::cast_sign_loss,
146	clippy::derive_partial_eq_without_eq,

serenity 0.11.5/src/lib.rs

67	clippy::wildcard_imports,
68	clippy::cast_sign_loss,
69	clippy::too_many_lines,

shamir_file_secret_sharing 1.0.0/src/main.rs

41	// disabled individual clippy linters
42	#![allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]

sled 0.34.7/tests/tree/mod.rs

95	#![allow(clippy::cast_precision_loss)]
96	#![allow(clippy::cast_sign_loss)]

slice-deque 0.3.0/src/lib.rs

136	clippy::cast_possible_wrap,
137	clippy::cast_sign_loss,
138	clippy::cast_possible_truncation,

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

136	clippy::cast_possible_wrap,
137	clippy::cast_sign_loss,
138	clippy::cast_possible_truncation,

sonant 0.1.0/examples/player.rs

4	#![allow(clippy::cast_precision_loss)]
5	#![allow(clippy::cast_sign_loss)]

sonant 0.1.0/src/lib.rs

16	#![allow(clippy::cast_precision_loss)]
17	#![allow(clippy::cast_sign_loss)]

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

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

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

2	clippy::as_conversions,
3	clippy::cast_sign_loss,
4	clippy::cast_possible_truncation,

sponsor-block 0.6.1/src/lib.rs

61	clippy::cast_precision_loss,
62	clippy::cast_sign_loss,
63	clippy::doc_markdown,

sqlx-migrate 0.6.0/src/lib.rs

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

ssd1681 0.1.0/src/lib.rs

26	#![allow(clippy::cast_possible_truncation)]
27	#![allow(clippy::cast_sign_loss)]
28	#![allow(clippy::must_use_candidate)]

ssimulacra2 0.3.0/src/lib.rs

6	#![allow(clippy::cast_precision_loss)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::default_trait_access)]

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

64	clippy::cast_possible_wrap,
65	clippy::cast_sign_loss,
66	clippy::module_name_repetitions,

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

3	#![allow(clippy::cast_precision_loss)]
4	#![allow(clippy::cast_sign_loss)]

sts_profile_auth 0.7.1/src/lib.rs

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

swarm-bot 0.3.4/src/main.rs

54	#![allow(clippy::wildcard_imports)]
55	#![allow(clippy::cast_sign_loss)]
56	// TODO: remove most of these

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

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

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

37	clippy::cast_precision_loss,
38	clippy::cast_sign_loss,
39	clippy::enum_glob_use,

tiny-bench 0.2.0/src/lib.rs

4	#![allow(clippy::module_name_repetitions)]
5	#![allow(clippy::cast_sign_loss)]
6	#![deny(missing_docs)]

tinydeque 0.1.1/src/lib.rs

4	#![warn(clippy::pedantic)]
5	#![allow(clippy::cast_sign_loss)]
6	#![allow(clippy::redundant_pattern_matching)]

toml-datetime-compat 0.2.0/src/lib.rs

84	#![warn(clippy::pedantic, missing_docs)]
85	#![allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
86	use std::result::Result as StdResult;

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

16	clippy::cast_possible_truncation,
17	clippy::cast_sign_loss,
18	clippy::cast_possible_wrap

trippy 0.6.0/src/main.rs

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

twitch-tui 2.0.2/src/main.rs

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

uc8151 0.1.4/src/lib.rs

460	fn try_from(value: Rectangle) -> Result<Self, &'static str> {
461	#![allow(clippy::cast_sign_loss)]
462	let point = value.top_left;

umpl 1.1.0/src/lib.rs

8	clippy::cast_possible_truncation,
9	clippy::cast_sign_loss,
10	clippy::cognitive_complexity,

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

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

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

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

unsafe-libyaml 0.2.5/src/lib.rs

16	clippy::cast_ptr_alignment,
17	clippy::cast_sign_loss,
18	clippy::collapsible_if,

uuid-simd 0.8.0/src/lib.rs

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

video-resize 0.1.1/src/lib.rs

6	#![allow(clippy::cast_precision_loss)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::default_trait_access)]

vsdbsled 0.34.7-patched/tests/tree/mod.rs

95	#![allow(clippy::cast_precision_loss)]
96	#![allow(clippy::cast_sign_loss)]

vsimd 0.8.0/src/lib.rs

29	clippy::cast_possible_truncation,
30	clippy::cast_sign_loss,
31	clippy::cast_possible_wrap,

weather-tui 0.1.0/src/main.rs

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

wikidata 0.3.0/src/lib.rs

7	#![allow(clippy::wildcard_imports)]
8	#![allow(clippy::cast_sign_loss)]
9	#![allow(clippy::cast_possible_truncation)]

xaskpass 2.5.2/src/main.rs

3	#![allow(clippy::non_ascii_literal)]
4	#![allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
5	#![allow(clippy::option_if_let_else)]

xkbcommon 0.5.0/src/xkb/mod.rs

4	clippy::wildcard_imports,
5	clippy::cast_sign_loss,
6	clippy::too_many_arguments

yuv2rgb 0.0.2/src/lib.rs

8	#![allow(clippy::cast_precision_loss)]
9	#![allow(clippy::cast_sign_loss)]
10	#![allow(clippy::inconsistent_struct_constructor)]

yuvxyb 0.3.0/src/lib.rs

6	#![allow(clippy::cast_precision_loss)]
7	#![allow(clippy::cast_sign_loss)]
8	#![allow(clippy::default_trait_access)]

zune-jpeg 0.2.0/src/color_convert.rs

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

58	let size = unsafe { db_get_i64(self.value, nullptr, 0) };
59	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
60	let mut bytes = vec![0_u8; size as usize];
61	let ptr: mut c_void = &mut bytes[..] as mut _ as *mut c_void;
62	#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
63	unsafe {

7	match value >= 0 {
8	#[allow(clippy::cast_sign_loss)]
9	true => value as u32 \| I32_SIGN_BIT,
10	#[allow(clippy::cast_sign_loss)]
11	false => (value - i32::min_value()) as u32,