agb 0.13.0/src/save/eeprom.rs

95	/// Reads a block from the save media.
96	#[allow(clippy::needless_range_loop)]
97	fn read_sector(&self, word: usize) -> [u8; 8] {
120	/// Writes a sector directly.
121	#[allow(clippy::needless_range_loop)]
122	fn write_sector_raw(

agb 0.13.0/src/save/flash.rs

357	/// Writes an entire buffer to the save media.
358	#[allow(clippy::needless_range_loop)]
359	fn write_buffer(&self, offset: usize, buf: &[u8], timeout: &mut Timeout) -> Result<(), Error> {
371	/// Erases and writes an entire 128b sector on Atmel devices.
372	#[allow(clippy::needless_range_loop)]
373	fn write_atmel_sector_raw(

agb 0.13.0/tests/save_test_common/mod.rs

32	#[allow(clippy::needless_range_loop)]
33	fn do_test(

alexcrichton-cranelift-codegen 0.53.0/src/legalizer/mod.rs

392	// Ignore the lint for this loop as the range needs to be 0 to table_size
393	#[allow(clippy::needless_range_loop)]
394	for i in 0..table_size {

algorithms-edu 0.2.7/src/algo/graph.rs

207	impl WeightedAdjacencyMatrix {
208	#[allow(clippy::needless_range_loop)]
209	pub fn with_size(n: usize) -> Self {

algorithms-edu 0.2.7/src/problems/dp/edit_distance.rs

3	#[allow(clippy::needless_range_loop)]
4	pub fn edit_distance(s1: &[u8], s2: &[u8]) -> u32 {

algorithms-edu 0.2.7/src/problems/graph/tsp/dp.rs

21	impl TspSolver {
22	#[allow(clippy::needless_range_loop)]
23	pub fn solve(distance: &WeightedAdjacencyMatrix, start: usize) -> (f64, Vec<usize>) {

algorithms-edu 0.2.7/src/problems/network_flow/mice_and_owls.rs

4	#[allow(clippy::many_single_char_names)]
5	#[allow(clippy::needless_range_loop)]
6	pub fn mice_and_owls<S: MaxFlowSolver>(mice: &[Mouse], holes: &[Hole], radius: f64) -> i32 {

ark-crypto-primitives 0.4.0/src/sponge/constraints/mod.rs

62	#[allow(clippy::needless_range_loop)]
63	for k in 0..params.num_limbs {

ark-sponge 0.4.0-alpha/src/constraints/mod.rs

62	#[allow(clippy::needless_range_loop)]
63	for k in 0..params.num_limbs {

arpfloat 0.1.9/src/bigint.rs

289	/// Implements addition of the 'rhs' sequence of words to this number.
290	#[allow(clippy::needless_range_loop)]
291	fn inplace_add_slice(&mut self, rhs: &[u64]) {
321	/// that shifts the divisor.
322	#[allow(clippy::needless_range_loop)]
323	fn inplace_sub_slice(&mut self, rhs: &[u64], bottom_zeros: usize) -> bool {

assembly-fdb 0.1.0/examples/sqlite-to-fdb.rs

323	// Iterate over fields
324	#[allow(clippy::needless_range_loop)]
325	for index in 0..column_count {

audio-engine 0.4.5/src/wav.rs

23	#[allow(clippy::needless_range_loop)]
24	fn inner_write_sample<S: hound::Sample>(

audio-processor-analysis 0.4.0/src/transient_detection/stft/dynamic_thresholds.rs

62	// This lint is no good
63	#[allow(clippy::needless_range_loop)]
64	for i in 0..power_of_change_frames.len() {

audio-processor-file 1.3.0/src/audio_file_processor/file_io.rs

212	for sample in 0..num_samples {
213	#[allow(clippy::needless_range_loop)]
214	for channel in 0..num_channels {

autd 9.0.1/src/controller/autd_logic.rs

197	#[allow(clippy::needless_range_loop)]
198	pub(crate) fn firmware_info_list(&mut self) -> Result<Vec<FirmwareInfo>, Box<dyn Error>> {

av1-grain 0.2.2/src/diff/solver.rs

1098	let dx = 255f64 / self.num_bins as f64;
1099	#[allow(clippy::needless_range_loop)]
1100	for i in start.max(1)..end.min(lut.points.len() - 1) {

aya-log 0.1.13/src/lib.rs

107	#[allow(clippy::needless_range_loop)]
108	for i in 0..events.read {

basicaf 0.1.2/src/ir/blockgen.rs

376	#[cfg_attr(feature = "cargo-clippy",
377	allow(needless_range_loop))]
378	for i in out_block..j+1 {

beeenn 0.1.0/src/bereader.rs

188	let mut buf = [0u8; 100000];
189	#[allow(clippy::needless_range_loop)]
190	for index in 0..len {

bellperson 0.24.1/src/gadgets/lookup.rs

290	#[allow(clippy::needless_range_loop)]
291	#[test]

bevy_render 0.9.1/src/mesh/shape/capsule.rs

47	impl From<Capsule> for Mesh {
48	#[allow(clippy::needless_range_loop)]
49	fn from(capsule: Capsule) -> Self {

bevy_rl_shooter 0.1.2/src/game.rs

39	let agents: Vec<&Actor> = player_query.iter().collect();
40	#[allow(clippy::needless_range_loop)]
41	for i in 0..agents.len() {

blades 0.5.0/src/page.rs

527	#[inline]
528	#[allow(clippy::needless_range_loop)]
529	pub fn from_external(mut pages: Vec<Page<'p>>) -> Self {

bls12_381_ietf 0.1.3/src/optimized_swu.rs

136	mapped_values[i] = ISO_3_MAP_COEFFICIENTS[i][last];
137	#[allow(clippy::needless_range_loop)]
138	for j in 0..last {

bmfont_rs 0.2.0/src/parse/mod.rs

17	impl<T: Copy + Default + Parse, const N: usize> Parse for [T; N] {
18	#[allow(clippy::needless_range_loop)]
19	fn parse(src: &str) -> ParseResult<Self> {

bocu1 0.1.0/src/variable_length_code.rs

161	#[inline]
162	#[allow(clippy::needless_range_loop)] // The loop is not "needless" here!
163	pub fn decode_delta(b: &[u8]) -> Result<(i32, &[u8]), DecodeError> {

brawllib_rs 0.24.1/src/mdl0/objects.rs

36	// Not sure if I can actually mutate like clippy is suggesting
37	#[allow(clippy::needless_range_loop)]
38	for i in 0..uv_ids.len() {

breadx-image 0.1.0/src/bits.rs

119	#[allow(clippy::needless_range_loop)]
120	#[cfg(test)]

breadx-image 0.1.0/src/lib.rs

918	#[allow(clippy::needless_range_loop)]
919	#[cfg(all(test, feature = "std"))]

broot 1.18.0/src/display/areas.rs

96	let nb_pos = slots.len();
97	#[allow(clippy::needless_range_loop)]
98	for slot_idx in 0..nb_pos {

bytelines 2.4.0/src/std.rs

154	#[cfg(test)]
155	#[allow(clippy::needless_range_loop)]
156	mod tests {

bytelines 2.4.0/src/tokio.rs

90	#[cfg(test)]
91	#[allow(clippy::needless_range_loop)]
92	mod tests {

cao-lang 0.1.108/src/collections/value_stack.rs

82	let n = self.count.min(N);
83	#[allow(clippy::needless_range_loop)]
84	for i in 0..n {

casper-types 1.5.0/src/system/auction/bid/vesting.rs

57	// Ed and Henry prefer this idiom
58	#[allow(clippy::needless_range_loop)]
59	for i in 0..LOCKED_AMOUNTS_LENGTH - 1 {

cdx 0.1.21/src/agg.rs

1124	}
1125	#[allow(clippy::needless_range_loop)] // cleaner this way
1126	for x in 0..val.len() {

cdx 0.1.21/src/bin/cdx/wc_main.rs

162	for x in &aggs {
163	#[allow(clippy::needless_range_loop)]
164	for i in 0..agg.len() {
226	}
227	#[allow(clippy::needless_range_loop)]
228	for i in 0..agg.len() {

cess-hashers 0.1.0/src/poseidon.rs

277	// any terminal padding
278	#[allow(clippy::needless_range_loop)]
279	for i in (elts.len() + 1)..arity {

cess-sp-porep 0.1.2/src/stacked/vanilla/proof.rs

474	#[allow(clippy::needless_range_loop)]
475	#[cfg(any(feature = "cuda", feature = "opencl"))]

cipher 0.4.3/src/stream_core.rs

276	#[inline(always)]
277	#[allow(clippy::needless_range_loop)]
278	fn call<B: StreamBackend<BlockSize = BS>>(self, backend: &mut B) {

cita_trie 4.0.0/src/trie.rs

827	let mut nodes = empty_children();
828	#[allow(clippy::needless_range_loop)]
829	for i in 0..nodes.len() {

codebreaker 0.3.1/src/rc4.rs

11	impl Rc4 {
12	#[allow(clippy::needless_range_loop)]
13	pub fn new(key: &[u8]) -> Self {

colorspace 0.1.0/src/math.rs

150	#[allow(clippy::needless_range_loop)]
151	for j in (i + 1)..3 {
333	let mut m = Matrix33::<T>::new([T::zero(); 9]);
334	#[allow(clippy::needless_range_loop)]
335	for i in 0..3 {

comparable 0.5.4/src/set.rs

34	if other.len() > self.len() {
35	#[allow(clippy::needless_range_loop)]
36	for i in self.len()..other.len() {

connectorx 0.3.1/src/dispatcher.rs

135	for _ in 0..n {
136	#[allow(clippy::needless_range_loop)]
137	for col in 0..dst.ncols() {
154	dst.aquire_row(n)?;
155	#[allow(clippy::needless_range_loop)]
156	for col in 0..dst.ncols() {

coreutils 0.0.17/tests/by-util/test_split.rs

191	fns.sort();
192	#[allow(clippy::needless_range_loop)]
193	for i in 0..5 {

coreutils 0.0.17/tests/by-util/test_tail.rs

1819	let mut delay = 1500;
1820	#[allow(clippy::needless_range_loop)]
1821	for i in 0..2 {
2217	let mut delay = 500;
2218	#[allow(clippy::needless_range_loop)]
2219	for i in 0..2 {

cpclib-image 0.6.0/src/image.rs

1	#![allow(clippy::needless_range_loop)]
192	/// Double the width (usefull for chuncky conversions)
193	#[allow(clippy::needless_range_loop, clippy::identity_op)]
194	pub fn double_horizontally(&mut self) {

crc32c 0.6.3/src/combine.rs

56	odd[0] = 0x82F63B78; /* CRC-32c polynomial */
57	#[allow(clippy::needless_range_loop)]
58	for n in 1..GF2_DIM {

cretonne-codegen 0.13.2/src/bforest/pool.rs

63	// Note that we have to capture `tree` by value to avoid borrow checker trouble.
64	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
65	for i in 0..usize::from(size + 1) {

cryptoxide 0.4.2/src/curve25519/scalar/mod.rs

15	impl Scalar {
16	#[allow(clippy::needless_range_loop)]
17	pub(crate) fn slide(&self) -> [i8; 256] {

cryptoxide 0.4.2/src/hashing/sha3.rs

68	// Code based on Keccak-compact64.c from ref implementation.
69	#[allow(clippy::needless_range_loop)]
70	fn keccak_f(state: &mut [u8; B]) {

cryptoxide 0.4.2/src/poly1305.rs

197	#[allow(clippy::needless_range_loop)]
198	for i in 0..want {

cskk 2.0.0/src/capi.rs

829	// Cleanup the CStrings we allocated so far and return -1
830	#[allow(clippy::needless_range_loop)]
831	for j in 0..i {

curve25519-dalek 4.0.0-rc.0/src/backend/serial/scalar_mul/precomputed_straus.rs

101	#[allow(clippy::needless_range_loop)]
102	for i in 0..sp {

curve25519-dalek 4.0.0-rc.0/src/backend/vector/avx2/field.rs

345	let low_26_bits = (1 << 26) - 1;
346	#[allow(clippy::needless_range_loop)]
347	for i in 0..5 {

curve25519-dalek 4.0.0-rc.0/src/backend/vector/scalar_mul/precomputed_straus.rs

98	#[allow(clippy::needless_range_loop)]
99	for i in 0..sp {

curve25519-dalek 4.0.0-rc.0/src/scalar.rs

427	let mut bytes = [0u8; 32];
428	#[allow(clippy::needless_range_loop)]
429	for i in 0..32 {
1100	let digits_count = (256 + w - 1) / w;
1101	#[allow(clippy::needless_range_loop)]
1102	for i in 0..digits_count {

cyfs-raptorq 1.6.1/src/base.rs

273	#[allow(clippy::needless_range_loop)]
274	for d in 1..f.len() {

cyfs-raptorq 1.6.1/src/constraint_matrix.rs

66	let mut mt: Vec<Vec<u8>> = vec![vec![0; Kprime + S]; H];
67	#[allow(clippy::needless_range_loop)]
68	for i in 0..H {
69	#[allow(clippy::needless_range_loop)]
70	for j in 0..=(Kprime + S - 2) {
82	// We only create the last row of the GAMMA matrix, as all preceding rows are just a shift left
83	#[allow(clippy::needless_range_loop)]
84	for j in 0..(Kprime + S) {
90	}
91	#[allow(clippy::needless_range_loop)]
92	for i in 0..H {
111	}
112	#[allow(clippy::needless_range_loop)]
113	for j in 0..(Kprime + S) {

cyfs-raptorq 1.6.1/src/matrix.rs

223	let mut temp = vec![vec![0; DenseBinaryMatrix::bit_position(self.width).0 + 1]; rows];
224	#[allow(clippy::needless_range_loop)]
225	for row in 0..rows {

cyfs-raptorq 1.6.1/src/pi_solver.rs

1129	let mut result = Vec::with_capacity(self.L);
1130	#[allow(clippy::needless_range_loop)]
1131	for i in 0..self.L {

cyfs-raptorq 1.6.1/src/sparse_matrix.rs

90	let mut row_mapping = vec![0; height];
91	#[allow(clippy::needless_range_loop)]
92	for i in 0..height {
94	}
95	#[allow(clippy::needless_range_loop)]
96	for i in 0..width {

dark-integers 0.0.1/src/mluint.rs

25	let mut res = [T::zero(); N];
26	#[allow(clippy::needless_range_loop)]
27	for i in 0..N {

deca 0.0.10/tests/integration_tests.rs

4	#[test]
5	#[allow(clippy::too_many_lines, clippy::needless_range_loop)]
6	fn bon_test() {

didyoumean 1.1.4/src/lib.rs

109	/// ```
110	#[allow(clippy::iter_count, clippy::needless_range_loop)]
111	pub fn edit_distance(search_chars: &[char], known_term: &str) -> usize {

difference 2.0.0/examples/line-by-line.rs

16	#[allow(unused_must_use)]
17	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
18	fn main() {

dleq 0.2.0/src/cross_group/aos.rs

173	let mut e = Self::nonces(transcript.clone(), (R0_0, R1_0));
174	#[allow(clippy::needless_range_loop)]
175	for i in 0 .. (RING_LEN - 1) {
189	let mut e = None;
190	#[allow(clippy::needless_range_loop)]
191	for i in 0 .. RING_LEN {

dlx 0.1.0/examples/sudoku.rs

61	/// sudoku clue.
62	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
63	fn rows_from_line(line: &str) -> Vec<Row> {

domain 0.7.1/src/base/net/nostd.rs

136	#[allow(clippy::many_single_char_names)]
137	#[allow(clippy::needless_range_loop)]
138	impl fmt::Display for Ipv6Addr {

dubp-documents 0.58.0/src/transaction/v10.rs

239	let mut tx_unlockable_on = 0;
240	#[allow(clippy::needless_range_loop)]
241	for i in 0..self.inputs.len() {

dup-crypto 0.58.0/src/bases/b58.rs

44	}
45	#[allow(clippy::needless_range_loop)]
46	for i in 0..delta {

dusk-plonk 0.13.1/src/fft/domain.rs

229	#[allow(clippy::needless_range_loop)]
230	/// Evaluate all the lagrange polynomials defined by this domain at the

duvet 0.2.0/src/extract.rs

144	#[allow(clippy::needless_range_loop)]
145	for i in start.0..=end.0 {

easyneural 0.1.0/src/network.rs

67	) {
68	#[allow(clippy::needless_range_loop)]
69	for i in 0..layer.len() - if is_last { 0 } else { 1 } {

ecrs 0.1.0-beta.3/src/ga/operators/crossover.rs

739	#[allow(clippy::needless_range_loop)]
740	for i in begin..end {

emlop 0.5.0/src/table.rs

95	// doesn't make sense here.
96	#[allow(clippy::needless_range_loop)]
97	for i in 0..N {

eo 0.0.3/src/net/packet_processing.rs

156	/// Init_Init packets are ignored
157	#[allow(clippy::needless_range_loop)]
158	pub fn encode(&self, bytes: &mut [EOByte]) {

erg_common 0.6.3/levenshtein.rs

20	for i1 in 0..l_len {
21	#[allow(clippy::needless_range_loop)]
22	for i2 in 0..r_len {

ergotree-ir 0.22.0/src/sigma_protocol/dlog_group.rs

66	let mut bytes = [0u8; 32];
67	#[allow(clippy::needless_range_loop)]
68	#[allow(clippy::unwrap_used)]

esl01-renderdag 0.3.0/src/render.rs

462	};
463	#[allow(clippy::needless_range_loop)]
464	for i in column + 1..parent_column {

eth_trie 0.1.0/src/trie.rs

894	let mut nodes = empty_children();
895	#[allow(clippy::needless_range_loop)]
896	for i in 0..nodes.len() {

everscale-raptorq 1.7.0/src/base.rs

262	#[allow(clippy::needless_range_loop)]
263	for d in 1..f.len() {

everscale-raptorq 1.7.0/src/constraint_matrix.rs

66	// with the lower right 1 in GAMMA
67	#[allow(clippy::needless_range_loop)]
68	for i in 0..H {
76	for j in (0..=(Kprime + S - 2)).rev() {
77	#[allow(clippy::needless_range_loop)]
78	for i in 0..H {
89	// Copy G_HDPC into matrix
90	#[allow(clippy::needless_range_loop)]
91	for i in 0..H {
92	#[allow(clippy::needless_range_loop)]
93	for j in 0..(Kprime + S) {
190	let mut mt: Vec<Vec<u8>> = vec![vec![0; Kprime + S]; H];
191	#[allow(clippy::needless_range_loop)]
192	for i in 0..H {

everscale-raptorq 1.7.0/src/pi_solver.rs

1301	let mut result = Vec::with_capacity(self.L);
1302	#[allow(clippy::needless_range_loop)]
1303	for i in 0..self.L {

everscale-raptorq 1.7.0/src/sparse_matrix.rs

107	let mut row_mapping = vec![0; height];
108	#[allow(clippy::needless_range_loop)]
109	for i in 0..height {
111	}
112	#[allow(clippy::needless_range_loop)]
113	for i in 0..width {

evilaes 0.1.0/src/lib.rs

448	// I think this is useless at this point
449	#[allow(clippy::needless_range_loop)]
450	fn transpose(state: &mut [[u8; 4]; 4])

evm-core 0.37.0/src/eval/misc.rs

31	let mut load = [0u8; 32];
32	#[allow(clippy::needless_range_loop)]
33	for i in 0..32 {

evm-core 0.37.0/src/memory.rs

86	#[allow(clippy::needless_range_loop)]
87	for index in 0..size {

fast_rsync 0.1.4/src/md4/mod.rs

396	type Item = (&'a [u8], [u8; 16]);
397	#[allow(clippy::needless_range_loop)]
398	fn next(&mut self) -> Option<Self::Item> {

fbas_analyzer 0.7.3/src/simulation/graph.rs

24	/// "highest" tier, i.e., the tier with the next lowest index.
25	#[allow(clippy::needless_range_loop)]
26	pub fn new_tiered_full_mesh(tier_sizes: &[usize]) -> Self {
205	/// Simplified page rank (no dampening, fixed maximum number of runs, fixed epsilon)
206	#[allow(clippy::needless_range_loop)]
207	pub fn get_rank_scores(&self) -> Vec<RankScore> {

fea-rs 0.2.0/src/compile/features.rs

294	let mut out = [LookupId::Empty; N];
295	#[allow(clippy::needless_range_loop)]
296	for i in 0..N {

femtovg 0.4.0/src/gradient_store.rs

93	#[allow(clippy::needless_range_loop)]
94	for i in s..e {

fera-graph 0.2.0/src/builder.rs

774	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
775	fn complete_binary_tree()

file_endec 1.0.1/src/files/mockfile.rs

25	let mut b: u32 = 1;
26	#[allow(clippy::needless_range_loop)]
27	for i in 0..len {

filecoin-hashers 7.0.0/src/poseidon.rs

271	// any terminal padding
272	#[allow(clippy::needless_range_loop)]
273	for i in (elts.len() + 1)..arity {

flacenc 0.1.0/src/lpc.rs

654	#[cfg(test)]
655	#[allow(clippy::pedantic, clippy::nursery, clippy::needless_range_loop)]
656	mod tests {

flacenc 0.1.0/src/source.rs

294	#[cfg(test)]
295	#[allow(clippy::pedantic, clippy::nursery, clippy::needless_range_loop)]
296	mod tests {

fluvio-cli 0.3.1/src/common/hex_dump.rs

7	/// Takes a u8 array of bytes and converts to hex dump
8	#[allow(clippy::needless_range_loop)]
9	pub fn bytes_to_hex_dump(record: &[u8]) -> String {

fluvio-extension-common 0.10.0/src/common/hex_dump.rs

7	/// Takes a u8 array of bytes and converts to hex dump
8	#[allow(clippy::needless_range_loop)]
9	pub fn bytes_to_hex_dump(record: &[u8]) -> String {

fullcodec-plonk 0.2.0/src/fft/domain.rs

202	#[allow(clippy::needless_range_loop)]
203	/// Evaluate all the lagrange polynomials defined by this domain at the

futures-concurrency 7.0.0/src/future/race_ok/array/mod.rs

76	// NOTE: this clippy attribute can be removed once we can `collect` into `[usize; K]`.
77	#[allow(clippy::needless_range_loop)]
78	for (i, el) in this.elems.iter_mut().enumerate() {

futures-concurrency 7.0.0/src/future/try_join/array.rs

70	// NOTE: this clippy attribute can be removed once we can `collect` into `[usize; K]`.
71	#[allow(clippy::needless_range_loop)]
72	for (i, el) in this.elems.iter_mut().enumerate() {

gdnative-core 0.11.3/src/core_types/access.rs

309	#[allow(clippy::needless_range_loop)]
310	for i in 0..8 {

gemachain-runtime 1.8.2/src/accounts_db.rs

7951	#[allow(clippy::needless_range_loop)]
7952	fn modify_accounts(

genpass3 1.1.0/src/lib.rs

124	// elements of the Vec we would have mutable reference problems.
125	#[allow(clippy::needless_range_loop)]
126	for i in 0..config.length {

geo-booleanop 0.3.2/src/boolean/connect_edges.rs

57	/// iteration around the vertex.
58	#[allow(clippy::needless_range_loop)] // Check has false positive here
59	fn precompute_iteration_order<T, I, L>(data: &[T], is_identical: I, is_left: L) -> Vec<usize>

gf2_192 0.22.0/src/gf2_192.rs

702	#[allow(clippy::needless_range_loop)]
703	fn mul_bits(a: &[i64], b: &[i64]) -> GF2Slow {

ggez 0.9.0-rc0/examples/meshbatch.rs

63	impl event::EventHandler<ggez::GameError> for MainState {
64	#[allow(clippy::needless_range_loop)]
65	fn update(&mut self, ctx: &mut Context) -> GameResult {

good-web-game 0.6.0/examples/meshbatch.rs

66	impl event::EventHandler<ggez::GameError> for MainState {
67	#[allow(clippy::needless_range_loop)]
68	fn update(

gost94 0.10.4/src/gost94_core.rs

23	#[allow(clippy::needless_range_loop)]
24	for i in 0..8 {
37	#[allow(clippy::needless_range_loop)]
38	fn encrypt(msg: &mut [u8], key: Block, sbox: &SBox) {

gpio-cdev 0.5.1/src/lib.rs

788	};
789	#[allow(clippy::needless_range_loop)] // clippy does not understand this loop correctly
790	for i in 0..n {

graph-algo-ptas 0.1.0/src/utils/max_independent_set.rs

14	#[allow(clippy::needless_range_loop)]
15	for j in i + 1..sol.len() {

grass_compiler 0.12.2/src/evaluate/visitor.rs

2199	#[allow(clippy::needless_range_loop)]
2200	for i in (0..min_len).rev() {

grass_compiler 0.12.2/src/value/calculation.rs

257	#[allow(clippy::needless_range_loop)]
258	fn verify_compatible_numbers(

grav1synth 0.1.0-beta.5/src/parser/frame.rs

1176	let mut input = input;
1177	#[allow(clippy::needless_range_loop)]
1178	for i in 0..MAX_SEGMENTS {

grex 1.4.1/src/grapheme.rs

130	#[allow(clippy::needless_range_loop)]
131	for i in 0..characters.len() {

halo2_gadgets 0.2.0/src/poseidon/primitives/mds.rs

51	let mut mds = [[F::zero(); T]; T];
52	#[allow(clippy::needless_range_loop)]
53	for i in 0..T {
111	// Verify that MDS * MDS^-1 = I.
112	#[allow(clippy::needless_range_loop)]
113	for i in 0..T {

halo2_gadgets 0.2.0/src/poseidon/primitives.rs

89	// Matrix multiplication
90	#[allow(clippy::needless_range_loop)]
91	for i in 0..T {

hammer-and-sample 0.1.4/tests/hierarchical.rs

65	#[allow(clippy::needless_range_loop)]
66	for group in 0..GROUPS {

hash-table 0.2.5/src/lib.rs

44	pub fn from_parts(mut hashes: Hs, elems: Es, hasher: H) -> Self {
45	#[allow(clippy::needless_range_loop)]
46	for k in 0..hashes[..].len() { hashes[k] = 0; }

hash-trie 0.4.0/src/bit_indexed_array.rs

18	let mut building: [V; SIZE] = mem::uninitialized();
19	#[allow(clippy::needless_range_loop)]
20	for i in 0..SIZE {

hdd 0.10.3/src/utils.rs

32	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
33	pub fn hexdump_8(data: &[u8]) -> String {
66	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
67	pub fn hexdump_16be(data: &[u16]) -> String {

here_be_dragons 0.2.1/src/map.rs

86	/// Create map from given string
87	#[allow(clippy::needless_range_loop)]
88	pub fn from_string(map_string: &str) -> Map<D> {

hmip721 0.1.0/src/contract.rs

4058	// do for each PermissionType
4059	#[allow(clippy::needless_range_loop)]
4060	for i in 0..num_perm_types {

inout 0.1.3/src/inout.rs

136	#[inline(always)]
137	#[allow(clippy::needless_range_loop)]
138	pub fn xor_in2out(&mut self, data: &GenericArray<u8, N>) {
160	#[inline(always)]
161	#[allow(clippy::needless_range_loop)]
162	pub fn xor_in2out(&mut self, data: &GenericArray<GenericArray<u8, N>, M>) {

inout 0.1.3/src/inout_buf.rs

245	#[inline(always)]
246	#[allow(clippy::needless_range_loop)]
247	pub fn xor_in2out(&mut self, data: &[u8]) {

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

180	#[allow(clippy::needless_range_loop)]
181	for i in 0..count {

inside-baseball 0.1.0/src/xor.rs

53	let len = min(buf.len(), self.buffer.len());
54	#[allow(clippy::needless_range_loop)]
55	for i in 0..len {

iscc-rs 0.2.0/src/hashes.rs

58	for digest in hash_digests {
59	#[allow(clippy::needless_range_loop)]
60	for i in 0..64 {

isla-axiomatic 0.2.0/src/footprint_analysis.rs

195	// intervening exclusives.
196	#[allow(clippy::needless_range_loop)]
197	pub fn rmw_dep<B: BV>(from: usize, to: usize, instrs: &[B], footprints: &HashMap<B, Footprint>) -> bool {
218	/// first instruction before reaching the second.
219	#[allow(clippy::needless_range_loop)]
220	fn touched_by<B: BV>(
307	/// See `addr_dep`
308	#[allow(clippy::needless_range_loop)]
309	pub fn ctrl_dep<B: BV>(from: usize, to: usize, instrs: &[B], footprints: &HashMap<B, Footprint>) -> bool {

isla-lib 0.2.0/src/primop.rs

61	#[allow(clippy::needless_range_loop)]
62	pub fn smt_i128(i: i128) -> Exp {
80	#[allow(clippy::needless_range_loop)]
81	fn smt_mask_lower(len: usize, mask_width: usize) -> Exp {

isla-lib 0.2.0/src/smt/smtlib.rs

119	#[allow(clippy::needless_range_loop)]
120	pub fn bits64(bits: u64, size: u32) -> Exp {

isla-lib 0.2.0/src/smt.rs

927	#[allow(clippy::needless_range_loop)]
928	fn get_large_bv(&mut self, ast: Ast, size: u32) -> Result<Vec<bool>, ExecError> {

jpeg-encoder 0.5.1/src/huffman.rs

97	/// Generates an optimized huffman table as described in Section K.2
98	#[allow(clippy::needless_range_loop)]
99	pub fn new_optimized(mut freq: [u32; 257]) -> HuffmanTable {

k12 0.2.1/src/lanes.rs

93	#[allow(clippy::needless_range_loop)]
94	for round in 0..12 {

k12 0.2.1/src/lib.rs

165	#[allow(clippy::needless_range_loop)]
166	for i in 0..n - 1 {

k256 0.12.0/src/arithmetic/mul.rs

390	let mut res = [LookupTable::default(); 33];
391	#[allow(clippy::needless_range_loop)]
392	for i in 0..33 {

kalk 3.0.3/src/prelude/mod.rs

1034	#[allow(clippy::needless_range_loop)]
1035	pub fn transpose(x: KalkValue) -> Result<KalkValue, KalkError> {

kas-core 0.12.1/src/layout/size_rules.rs

370	clippy::comparison_chain,
371	clippy::needless_range_loop,
372	clippy::needless_return

khaiii-rs 0.1.4/src/lib.rs

139	#[allow(clippy::needless_range_loop)]
140	fn get_align(&self, input: &str) -> Vec<i32> {

kurobako 0.2.10/src/markdown.rs

57	#[allow(clippy::needless_range_loop)]
58	for col in 0..table.headers.len() {

lager 0.2.0/src/lib.rs

95	// For each element in the result
96	#[allow(clippy::needless_range_loop)]
97	for i in 0..M {
235	// For each element
236	#[allow(clippy::needless_range_loop)]
237	for row in 0..M {
257	// For each element
258	#[allow(clippy::needless_range_loop)]
259	for row in 0..M {

lattice-qcd-rs 0.2.1/src/test/mod.rs

231	#[test]
232	#[allow(clippy::needless_range_loop)]
233	/// Test the properties of generators

lexical-parse-float 0.8.5/src/bigint.rs

1133	/// In short, Karatsuba multiplication is never worthwhile for out use-case.
1134	#[allow(clippy::needless_range_loop)]
1135	pub fn long_mul<const SIZE: usize>(x: &[Limb], y: &[Limb]) -> Option<StackVec<SIZE>> {

libafl 0.9.0/src/feedbacks/map.rs

441	#[allow(clippy::wrong_self_convention)]
442	#[allow(clippy::needless_range_loop)]
443	fn is_interesting<EM, OT>(
661	#[allow(clippy::wrong_self_convention)]
662	#[allow(clippy::needless_range_loop)]
663	#[allow(clippy::trivially_copy_pass_by_ref)]

linfa-svm 0.6.1/src/solver_smo.rs

97	#[allow(clippy::needless_range_loop, clippy::too_many_arguments)]
98	impl<'a, F: Float, K: 'a + Permutable<F>> SolverState<'a, F, K> {

livesplit-core 0.13.0/src/analysis/sum_of_segments/best.rs

104	/// Best Segments. This value is also the value that is being returned.
105	#[allow(clippy::needless_range_loop)]
106	pub fn calculate(

livesplit-core 0.13.0/src/analysis/sum_of_segments/worst.rs

86	/// Sum of Worst Segments. This value is also the value that is being returned.
87	#[allow(clippy::needless_range_loop)]
88	pub fn calculate(

lofty 0.11.0/src/id3/v2/write/mod.rs

244	#[allow(clippy::needless_range_loop)]
245	for i in 0..5 {
280	#[allow(clippy::needless_range_loop)]
281	for i in 0..5 {

lofty 0.11.0/src/iff/wav/tag/write.rs

122	#[allow(clippy::needless_range_loop)]
123	for i in 0..4 {

logicsim 0.1.7/src/graph/initialized_graph.rs

73	// Using a manual loop results in 2% less instructions.
74	#[allow(clippy::needless_range_loop)]
75	for i in 0..gates.len() {
114	// Using a manual loop results in 2% less instructions.
115	#[allow(clippy::needless_range_loop)]
116	for i in 0..node.dependencies.len() {

lore 2.1.0/src/hash/md4.rs

238	#[allow(clippy::needless_range_loop)]
239	for i in 0..48 {

lore 2.1.0/src/hash/md5.rs

198	#[allow(clippy::needless_range_loop)]
199	for i in 0..64 {

lowcharts 0.5.8/src/plot/splittimehist.rs

104	// different lengths
105	#[allow(clippy::needless_range_loop)]
106	fn fmt_row(

lumiere 0.2.0/src/scene.rs

48	#[allow(clippy::needless_range_loop)]
49	for row in 0..self.image_height {

lzfse_rust 0.1.0/src/bits/accum.rs

147	#[allow(clippy::needless_range_loop)]
148	#[test]

lzfse_rust 0.1.0/src/encode/frontend_bytes.rs

368	// Sandwich, incremental literals.
369	#[allow(clippy::needless_range_loop)]
370	#[test]

lzfse_rust 0.1.0/src/fse/constants.rs

473	#[allow(clippy::needless_range_loop)]
474	#[test]

lzfse_rust 0.1.0/src/fse/decoder.rs

194	#[allow(arithmetic_overflow)]
195	#[allow(clippy::needless_range_loop)]
196	pub fn build_v_table(
238	#[allow(arithmetic_overflow)]
239	#[allow(clippy::needless_range_loop)]
240	pub fn build_u_table(weights: &[u16], table: &mut [UEntry]) {

lzfse_rust 0.1.0/src/fse/encoder.rs

223	#[allow(arithmetic_overflow)]
224	#[allow(clippy::needless_range_loop)]
225	#[inline(always)]

lzfse_rust 0.1.0/src/fse/weights.rs

113	#[allow(clippy::needless_range_loop)]
114	pub fn store_v1(&self, dst: &mut [u8]) {

lzfse_rust 0.1.0/src/ops/copy_long.rs

107	#[allow(clippy::needless_range_loop)]
108	#[test]

lzfse_rust 0.1.0/src/ops/copy_short.rs

111	#[allow(clippy::needless_range_loop)]
112	#[test]

lzfse_rust 0.1.0/src/ops/write_long.rs

51	#[allow(clippy::needless_range_loop)]
52	#[test]

magma 0.8.1/src/sboxes.rs

17	/// Generate expanded version of S-box.
18	#[allow(clippy::needless_range_loop)]
19	fn gen_exp_sbox() -> ExpSbox {

mapgen 0.6.0/src/map_buffer.rs

51	/// Create map from given string
52	#[allow(clippy::needless_range_loop)]
53	pub fn from_string(map_string: &str) -> MapBuffer {

marine-core 0.19.0/src/module/memory.rs

43	// needed because clippy suggests using an iterator which looks worse
44	#[allow(clippy::needless_range_loop)]
45	fn read_array<const COUNT: usize>(&self, offset: u32) -> [u8; COUNT] {
54	// needed because clippy suggests using an iterator which looks worse
55	#[allow(clippy::needless_range_loop)]
56	fn read_vec(&self, offset: u32, size: u32) -> Vec<u8> {

marmoset 0.9.4/examples/count.rs

238	/// SuperSet. It only tests combinations that include `extra`.
239	#[allow(clippy::needless_range_loop)]
240	fn contains_superset(hand: &[usize], extra: usize) -> bool {

max-7219-led-matrix-util 0.2.4/src/lib.rs

254	/// ```
255	#[allow(clippy::needless_range_loop)]
256	pub fn transpose_single_display_data(data: &SingleDisplayData) -> SingleDisplayData {

memtable-core 0.2.0/src/impls/col.rs

208	#[allow(clippy::needless_range_loop)]
209	for row in 0..ROW {

memtable-core 0.2.0/src/impls/dynamic.rs

218	#[allow(clippy::needless_range_loop)]
219	for row in 0..ROW {

memtable-core 0.2.0/src/impls/row.rs

232	#[allow(clippy::needless_range_loop)]
233	for row in 0..ROW {

memtable-core 0.2.0/src/utils/ser/array.rs

15	#[allow(clippy::needless_range_loop)]
16	for i in 0..N {

memtable-core 0.2.0/src/utils/ser/table_array.rs

15	#[allow(clippy::needless_range_loop)]
16	for row in 0..ROW {

merkle-rs 0.0.1/tests/large_tree.rs

90	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
91	for j in i + 1..max_size {

micro_ndarray 0.2.3/src/iterator.rs

59	_ => {
60	#[allow(clippy::needless_range_loop)] // clippy bug
61	for n in 0..D {

miden 0.3.0/tests/integration/stdlib/math/secp256k1.rs

114	#[test]
115	#[allow(clippy::needless_range_loop)]
116	fn test_u256_mod_neg() {

miden-air 0.3.0/src/chiplets/hasher/mod.rs

603	#[allow(clippy::needless_range_loop)]
604	for i in 0..HASH_CYCLE_LEN - 1 {

miden-air 0.3.0/src/stack/mod.rs

159	// enforces constraint on the ith element in the stack in the next trace.
160	#[allow(clippy::needless_range_loop)]
161	for i in 1..NUM_GENERAL_CONSTRAINTS - 2 {

miden-air 0.3.0/src/stack/stack_manipulation/mod.rs

204	/// ZERO.
205	#[allow(clippy::needless_range_loop)]
206	pub fn enforce_swapwx_constraints<E: FieldElement>(
280	/// element is 0.
281	#[allow(clippy::needless_range_loop)]
282	pub fn enforce_cswapx_constraints<E: FieldElement>(

miden-processor 0.3.0/src/trace/decoder/tests.rs

20	#[test]
21	#[allow(clippy::needless_range_loop)]
22	fn decoder_p1_span_with_respan() {
64	#[test]
65	#[allow(clippy::needless_range_loop)]
66	fn decoder_p1_join() {
124	#[test]
125	#[allow(clippy::needless_range_loop)]
126	fn decoder_p1_split() {
171	#[test]
172	#[allow(clippy::needless_range_loop)]
173	fn decoder_p1_loop_with_repeat() {
288	#[test]
289	#[allow(clippy::needless_range_loop)]
290	fn decoder_p2_span_with_respan() {

miden-processor 0.3.0/src/trace/tests/chiplets/bitwise.rs

19	#[test]
20	#[allow(clippy::needless_range_loop)]
21	fn b_aux_trace_bitwise() {

miden-processor 0.3.0/src/trace/tests/chiplets/hasher.rs

38	#[test]
39	#[allow(clippy::needless_range_loop)]
40	pub fn b_chip_span() {
109	#[test]
110	#[allow(clippy::needless_range_loop)]
111	pub fn b_chip_span_with_respan() {
213	#[test]
214	#[allow(clippy::needless_range_loop)]
215	pub fn b_chip_merge() {
328	#[test]
329	#[allow(clippy::needless_range_loop)]
330	pub fn b_chip_permutation() {

minorhacks_chess 0.1.3/src/gen_tables/between.rs

60	// Write the BETWEEN array to the specified file.
61	#[allow(clippy::needless_range_loop)]
62	pub fn write_between(f: &mut File) {

minorhacks_chess 0.1.3/src/gen_tables/king.rs

68	// Write the KING_MOVES array to the specified file.
69	#[allow(clippy::needless_range_loop)]
70	pub fn write_king_moves(f: &mut File) {

minorhacks_chess 0.1.3/src/gen_tables/knights.rs

30	// Write the KNIGHT_MOVES array to the specified file.
31	#[allow(clippy::needless_range_loop)]
32	pub fn write_knight_moves(f: &mut File) {

minorhacks_chess 0.1.3/src/gen_tables/lines.rs

49	// Write the LINE array to the specified file.
50	#[allow(clippy::needless_range_loop)]
51	pub fn write_lines(f: &mut File) {

minorhacks_chess 0.1.3/src/gen_tables/magic.rs

137	// Write the MAGIC_NUMBERS and MOVES arrays to the specified file.
138	#[allow(clippy::needless_range_loop)]
139	pub fn write_magic(f: &mut File) {

minorhacks_chess 0.1.3/src/gen_tables/pawns.rs

88	// Write the PAWN_MOVES array to the specified file.
89	#[allow(clippy::needless_range_loop)]
90	pub fn write_pawn_moves(f: &mut File) {
103	// Write the PAWN_ATTACKS array to the specified file.
104	#[allow(clippy::needless_range_loop)]
105	pub fn write_pawn_attacks(f: &mut File) {

minorhacks_chess 0.1.3/src/gen_tables/ranks_files.rs

57	// Write the FILES array to the specified file.
58	#[allow(clippy::needless_range_loop)]
59	pub fn write_bitboard_data(f: &mut File) {

minorhacks_chess 0.1.3/src/gen_tables/rays.rs

54	// Write the RAYS array to the specified file.
55	#[allow(clippy::needless_range_loop)]
56	pub fn write_rays(f: &mut File) {

mkups 0.1.0/src/apply.rs

115	let n = read_nonzero(reader, buf, patch)?;
116	#[allow(clippy::needless_range_loop)]
117	for i in 0..n {

mockd 0.4.1/src/colour/mod.rs

65	#[allow(clippy::needless_range_loop)]
66	for x in 0..5 {

mokuroku 3.1.0/src/base32.rs

48	// replace the trailing zeros filled in above with padding
49	#[allow(clippy::needless_range_loop)]
50	for idx in data_len + 1..output_len {

molt 0.3.1/src/expr.rs

1175	/// Parses math functions, returning the evaluated value.
1176	#[allow(clippy::needless_range_loop)]
1177	fn expr_math_func(interp: &mut Interp, info: &mut ExprInfo, func_name: &str) -> DatumResult {

molt-ng 0.3.2/src/expr.rs

1175	/// Parses math functions, returning the evaluated value.
1176	#[allow(clippy::needless_range_loop)]
1177	fn expr_math_func(interp: &mut Interp, info: &mut ExprInfo, func_name: &str) -> DatumResult {

mongodb-arrow-connector 0.7.0/src/writer.rs

221	.expect("Unable to unwrap array");
222	#[allow(clippy::needless_range_loop)]
223	for i in 0..len {
239	.expect("Unable to unwrap array");
240	#[allow(clippy::needless_range_loop)]
241	for i in 0..len {
252	.expect("Unable to unwrap array");
253	#[allow(clippy::needless_range_loop)]
254	for i in 0..len {
265	.expect("Unable to unwrap array");
266	#[allow(clippy::needless_range_loop)]
267	for i in 0..len {
277	.expect("Unable to unwrap array");
278	#[allow(clippy::needless_range_loop)]
279	for i in 0..len {

mongodb-cursor-pagination 0.2.9/src/lib.rs

                let mut queries: Vec<Document> = Vec::new();
                #[allow(clippy::needless_range_loop)]
                for i in 0..keys.len() {
                    let mut query = query_doc.clone();
                    #[allow(clippy::needless_range_loop)]
                    for j in 0..i {

moscato 0.1.2/src/truetype/var.rs

255	/// for the deltas associated with this region.
256	#[allow(clippy::needless_range_loop)]
257	fn compute_scalar(&self, coords: &[i16]) -> Fixed {

mpl-candy-machine 4.5.0/src/processor/mint.rs

853	#[allow(clippy::needless_range_loop)]
854	for i in 4..4 + MAX_NAME_LENGTH {
861	#[allow(clippy::needless_range_loop)]
862	for i in 8 + MAX_NAME_LENGTH..8 + MAX_NAME_LENGTH + MAX_URI_LENGTH {

mpl-candy-machine 4.5.0/tests/core/helpers.rs

227	#[allow(clippy::needless_range_loop)]
228	for i in 0..allocations.len() {

multiversx-sdk 0.1.1/src/crypto/edwards25519/extended_group_element.rs

41	// a[31] <= 127
42	#[allow(clippy::needless_range_loop)]
43	pub fn ge_scalar_mult_base(&mut self, a: [u8; 32]) {

muta-keypair 0.1.0-alpha.1/src/main.rs

33	#[allow(clippy::needless_range_loop)]
34	pub fn main() {

mwalib 0.16.0/examples/mwalib-sum-first-fine-channel-gpubox-hdus.rs

28	#[cfg(not(tarpaulin_include))]
29	#[allow(clippy::needless_range_loop)] // Ignoring this, as it is a false positive
30	fn main() -> Result<(), anyhow::Error> {

naga 0.11.0/src/front/glsl/context.rs

435	#[allow(clippy::needless_range_loop)]
436	for index in 0..size {

ndarray 0.15.6/examples/convo.rs

31	let mut conv = F::zero();
32	#[allow(clippy::needless_range_loop)]
33	for k in 0..3 {

neptune 8.1.0/src/matrix.rs

154	#[allow(clippy::needless_range_loop)]
155	pub fn transpose<F: PrimeField>(matrix: &Matrix<F>) -> Matrix<F> {
168	#[allow(clippy::needless_range_loop)]
169	pub fn make_identity<F: PrimeField>(size: usize) -> Matrix<F> {

northstar-runtime 0.7.0/src/npk/dm_verity.rs

161	let mut offset = 0;
162	#[allow(clippy::needless_range_loop)]
163	for m in (n + 1)..num_levels {

nova-snark 0.12.0/src/gadgets/utils.rs

130	// Now enforce that the limbs are all equal to the constants
131	#[allow(clippy::needless_range_loop)]
132	for i in 0..n_limbs {

nsga 0.1.1/src/optimizer.rs

202	#[allow(clippy::needless_range_loop)]
203	fn sort(&self, pop: Vec<Candidate<S>>) -> Vec<Candidate<S>> {

nu-parser 0.75.0/src/parser.rs

559	{
560	#[allow(clippy::needless_range_loop)]
561	for span_idx in spans_idx..spans.len() {

osrs-cli 2.0.0/src/commands/calc/stew.rs

157	// to differentiate 0-indexed (usize) from 1-indexed (newtypes).
158	#[allow(clippy::needless_range_loop)]
159	for doses_per_stew in 1..=MAX_DOSES {

osshkeys 0.6.2/src/keys/mod.rs

605	// Output content.
606	#[allow(clippy::needless_range_loop)]
607	for y in 0..FLDSIZE_Y {

pallas-machines 0.4.0/src/payloads.rs

96	#[allow(clippy::needless_range_loop)]
97	for i in 0..(len - 1) {

para-cli 0.1.0/src/ppm.rs

367	// Loop through layers
368	#[allow(clippy::needless_range_loop)]
369	for layer in 0..2 {
486	#[allow(clippy::needless_range_loop)]
487	for y in 0..192 {

parity-plonk 0.2.0/src/fft/domain.rs

202	#[allow(clippy::needless_range_loop)]
203	/// Evaluate all the lagrange polynomials defined by this domain at the

parol 0.16.0/src/transformation/canonicalization.rs

664	#[allow(clippy::needless_range_loop)]
665	for pi in 0..productions.len() {

petgraph 0.6.2/src/algo/floyd_warshall.rs

8

#[allow(clippy::type_complexity, clippy::needless_range_loop)]

9

/// \[Generic\] [Floyd–Warshall algorithm](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm) is an algorithm for all pairs shortest path problem

plonkup 0.9.2/src/fft/domain.rs

207	#[allow(clippy::needless_range_loop)]
208	/// Evaluate all the lagrange polynomials defined by this domain at the

pmd_script_entry_list 1.0.0/src/script_entry_list.rs

126	let mut flags = [0; 4];
127	#[allow(clippy::needless_range_loop)]
128	for flag_id in 0..4 {

pmtiles2 0.1.6/src/directory.rs

97	/// ```
98	#[allow(clippy::needless_range_loop)]
99	pub fn from_reader(

postcss 0.0.2/src/tokenizer.rs

400	let bytes = s.as_bytes();
401	#[allow(clippy::needless_range_loop)]
402	for i in 1..bytes.len() {

presser 0.3.1/src/lib.rs

394	#[allow(clippy::needless_range_loop)]
395	for i in 0..len {

prettytable 0.10.0/src/lib.rs

123	let mut col_width = vec![0usize; colnum];
124	#[allow(clippy::needless_range_loop)]
125	for i in 0..colnum {

prettytable-rs 0.10.0/src/lib.rs

123	let mut col_width = vec![0usize; colnum];
124	#[allow(clippy::needless_range_loop)]
125	for i in 0..colnum {

prio 0.10.0/src/client.rs

223	// set g_i = f_i - 1
224	#[allow(clippy::needless_range_loop)]
225	for i in 0..dimension {

prio 0.10.0/src/fft.rs

50	#[allow(clippy::needless_range_loop)]
51	for i in 0..size {
199	// every odd element is set to 0.
200	#[allow(clippy::needless_range_loop)]
201	for i in 0..len {

prio 0.10.0/src/flp.rs

218	/// * `joint_rand` is the randomness shared by the prover and verifier.
219	#[allow(clippy::needless_range_loop)]
220	fn prove(
469	/// Returns true if the verifier message indicates that the input from which it was generated is valid.
470	#[allow(clippy::needless_range_loop)]
471	fn decide(&self, verifier: &[Self::Field]) -> Result<bool, FlpError> {
583	#[allow(clippy::needless_range_loop)]
584	for wire in 0..f_vals.len() {
598	fn call(&mut self, inp: &[F]) -> Result<F, FlpError> {
599	#[allow(clippy::needless_range_loop)]
600	for wire in 0..inp.len() {
689	fn call(&mut self, inp: &[F]) -> Result<F, FlpError> {
690	#[allow(clippy::needless_range_loop)]
691	for wire in 0..inp.len() {

prio 0.10.0/src/polynomial.rs

149	let n_inverse = F::from(F::Integer::try_from(n_points).unwrap()).inv();
150	#[allow(clippy::needless_range_loop)]
151	for i in 0..n_points {
376	#[allow(clippy::needless_range_loop)]
377	for i in 0..count {

pyflow 0.3.1/src/files.rs

176	if dep_start != 0 {
177	#[allow(clippy::needless_range_loop)]
178	for i in dep_start..=dep_end {
187	if dev_dep_start != 0 {
188	#[allow(clippy::needless_range_loop)]
189	for i in dev_dep_start..=dev_dep_end {

qmat 0.5.1/tests/mat.rs

18	#[allow(clippy::needless_range_loop)]
19	for i in 0..6 {

qmat 0.5.1/tests/new_matrix.rs

14	let mut data = [0; 28];
15	#[allow(clippy::needless_range_loop)] // for whatever reason didn't work with an iterator
16	for i in 0..28 {

qsv 0.87.0/src/cmd/excel.rs

200	};
201	#[allow(clippy::needless_range_loop)]
202	for i in 0..num_sheets {

quicklz 0.3.1/src/lib.rs

126	) {
127	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
128	for i in start..end {
576	feature = "cargo-clippy",
577	allow(needless_range_loop)
578	)]
610	feature = "cargo-clippy",
611	allow(needless_range_loop)
612	)]

rabbit 0.4.1/src/lib.rs

173	fn counter_update(&mut self) {
174	#[allow(unused_mut, clippy::needless_range_loop)]
175	for j in 0..8 {
188	#[allow(clippy::needless_range_loop)]
189	for j in 0..8 {

raft-engine 0.3.0/src/swappy_allocator.rs

1059	total_shift += shift;
1060	#[allow(clippy::needless_range_loop)]
1061	for i in 0..n {

randomx-rs 1.1.9/src/lib.rs

401

    /// `input` is an array of a sequence of u8 to be hashed.

402

    #[allow(clippy::needless_range_loop)] // Range loop is not only for indexing `input`

403

    pub fn calculate_hash_set(&self, input: &[&[u8]]) -> Result<Vec<Vec<u8>>, RandomXError> {

rant 4.0.0-alpha.33/src/stdlib/collections.rs

253	#[allow(clippy::needless_range_loop)]
254	pub fn oxford_join(vm: &mut VM, (comma, conj, comma_conj, list): (RantValue, RantValue, RantValue, Vec<RantValue>)) -> RantStdResult {

raptorq 1.7.0/src/base.rs

262	#[allow(clippy::needless_range_loop)]
263	for d in 1..f.len() {

raptorq 1.7.0/src/constraint_matrix.rs

66	// with the lower right 1 in GAMMA
67	#[allow(clippy::needless_range_loop)]
68	for i in 0..H {
76	for j in (0..=(Kprime + S - 2)).rev() {
77	#[allow(clippy::needless_range_loop)]
78	for i in 0..H {
89	// Copy G_HDPC into matrix
90	#[allow(clippy::needless_range_loop)]
91	for i in 0..H {
92	#[allow(clippy::needless_range_loop)]
93	for j in 0..(Kprime + S) {
190	let mut mt: Vec<Vec<u8>> = vec![vec![0; Kprime + S]; H];
191	#[allow(clippy::needless_range_loop)]
192	for i in 0..H {

raptorq 1.7.0/src/pi_solver.rs

1301	let mut result = Vec::with_capacity(self.L);
1302	#[allow(clippy::needless_range_loop)]
1303	for i in 0..self.L {

raptorq 1.7.0/src/sparse_matrix.rs

107	let mut row_mapping = vec![0; height];
108	#[allow(clippy::needless_range_loop)]
109	for i in 0..height {
111	}
112	#[allow(clippy::needless_range_loop)]
113	for i in 0..width {

reed-solomon-16 0.1.0/src/engine/tables.rs

81	/// Initializes and returns [`Exp`] and [`Log`] tables.
82	#[allow(clippy::needless_range_loop)]
83	pub fn initialize_exp_log() -> (&'static Exp, &'static Log) {
162	/// Initializes and returns [`Skew`] table.
163	#[allow(clippy::needless_range_loop)]
164	pub fn initialize_skew() -> &'static Skew {

requestty-ui 0.5.0/src/select/mod.rs

400	#[allow(clippy::needless_range_loop)]
401	for i in 1..heights.len() {

reverie-zk 0.3.2/src/algebra/z64/domain.rs

69	{
70	#[allow(clippy::needless_range_loop)]
71	for i in 0..batch::NSHARES {

ring 0.17.0-alpha.11/tests/aead_tests.rs

260	} else {
261	#[allow(clippy::needless_range_loop)]
262	for b in 0..more_comprehensive_in_prefix_lengths.len() {

ropey 1.5.1/src/tree/node_children.rs

284	#[allow(clippy::needless_range_loop)]
285	pub fn combined_info(&self) -> TextInfo {

rp2040-hal 0.7.0/src/sio.rs

658	let mut result = [false; 32];
659	#[allow(clippy::needless_range_loop)]
660	for i in 0..32 {

ruffbox_synth 0.6.0/src/building_blocks/routing.rs

61	/// pan mono to stereo
62	#[allow(clippy::needless_range_loop)]
63	pub fn process_block(

rustgym 0.2.0/src/lib.rs

100	#[allow(clippy::collapsible_if)]
101	#[allow(clippy::needless_range_loop)]
102	#[allow(clippy::too_many_arguments)]
107	#[allow(clippy::collapsible_if)]
108	#[allow(clippy::needless_range_loop)]
109	#[allow(clippy::too_many_arguments)]

rustler 0.27.0/build.rs

61	#[allow(clippy::needless_range_loop)]
62	for i in 0..=index {

rv 0.15.0-rc.1/src/misc/ks.rs

418	// They are not rusty. Please feel free to make them rusty 😘
419	#[allow(clippy::needless_range_loop)]
420	#[allow(clippy::many_single_char_names)]

safe-zk-token-sdk 1.14.3/src/range_proof/util.rs

32	let mut out = vec![Scalar::zero(); n];
33	#[allow(clippy::needless_range_loop)]
34	for i in 0..n {

safe-zk-token-sdk 1.14.3/src/sigma_proofs/fee_proof.rs

448	#[allow(clippy::needless_range_loop)]
449	fn conditional_select_ristretto(

safecoin-runtime 1.14.3/src/accounts_db.rs

10336	#[allow(clippy::needless_range_loop)]
10337	fn modify_accounts(

secp256kfun 0.8.2/src/vendor/k256/scalar/scalar_4x64.rs

332	if small_shift == 0 {
333	#[allow(clippy::needless_range_loop)]
334	#[allow(clippy::manual_memcpy)]
338	} else {
339	#[allow(clippy::needless_range_loop)]
340	for i in 0..(4 - full_shifts) {

secp256kfun 0.8.2/src/vendor/k256/scalar/scalar_8x32.rs

446	if small_shift == 0 {
447	#[allow(clippy::needless_range_loop)]
448	#[allow(clippy::manual_memcpy)]
452	} else {
453	#[allow(clippy::needless_range_loop)]
454	for i in 0..(8 - full_shifts) {

secp256kfun_k256_backend 2.0.1/src/arithmetic/scalar/scalar_4x64.rs

341	if small_shift == 0 {
342	#[allow(clippy::needless_range_loop)]
343	#[allow(clippy::manual_memcpy)]
347	} else {
348	#[allow(clippy::needless_range_loop)]
349	for i in 0..(4 - full_shifts) {

secp256kfun_k256_backend 2.0.1/src/arithmetic/scalar/scalar_8x32.rs

451	if small_shift == 0 {
452	#[allow(clippy::needless_range_loop)]
453	#[allow(clippy::manual_memcpy)]
457	} else {
458	#[allow(clippy::needless_range_loop)]
459	for i in 0..(8 - full_shifts) {

seq2xypic 0.1.1/src/main.rs

87	#[allow(clippy::needless_range_loop)] // More readable like this.
88	fn print_note(
166	#[allow(clippy::needless_range_loop)] // The loops are clearer.
167	pub fn print(&self, nodes: &Nodes, verticals: &mut Vec<usize>) {

serde_someip 0.2.3/src/ser.rs

54	//rather than the elements of the array, but clippy disagrees...
55	#[allow(clippy::needless_range_loop)]
56	for i in 0..size {
63	{
64	#[allow(clippy::needless_range_loop)]
65	for i in 0..size {

shabal 0.4.1/src/core_api.rs

27	impl ShabalVarCore {
28	#[allow(clippy::needless_range_loop)]
29	fn add_m(&mut self, m: &M) {
35	#[allow(clippy::needless_range_loop)]
36	fn sub_m(&mut self, m: &M) {
190	#[inline]
191	#[allow(clippy::needless_range_loop)]
192	fn new(output_size: usize) -> Result<Self, InvalidOutputSize> {

shipyard 0.6.2/src/scheduler/workload.rs

926	#[allow(clippy::needless_range_loop)]
927	fn dependencies(

shor 1.0.5/src/quantum.rs

115	#[allow(clippy::needless_range_loop)]
116	pub fn apply(&mut self, g: Gate) {
194	#[allow(clippy::needless_range_loop)]
195	fn tensor(m: Gate, n: Rc<Gate>) -> Gate {
367	#[allow(clippy::needless_range_loop)]
368	fn transpose(g: Gate) -> Gate {
384	#[allow(clippy::needless_range_loop)]
385	fn conjugate(g: Gate) -> Gate {

signature_bbs_plus 0.37.0/src/pok_signature.rs

83	#[allow(clippy::needless_range_loop)]
84	for i in 0..generators.len() {

signature_bbs_plus 0.37.0/src/pok_signature_proof.rs

92	#[allow(clippy::needless_range_loop)]
93	for i in 0..proofs1.len() {

signature_bbs_plus 0.37.0/src/signature.rs

63	#[allow(clippy::needless_range_loop)]
64	for i in 0..arr.len() {

signature_core 0.37.0/src/proof_committed_builder.rs

141	#[allow(clippy::needless_range_loop)]
142	for i in 0..self.cache.scalars.len() {

signature_ps 0.35.0/src/blind_signature.rs

63	#[allow(clippy::needless_range_loop)]
64	for i in 0..arr.len() {

signature_ps 0.35.0/src/pok_signature.rs

51	#[allow(clippy::needless_range_loop)]
52	for i in 0..messages.len() {

signature_ps 0.35.0/src/signature.rs

57	let mut arr = [0u8; Signature::BYTES];
58	#[allow(clippy::needless_range_loop)]
59	for i in 0..arr.len() {
121	#[allow(clippy::needless_range_loop)]
122	for i in 0..msgs.len() {
154	#[allow(clippy::needless_range_loop)]
155	for i in 0..msgs.len() {

simple_libc 0.5.0/src/net/abstract_unix.rs

102	// Replace any NULL bytes
103	#[allow(clippy::needless_range_loop)]
104	for i in 1..(name_vec.len()) {

smallint 0.2.2/src/logic.rs

104	let mut v = i;
105	#[allow(clippy::needless_range_loop)]
106	for r in 0..4 {
154	let mut v = i;
155	#[allow(clippy::needless_range_loop)]
156	for r in 0..4 {

smallint 0.2.2/src/ops.rs

95	let mut v = t;
96	#[allow(clippy::needless_range_loop)]
97	for r in 0..4 {
114	let mut v = i;
115	#[allow(clippy::needless_range_loop)]
116	for r in 0..4 {
246	let mut v = i;
247	#[allow(clippy::needless_range_loop)]
248	for r in 0..4 {
334	#[allow(clippy::needless_range_loop)]
335	for i in 0..l2 {
352	#[allow(clippy::needless_range_loop)]
353	for i in 0..l1 {

smarty_pants 1.0.1/src/neural_network.rs

89	// This is allowed becuase I couldn't find a way to implement clippy's suggestion without doing something ridiculous.
90	#[allow(clippy::needless_range_loop)]
91	for output in 0..self.output_weights.len() {

sn_farming 0.1.0/src/calculation.rs

108	#[allow(clippy::needless_range_loop)]
109	/// Distribute the reward

sn_transfers 0.8.1/src/actor.rs

723	#[allow(clippy::needless_range_loop)]
724	#[test]

snarkvm-fields 0.9.11/src/traits/poseidon_grain_lfsr.rs

86	#[allow(clippy::needless_range_loop)]
87	// b50, ..., b79 are set to 1

snarkvm-marlin 0.8.0/src/fiat_shamir/fiat_shamir_algebraic_sponge_gadget.rs

266	#[allow(clippy::needless_range_loop)]
267	for k in 0..params.num_limbs {

solana 0.18.0-pre1/src/leader_schedule_cache.rs

98	// but leader_schedule doesn't implement Iter...
99	#[allow(clippy::needless_range_loop)]
100	for i in start_index..bank.get_slots_in_epoch(epoch) {

solana-runtime 1.14.13/src/accounts_db.rs

10322	#[allow(clippy::needless_range_loop)]
10323	fn modify_accounts(

solana-zk-token-sdk 1.14.13/src/range_proof/util.rs

32	let mut out = vec![Scalar::zero(); n];
33	#[allow(clippy::needless_range_loop)]
34	for i in 0..n {

solana-zk-token-sdk 1.14.13/src/sigma_proofs/fee_proof.rs

453	#[allow(clippy::needless_range_loop)]
454	fn conditional_select_ristretto(

solang 0.2.1/tests/substrate_tests/arrays.rs

172	#[allow(clippy::needless_range_loop)]
173	for i in 0..a.len() {

sp-ropey 0.2.0/src/tree/node_children.rs

288	#[allow(clippy::needless_range_loop)]
289	pub fn combined_info(&self) -> TextInfo {

spl-zk-token-sdk 0.1.0/src/range_proof/util.rs

32	let mut out = vec![Scalar::zero(); n];
33	#[allow(clippy::needless_range_loop)]
34	for i in 0..n {

spreadsheet-ods 0.15.0/src/lib.rs

2792	/// Create a currency value.
2793	#[allow(clippy::needless_range_loop)]
2794	pub fn new_currency<S: AsRef<str>>(cur: S, value: f64) -> Self {

sss-rs 0.9.1/src/basic_sharing.rs

217

/// **matrix:** The matrix to be transposed, must be a valid matrix else an error is returned.

218

#[allow(clippy::needless_range_loop)]

219

pub fn transpose_vec_matrix<T: Clone>(matrix: Vec<Vec<T>>) -> Result<Vec<Vec<T>>, Error> {

sssync 0.1.1/src/hash.rs

9	#[allow(clippy::needless_range_loop)]
10	fn u128_to_byte_array(n: u128) -> [u8; 16] {

starlark 0.8.0/src/eval/bc/instr_impl.rs

263	let mut values = MaybeUninit::uninit();
264	#[allow(clippy::needless_range_loop)]
265	for i in 0..N {

storage-proofs-porep 12.0.0/src/stacked/vanilla/proof.rs

506	#[allow(clippy::needless_range_loop)]
507	#[cfg(any(feature = "cuda", feature = "opencl"))]

streebog 0.10.2/src/core_api.rs

58	#[allow(clippy::needless_range_loop)]
59	for i in 0..12 {

superdiff 2.1.2/src/comp.rs

204	/// This algorithm runs at a time complexity of O(mn).
205	#[allow(clippy::needless_range_loop)]
206	pub fn levenshtein_distance(x: &str, y: &str, threshold: usize) -> usize {

swarm-bot 0.3.4/src/client/pathfind/incremental/mod.rs

297	#[allow(clippy::needless_range_loop)]
298	for i in 0..state.meta_heuristics.len() {

swash 0.1.6/src/scale/cff/cff.rs

1357	#[allow(clippy::needless_range_loop)]
1358	fn compute_scalars(data: &BlendData, outer: u16, scalars: &mut [f32]) -> Option<(bool, usize)> {

swash 0.1.6/src/scale/glyf/var.rs

260	/// for the deltas associated with this region.
261	#[allow(clippy::needless_range_loop)]
262	fn compute_scalar(&self, coords: &[i16]) -> Fixed {

swash 0.1.6/src/shape/buffer.rs

541	#[allow(clippy::needless_range_loop)]
542	pub fn reorder_complex(glyphs: &mut [GlyphData], buf: &mut Vec<GlyphData>, order: &mut Vec<usize>) {

tabled 0.10.0/examples/matrix.rs

9	#[allow(clippy::needless_range_loop)]
10	for i in 0..N {

tabulate 1.2.0/src/lib.rs

157	}
158	#[allow(clippy::needless_range_loop)]
159	for i in columns.len()..row.len() {

tangram_features 0.7.0/bag_of_words.rs

141	let mut feature_values_sum_of_squares = 0.0;
142	#[allow(clippy::needless_range_loop)]
143	for ngram_index in 0..self.ngrams.len() {

tari_core 0.8.1/src/proof_of_work/monero_rx.rs

125	/// Tree hash algorithm in monero
126	#[allow(clippy::needless_range_loop)]
127	pub fn tree_hash(hashes: &[Hash]) -> Result<Hash, MergeMineError> {

tari_utilities 0.3.0/src/ciphers/chacha20.rs

80

    /// Construct an initial state from a 128-bit constant, 256-bit key, 96-bit nonce and a 32-bit block counter

81

    #[allow(clippy::needless_range_loop)]

82

    fn construct_state(key: &[u8; 32], nonce: &[u8; 12], counter: u32) -> [u32; 16] {

tari_utilities 0.3.0/src/lib.rs

23	#[allow(clippy::needless_range_loop)]
24	pub mod bit;

termimad 0.20.6/src/tbl.rs

79	#[allow(clippy::needless_range_loop)]
80	impl Table {

test-curve25519-dalek 4.0.0-pre.17/src/backend/serial/scalar_mul/precomputed_straus.rs

101	#[allow(clippy::needless_range_loop)]
102	for i in 0..sp {

test-curve25519-dalek 4.0.0-pre.17/src/backend/vector/avx2/field.rs

345	let low_26_bits = (1 << 26) - 1;
346	#[allow(clippy::needless_range_loop)]
347	for i in 0..5 {

test-curve25519-dalek 4.0.0-pre.17/src/backend/vector/scalar_mul/precomputed_straus.rs

98	#[allow(clippy::needless_range_loop)]
99	for i in 0..sp {

test-curve25519-dalek 4.0.0-pre.17/src/scalar.rs

397	let mut bytes = [0u8; 32];
398	#[allow(clippy::needless_range_loop)]
399	for i in 0..32 {
1070	let digits_count = (256 + w - 1) / w;
1071	#[allow(clippy::needless_range_loop)]
1072	for i in 0..digits_count {

tgba 0.3.0/src/cpu.rs

214	#[allow(clippy::needless_range_loop)]
215	for i in 0..16 {
226	#[allow(clippy::needless_range_loop)]
227	for i in 0..16 {
2374	#[allow(clippy::needless_range_loop)]
2375	for i in 0..=14 {

thyme 0.6.0/src/image.rs

236	for y in 0..4 {
237	#[allow(clippy::needless_range_loop)]
238	for x in 0..4 {
251	for y in 0..2 {
252	#[allow(clippy::needless_range_loop)]
253	for x in 0..4 {
266	for y in 0..4 {
267	#[allow(clippy::needless_range_loop)]
268	for x in 0..2 {

tiny-bench 0.2.0/examples/bad_sort.rs

11	#[allow(clippy::needless_range_loop)]
12	fn bad_sort(mut v: Vec<u32>) -> Vec<u32> {

tookey-libtss 1.2.0/src/ecdsa/blame.rs

207	#[allow(clippy::needless_range_loop)]
208	for i in 0..len {
384	#[allow(clippy::needless_range_loop)]
385	for i in 0..len {
393	// check zero knowledge proof
394	#[allow(clippy::needless_range_loop)]
395	for i in 0..len {

transform-matrix 0.1.1/src/matrix.rs

78	#[allow(clippy::needless_range_loop)]
79	pub fn multiply(m1: Matrix, m2: Matrix) -> Matrix {

triton-vm 0.14.0/src/state.rs

104	#[allow(clippy::needless_range_loop)]
105	impl<'pgm> VMState<'pgm> {

tsproto-types 0.1.0/src/crypto.rs

354	// Xor first 100 bytes with a static value
355	#[allow(clippy::needless_range_loop)]
356	for i in 0..cmp::min(data.len(), 100) {
408	// Xor first 100 bytes with a static value
409	#[allow(clippy::needless_range_loop)]
410	for i in 0..cmp::min(data.len(), 100) {

tvis 0.15.3/src/input/windows.rs

222	#[cfg_attr(feature = "cargo-clippy",
223	allow(needless_range_loop, needless_pass_by_value))]
224	fn event_loop(tx: Sender<Box<Event>>) -> Result<()> {

twenty-first 0.15.0/src/shared_math/tip5.rs

162	#[allow(clippy::needless_range_loop)] // faster like so
163	for i in 0..8 {

unic-bidi 0.9.0/src/bidi_info.rs

280	/// <https://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels>
281	#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
282	pub fn visual_runs(

vapoursynth 0.4.0/examples/vspipe.rs

265	let format = frame.format();
266	#[allow(clippy::needless_range_loop)]
267	for plane in 0..format.plane_count() {

video-resize 0.1.1/src/resize/mod.rs

44	unsafe {
45	#[allow(clippy::needless_range_loop)]
46	for j in 0..dest_width {

virt 0.2.12/src/connect.rs

396	/// ```
397	#[allow(clippy::needless_range_loop)]
398	pub fn list_domains(&self) -> Result<Vec<u32>, Error> {
424	/// ```
425	#[allow(clippy::needless_range_loop)]
426	pub fn list_interfaces(&self) -> Result<Vec<String>, Error> {
452	/// ```
453	#[allow(clippy::needless_range_loop)]
454	pub fn list_networks(&self) -> Result<Vec<String>, Error> {
470	#[allow(clippy::needless_range_loop)]
471	pub fn list_nw_filters(&self) -> Result<Vec<String>, Error> {
487	#[allow(clippy::needless_range_loop)]
488	pub fn list_secrets(&self) -> Result<Vec<String>, Error> {

virt 0.2.12/src/nodedev.rs

213	#[allow(clippy::needless_range_loop)]
214	pub fn list_caps(&self) -> Result<Vec<String>, Error> {

virt 0.2.12/src/storage_pool.rs

171	#[allow(clippy::needless_range_loop)]
172	pub fn list_volumes(&self) -> Result<Vec<String>, Error> {

vpncloud 2.3.0/src/beacon.rs

72	#[allow(clippy::needless_range_loop)]
73	fn mask_with_keystream(&self, data: &mut [u8], type_: u8, seed: u8) {

vpncloud 2.3.0/src/types.rs

101	#[allow(unknown_lints, clippy::needless_range_loop)]
102	fn from_str(text: &str) -> Result<Self, Self::Err> {

vsimd 0.8.0/src/simulation.rs

32	#[allow(clippy::needless_range_loop)]
33	#[inline(always)]
47	#[allow(clippy::needless_range_loop)]
48	#[inline(always)]
57	#[allow(clippy::needless_range_loop)]
58	#[inline(always)]

vtparse 0.6.2/src/lib.rs

579	let limit = self.osc.num_params.min(MAX_OSC);
580	#[allow(clippy::needless_range_loop)]
581	for i in 0..limit - 1 {

waffles-solana-runtime 1.15.0/src/accounts_db.rs

11061	#[allow(clippy::needless_range_loop)]
11062	fn modify_accounts(

waffles-solana-zk-token-sdk 1.15.0/src/range_proof/util.rs

32	let mut out = vec![Scalar::zero(); n];
33	#[allow(clippy::needless_range_loop)]
34	for i in 0..n {

waffles-solana-zk-token-sdk 1.15.0/src/sigma_proofs/fee_proof.rs

453	#[allow(clippy::needless_range_loop)]
454	fn conditional_select_ristretto(

wasm4fun-fmt 0.1.0/src/fmt.rs

94	// Overwrite with placeholder
95	#[allow(clippy::needless_range_loop)]
96	for i in 0..m {

wasmcloud-host 0.19.0/src/host.rs

689	// getting an iterator of this const produces `&&str` which is a super annoying type
690	#[allow(clippy::needless_range_loop)]
691	for x in 0..RESTRICTED_LABELS.len() {

wasmer-compiler-singlepass 3.2.0-alpha.1/src/emitter_arm64.rs

3550	/* Clippy is wrong about using `i` to index `PARAM_REGS` here. */
3551	#[allow(clippy::needless_range_loop)]
3552	for i in 0..sig.params().len() {

wasmer-compiler-singlepass 3.2.0-alpha.1/src/machine_x64.rs

8093	static PARAM_REGS: &[GPR] = &[GPR::RDX, GPR::R8, GPR::R9];
8094	#[allow(clippy::needless_range_loop)]
8095	for i in 0..sig.params().len() {
8134	static PARAM_REGS: &[GPR] = &[GPR::RSI, GPR::RDX, GPR::RCX, GPR::R8, GPR::R9];
8135	#[allow(clippy::needless_range_loop)]
8136	for i in 0..sig.params().len() {

watchmaker 2.0.0/src/selector/tournament_selector.rs

46	impl<G> Selector<G> for TournamentSelector<G> {
47	#[allow(clippy::needless_range_loop)]
48	fn select(&mut self, _population: &[G], costs: &[f64], partner_indices: &mut [usize]) {

whirlpool 0.10.4/src/compress.rs

23	#[allow(clippy::needless_range_loop)]
24	for r in 0..R {

winter-prover 0.4.2/src/trace/tests.rs

115	let mut trace_state = vec![BaseElement::ZERO; trace_table.main_trace_width()];
116	#[allow(clippy::needless_range_loop)]
117	for i in 0..trace_table.trace_len() {

wlambda 0.8.1/src/util.rs

326	/// strings' lengths.
327	#[allow(clippy::needless_range_loop)]
328	pub fn edit_distance(a: &str, b: &str) -> usize {

woodchipper 1.1.0/src/renderer/interactive/search_bar.rs

266	// iter methods aren't quite sufficient here
267	#[allow(clippy::needless_range_loop)]
268	for i in min..max {

world-map-gen 0.1.1/src/large_gen.rs

67	#[allow(clippy::needless_range_loop)]
68	fn towns(&mut self, altitudes: &[Vec<u8>]) -> HashSet<Pos> {

wt_csv 0.10.0/src/wtcsv/core/wtcsv.rs

39	#[allow(clippy::needless_range_loop)]
40	for i in 0..chars.len() {

yahoo-finance 0.3.0/src/history.rs

27	#[allow(clippy::needless_range_loop)]
28	for i in 0..timestamps.len() {

yatima-core 0.1.1/src/check/ctx.rs

29	pub fn add_mul_ctx(uses: Uses, use_ctx: &mut Ctx, use_ctx2: Ctx) {
30	#[allow(clippy::needless_range_loop)]
31	for i in 0..use_ctx.len() {
38	pub fn add_ctx(use_ctx: &mut Ctx, use_ctx2: Ctx) {
39	#[allow(clippy::needless_range_loop)]
40	for i in 0..use_ctx.len() {
47	pub fn mul_ctx(uses: Uses, use_ctx: &mut Ctx) {
48	#[allow(clippy::needless_range_loop)]
49	for i in 0..use_ctx.len() {
57	let mut rest = use_ctx.clone();
58	#[allow(clippy::needless_range_loop)]
59	for i in 0..use_ctx.len() {

ytop 0.6.2/src/widgets/cpu.rs

105	} else {
106	#[allow(clippy::needless_range_loop)]
107	for i in 0..self.cpu_count {

yuuang_dominators 0.6.3/src/algo/floyd_warshall.rs

10

#[allow(clippy::type_complexity, clippy::needless_range_loop)]

11

/// \[Generic\] [Floyd–Warshall algorithm](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm) is an algorithm for all pairs shortest path problem

yuuang_petgraph 0.6.3/src/algo/floyd_warshall.rs

10

#[allow(clippy::type_complexity, clippy::needless_range_loop)]

11

/// \[Generic\] [Floyd–Warshall algorithm](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm) is an algorithm for all pairs shortest path problem

zero-plonk 0.2.5/src/fft/domain.rs

228	#[allow(clippy::needless_range_loop)]
229	/// Evaluate all the lagrange polynomials defined by this domain at the

zkp-stark 0.2.1/src/algebraic_dag.rs

449	// We want to use `for i in 0..CHUNK_SIZE` for consistency
450	#[allow(clippy::needless_range_loop)]
451	pub(crate) fn init(&mut self, start: usize) {
495	// We want to use `for i in 0..CHUNK_SIZE` for consistency
496	#[allow(clippy::needless_range_loop)]
497	#[inline(never)]

zune-inflate 0.2.42/src/decoder.rs

1447	/// Build the decode table for the precode
1448	#[allow(clippy::needless_range_loop)]
1449	fn build_decode_table_inner(

zvxryb-broadphase 0.1.2/src/geom.rs

33	{
34	#[allow(clippy::needless_range_loop)]
35	for i in 0..Arr::len() {
392	let bounds = &mut result.cell_bounds;
393	#[allow(clippy::needless_range_loop)]
394	for axis in 0..2 {
433	let bounds = &mut result.cell_bounds;
434	#[allow(clippy::needless_range_loop)]
435	for axis in 0..3 {
577	let bounds = &mut result.cell_bounds;
578	#[allow(clippy::needless_range_loop)]
579	for axis in 0..2 {
647	let bounds = &mut result.cell_bounds;
648	#[allow(clippy::needless_range_loop)]
649	for axis in 0..3 {

aes 0.8.2/src/armv8.rs

10	#![allow(clippy::needless_range_loop)]

aes 0.8.2/src/ni/utils.rs

3	// TODO(tarcieri): check performance impact / generated assembly changes
4	#![allow(clippy::needless_range_loop)]

ark-crypto-primitives 0.4.0/src/merkle_tree/mod.rs

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

av-metrics 0.9.0/src/lib.rs

5	#![allow(clippy::cast_lossless)]
6	#![allow(clippy::needless_range_loop)]
7	#![allow(clippy::unreadable_literal)]

awint_core 0.8.0/src/lib.rs

21	// We are using special indexing everywhere
22	#![allow(clippy::needless_range_loop)]
23	// not const and tends to be longer

awint_dag 0.8.0/src/lib.rs

190	#![deny(unsafe_op_in_unsafe_fn)]
191	#![allow(clippy::needless_range_loop)]
192	#![allow(clippy::comparison_chain)]

awint_ext 0.8.0/src/lib.rs

14	// We are using special indexing everywhere
15	#![allow(clippy::needless_range_loop)]
16	// not const and tends to be longer

awint_internals 0.8.0/src/lib.rs

14	#![allow(clippy::manual_range_contains)]
15	#![allow(clippy::needless_range_loop)]

awint_macro_internals 0.8.0/src/lib.rs

6	#![allow(clippy::needless_range_loop)]
7	#![allow(clippy::comparison_chain)]

bevy_crevice 0.7.0/src/lib.rs

4	clippy::len_without_is_empty,
5	clippy::needless_range_loop,
6	clippy::all,

binreader 0.2.1/src/lib.rs

23	#![allow(clippy::needless_range_loop)]
24	use binreader_macros::make_number_methods;

blocking 1.3.0/tests/unblock.rs

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

buddy-alloc 0.4.1/src/buddy_alloc.rs

7	#![allow(clippy::needless_range_loop)]

caminos-lib 0.5.2/src/lib.rs

290

	// What is the more appropiate way to iterate a couple arrays of same size, while also using the index itself?

291

	#![allow(clippy::needless_range_loop)]

292

	// I have several cases that seem cleaner without collapsing.

chacha20 0.9.0/src/lib.rs

112	#![warn(missing_docs, rust_2018_idioms, trivial_casts, unused_qualifications)]
113	#![allow(clippy::needless_range_loop)]

chipmunk-sdl2 1.0.0/src/drivers/display.rs

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

cosmian_kyber 0.1.0/src/avx2/fips202.rs

1	#![allow(clippy::needless_range_loop, dead_code)]
2	use crate::symmetric::KeccakState;

cosmian_kyber 0.1.0/src/reference/fips202.rs

1	#![allow(clippy::needless_range_loop, dead_code)]

crymap 1.0.1/src/main.rs

23	clippy::too_many_arguments,
24	clippy::needless_range_loop
25	)]

crypto-bigint 0.5.0-pre.3/src/uint.rs

3	#![allow(
4	clippy::needless_range_loop,
5	clippy::many_single_char_names,

cudarc 0.6.1/src/cublas/safe.rs

298	mod tests {
299	#![allow(clippy::needless_range_loop)]

cudarc 0.6.1/src/curand/safe.rs

95	mod tests {
96	#![allow(clippy::needless_range_loop)]

daa 0.5.0/src/lib.rs

25	#![warn(missing_docs, rust_2018_idioms)]
26	#![allow(clippy::needless_range_loop)]

directx_math 0.2.2/src/lib.rs

80	#![allow(clippy::float_cmp)]
81	#![allow(clippy::needless_range_loop)]
82	#![allow(clippy::useless_let_if_seq)]

dtool 0.11.0/src/modules.rs

6	#![allow(clippy::match_like_matches_macro)]
7	#![allow(clippy::needless_range_loop)]
8	#![allow(clippy::useless_format)]

ed25519-compact 2.0.4/src/lib.rs

95	#![allow(
96	clippy::needless_range_loop,
97	clippy::many_single_char_names,

egui 0.20.1/src/containers/scroll_area.rs

6	#![allow(clippy::needless_range_loop)]

encode_unicode 1.0.0/src/lib.rs

52

    clippy::wrong_self_convention,// smaller than pointer

53

    clippy::needless_range_loop,// the suggested iterator chains are less intuitive

54

    clippy::identity_op,// applying a set of opereations with varying arguments to many elements looks nice

feos 0.4.1/src/uvtheory/eos/mod.rs

1	#![allow(clippy::excessive_precision)]
2	#![allow(clippy::needless_range_loop)]

fere 0.0.0/src/graphics/gi/probe_volume.rs

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

fere 0.0.0/src/graphics/glmanager/shader.rs

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

filtration-domination 0.0.1/src/lib.rs

6	#![warn(clippy::needless_pass_by_value)]
7	#![allow(clippy::needless_range_loop)]
8	#![warn(clippy::disallowed_types)]

fundsp 0.12.0/src/lib.rs

12	clippy::double_neg,
13	clippy::needless_range_loop,
14	clippy::manual_range_contains,

fuzzcheck 0.12.1/src/lib.rs

48	#![allow(clippy::type_complexity)]
49	#![allow(clippy::needless_range_loop)]

geodesy 0.9.2/src/op/parsed_parameters.rs

8	#![allow(clippy::needless_range_loop)]
9	use crate::math::FourierCoefficients;

groestl 0.10.1/src/compress1024.rs

1	#![allow(clippy::needless_range_loop)]
2	use crate::table::TABLE;

groestl 0.10.1/src/compress512.rs

1	#![allow(clippy::needless_range_loop)]
2	use crate::table::TABLE;

i2p_snow 0.5.1/tests/general.rs

1	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
2	#![allow(non_snake_case)]

imageproc 0.23.0/src/lib.rs

14	clippy::too_many_arguments,
15	clippy::needless_range_loop,
16	clippy::useless_let_if_seq,

imageproc-patched 0.22.0-unofficial.1-foresterre/src/lib.rs

14	clippy::too_many_arguments,
15	clippy::needless_range_loop,
16	clippy::useless_let_if_seq,

itoap 1.0.1/src/lib.rs

49	#![allow(clippy::many_single_char_names, clippy::needless_range_loop)]
50	#![cfg_attr(docsrs, feature(doc_cfg))]

kas-text 0.6.0/src/display/glyph_pos.rs

10	#![allow(clippy::never_loop)]
11	#![allow(clippy::needless_range_loop)]

kuznyechik 0.8.1/src/lib.rs

30	#![warn(missing_docs, rust_2018_idioms)]
31	#![allow(clippy::needless_range_loop, clippy::transmute_ptr_to_ptr)]

lapce-xi-rope 0.3.1/src/lib.rs

20	clippy::many_single_char_names,
21	clippy::needless_range_loop,
22	clippy::new_without_default,

libsecp256k1-core 0.3.0/src/lib.rs

6	clippy::many_single_char_names,
7	clippy::needless_range_loop,
8	clippy::suspicious_op_assign_impl,

libsecp256k1-gen-genmult 0.3.0/src/lib.rs

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

luacells 0.1.4/src/main.rs

5	clippy::cast_possible_wrap,
6	clippy::needless_range_loop
7	)]

lyon_tessellation 1.0.8/src/stroke.rs

1	// There's a number of cases in this file where this lint just complicates the code.
2	#![allow(clippy::needless_range_loop)]

marmoset 0.9.4/src/core/find.rs

16	#![allow(clippy::needless_range_loop)]

mem-aead-mrs 0.1.1/tests/kat.rs

1	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

memtable-core 0.2.0/src/utils/de/array.rs

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

memtable-core 0.2.0/src/utils/de/table_array.rs

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

memtable-core 0.2.0/src/utils/ser/vec_array.rs

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

minisign 0.7.2/src/crypto/mod.rs

1	#![allow(
2	clippy::needless_range_loop,
3	clippy::many_single_char_names,

miracl_core_bls12381 4.2.2/src/lib.rs

22	#![allow(clippy::many_single_char_names)]
23	#![allow(clippy::needless_range_loop)]
24	#![allow(clippy::manual_memcpy)]

miracl_core_bn254 0.1.0/src/lib.rs

23	#![allow(clippy::many_single_char_names)]
24	#![allow(clippy::needless_range_loop)]
25	#![allow(clippy::manual_memcpy)]

miracl_core_ed25519 0.2.0/src/lib.rs

22	#![allow(clippy::many_single_char_names)]
23	#![allow(clippy::needless_range_loop)]
24	#![allow(clippy::manual_memcpy)]

miracl32 0.1.0-alpha.0/src/lib.rs

22	#![allow(clippy::many_single_char_names)]
23	#![allow(clippy::needless_range_loop)]
24	#![allow(clippy::manual_memcpy)]

mmr-crypto-primitives 0.2.1/src/merkle_tree/mod.rs

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

mmr-crypto-primitives 0.2.1/src/mmr/mod.rs

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

norx 0.1.1/src/lib.rs

1	#![no_std]
2	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

norx 0.1.1/tests/kat.rs

1	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

num-dual 0.6.0/src/lib.rs

34	#![warn(clippy::all)]
35	#![allow(clippy::needless_range_loop)]

p384_rs 0.1.10/src/arithmetic/projective.rs

3	#![allow(clippy::needless_range_loop, clippy::op_ref)]

plonky2 0.1.1/src/bin/generate_constants.rs

3	#![allow(clippy::needless_range_loop)]

plonky2 0.1.1/src/lib.rs

1	#![allow(clippy::too_many_arguments)]
2	#![allow(clippy::needless_range_loop)]
3	#![cfg_attr(not(feature = "std"), no_std)]

plonky2_ecdsa 0.1.0/src/lib.rs

1	#![allow(clippy::needless_range_loop)]
2	#![cfg_attr(not(test), no_std)]

plonky2_field 0.1.0/src/lib.rs

5	#![allow(clippy::len_without_is_empty)]
6	#![allow(clippy::needless_range_loop)]
7	#![allow(clippy::return_self_not_must_use)]

plonky2_u32 0.1.0/src/lib.rs

1	#![allow(clippy::needless_range_loop)]
2	#![no_std]

plonky2_util 0.1.0/src/lib.rs

4	#![allow(clippy::len_without_is_empty)]
5	#![allow(clippy::needless_range_loop)]
6	#![allow(clippy::return_self_not_must_use)]

pqc_kyber 0.4.0/src/avx2/fips202.rs

1	#![allow(clippy::needless_range_loop, dead_code)]
2	use crate::symmetric::KeccakState;

pqc_kyber 0.4.0/src/reference/fips202.rs

1	#![allow(clippy::needless_range_loop, dead_code)]

primeorder 0.12.1/src/projective.rs

3	#![allow(clippy::needless_range_loop, clippy::op_ref)]

q_compress 0.11.4/src/lib.rs

3	//! <https://github.com/mwlon/quantile-compression/tree/main/q_compress>.
4	#![allow(clippy::needless_range_loop)]
5	#![allow(clippy::manual_range_contains)]

rav1e 0.6.3/src/bin/rav1e-ch.rs

13	#![allow(clippy::cognitive_complexity)]
14	#![allow(clippy::needless_range_loop)]
15	#![allow(clippy::too_many_arguments)]

rav1e 0.6.3/src/bin/rav1e.rs

13	#![allow(clippy::cognitive_complexity)]
14	#![allow(clippy::needless_range_loop)]
15	#![allow(clippy::too_many_arguments)]

rav1e 0.6.3/src/lib.rs

40	#![allow(clippy::cognitive_complexity)]
41	#![allow(clippy::needless_range_loop)]
42	#![allow(clippy::too_many_arguments)]

rgb2spec 0.1.1/src/optimize/lower_upper.rs

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

rgb2spec 0.1.1/src/optimize.rs

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

rust-corosync 0.2.4/src/cpg.rs

9	#![allow(clippy::single_match)]
10	#![allow(clippy::needless_range_loop)]
11	#![allow(clippy::type_complexity)]

rust-corosync 0.2.4/src/quorum.rs

9	#![allow(clippy::type_complexity)]
10	#![allow(clippy::needless_range_loop)]
11	#![allow(clippy::single_match)]

rust-corosync 0.2.4/src/votequorum.rs

9	#![allow(clippy::type_complexity)]
10	#![allow(clippy::needless_range_loop)]
11	#![allow(clippy::single_match)]

segsource 0.2.0/src/segment/mod.rs

1	#![allow(clippy::needless_range_loop)]
2	use crate::{

segsource 0.2.0/src/testing/segment.rs

1	#![allow(clippy::needless_range_loop)]
2	use crate::{Endidness, Result, Segment};

serpent 0.5.1/src/lib.rs

21	#![warn(missing_docs, rust_2018_idioms)]
22	#![allow(clippy::needless_range_loop)]

slice-deque 0.3.0/benches/get.rs

1	#![feature(test)]
2	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

slice-deque 0.3.0/benches/index.rs

1	#![feature(test)]
2	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

slice-ring-buffer 0.3.2/benches/get.rs

1	#![feature(test)]
2	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

slice-ring-buffer 0.3.2/benches/index.rs

1	#![feature(test)]
2	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

smartcore 0.3.0/src/linear/elastic_net.rs

1	#![allow(clippy::needless_range_loop)]
2	//! # Elastic Net

snow 0.9.1/tests/general.rs

1	#![cfg(any(feature = "default-resolver", feature = "ring-accelerated"))]
2	#![allow(clippy::needless_range_loop)]
3	#![allow(non_snake_case)]

spartan 0.8.0/src/sparse_mlpoly.rs

2	#![allow(clippy::too_many_arguments)]
3	#![allow(clippy::needless_range_loop)]
4	use super::dense_mlpoly::DensePolynomial;

sparx-cipher 0.1.2/src/block.rs

1	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

summavy 0.25.3/src/lib.rs

8	clippy::module_inception,
9	clippy::needless_range_loop,
10	clippy::bool_assert_comparison

symphonia-bundle-mp3 0.5.2/src/layer3/hybrid_synthesis.rs

8	// Justification: Some loops are better expressed without a range loop.
9	#![allow(clippy::needless_range_loop)]

symphonia-codec-aac 0.5.2/src/lib.rs

16	// TODO: Remove this when refactoring AAC.
17	#![allow(clippy::needless_range_loop)]

system76_ecflash 0.1.3/examples/flash.rs

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

system76_ecflash 0.1.3/examples/isp.rs

2	#![allow(clippy::missing_safety_doc)]
3	#![allow(clippy::needless_range_loop)]

system76_ectool 0.3.8/src/lib.rs

17	#![allow(clippy::missing_safety_doc)]
18	#![allow(clippy::needless_range_loop)]

tiny-skia 0.8.2/src/lib.rs

24	#![allow(clippy::manual_range_contains)]
25	#![allow(clippy::needless_range_loop)]
26	#![allow(clippy::too_many_arguments)]

tokio 1.25.0/tests/rt_common.rs

1	#![allow(clippy::needless_range_loop)]
2	#![warn(rust_2018_idioms)]

tokio_wasi 1.23.0/tests/rt_common.rs

1	#![allow(clippy::needless_range_loop)]
2	#![warn(rust_2018_idioms)]

tract-linalg 0.19.2/src/generic/mmm.rs

1	#![allow(clippy::needless_range_loop)]
2	use num_traits::AsPrimitive;

triple_arena_render 0.7.0/src/grid_process.rs

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

tsxlib 0.1.3/src/timeseries.rs

401	where TRes : Clone + Default
402	{ #![allow(clippy::needless_range_loop)]
403	let mut newvals:Vec<TRes> = Vec::with_capacity(self.values.len());
426	where TRes : Clone + Default
427	{ #![allow(clippy::needless_range_loop)]
428	let mut newvals:Vec<TRes> = Vec::with_capacity(self.values.len());

tui-textarea 0.2.0/src/lib.rs

1	#![allow(clippy::needless_range_loop)]
2	#![forbid(unsafe_code)]

twofish 0.7.1/src/lib.rs

21	#![warn(missing_docs, rust_2018_idioms)]
22	#![allow(clippy::needless_range_loop, clippy::unreadable_literal)]

tx5-demo 0.0.1-alpha.3/src/main.rs

2	#![deny(unsafe_code)]
3	#![allow(clippy::needless_range_loop)]

ux-charts 0.1.3/src/radar.rs

3	#![allow(dead_code)]
4	#![allow(clippy::explicit_counter_loop, clippy::needless_range_loop)]

ux-dx 0.2.1/src/lib.rs

29	clippy::let_unit_value,
30	clippy::needless_range_loop,
31	clippy::iter_nth_zero,

ux-vg 0.2.9/src/lib.rs

10	clippy::unnecessary_to_owned,
11	clippy::needless_range_loop,
12	clippy::manual_map,

v_frame 0.3.3/src/lib.rs

13	#![allow(clippy::cognitive_complexity)]
14	#![allow(clippy::needless_range_loop)]
15	#![allow(clippy::too_many_arguments)]

xi-rope 0.3.0/src/lib.rs

20	clippy::many_single_char_names,
21	clippy::needless_range_loop,
22	clippy::new_without_default,

xorshift 0.1.3/src/xorshift1024.rs

11	#![cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]

zkutil 0.5.0/src/circom_circuit.rs

1	#![allow(clippy::needless_range_loop)]
2	extern crate bellman_ce;

329	let mut queries: Vec<Document> = Vec::new();
330	#[allow(clippy::needless_range_loop)]
331	for i in 0..keys.len() {
332	let mut query = query_doc.clone();
333	#[allow(clippy::needless_range_loop)]
334	for j in 0..i {