add-decimals 1.1.2/src/lib.rs

361	#[cfg(test)]
362	#[allow(clippy::unwrap_used)]
363	mod test {

amaurymartiny-async-smtp 0.1.0/src/sendmail/mod.rs

43	#[allow(clippy::option_unwrap_used)]
44	#[async_trait]

ark-api-ffi 0.17.0-pre.15/src/ffi/world_v0.rs

1564	impl std::fmt::Debug for Message {
1565	#[allow(clippy::unwrap_used)]
1566	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

async-rdma 0.4.0/src/access.rs

108	#[tokio::test]
109	#[allow(clippy::unwrap_used)]
110	async fn flags_into_ibv_access_test() {
118	#[tokio::test]
119	#[allow(clippy::unwrap_used)]
120	async fn ibv_access_into_flags_test() {

async-rdma 0.4.0/src/agent.rs

369	// imm was checked by `is_some()`
370	#[allow(clippy::unwrap_used)]
371	let _task = tokio::spawn(Arc::<Self>::clone(&self).handle_write_imm(imm.unwrap()));

async-rdma 0.4.0/src/context.rs

146	#[cfg(test)]
147	#[allow(unused, clippy::unwrap_used)]
148	mod tests {

async-rdma 0.4.0/src/id.rs

11	// No time can be earlier than Unix Epoch
12	#[allow(clippy::unwrap_used)]
13	let since_the_epoch = start.duration_since(UNIX_EPOCH).unwrap();

async-rdma 0.4.0/src/mr_allocator.rs

697	#[allow(clippy::as_conversions)]
698	#[allow(clippy::unwrap_used)]
699	unsafe extern "C" fn extent_alloc_hook_for_test(
736	#[allow(clippy::as_conversions)]
737	#[allow(clippy::unwrap_used)]
738	unsafe extern "C" fn extent_merge_hook_for_test(
779	#[test]
780	#[allow(clippy::unwrap_used)]
781	fn test_extent_hooks() -> io::Result<()> {
829	#[allow(clippy::as_conversions)]
830	#[allow(clippy::unwrap_used)]
831	fn je_malloxc_test() {
882	#[test]
883	#[allow(clippy::unwrap_used)]
884	fn zeroed_test() -> io::Result<()> {

async-smtp 0.6.0/src/sendmail/mod.rs

51	#[allow(clippy::unwrap_used)]
52	#[async_trait]

Boa 0.13.1/src/builtins/boolean/tests.rs

3	/// Test the correct type is returned from call and construct
4	#[allow(clippy::unwrap_used)]
5	#[test]

Boa 0.13.1/src/builtins/string/tests.rs

95	#[allow(clippy::unwrap_used)]
96	#[test]

Boa 0.13.1/src/syntax/parser/tests.rs

14	/// Checks that the given JavaScript string gives the expected expression.
15	#[allow(clippy::unwrap_used)]
16	#[track_caller]

boa_engine 0.16.0/src/builtins/boolean/tests.rs

3	/// Test the correct type is returned from call and construct
4	#[allow(clippy::unwrap_used)]
5	#[test]

boa_engine 0.16.0/src/builtins/string/tests.rs

96	#[allow(clippy::unwrap_used)]
97	#[test]

boa_engine 0.16.0/src/syntax/parser/tests.rs

20	/// Checks that the given JavaScript string gives the expected expression.
21	#[allow(clippy::unwrap_used)]
22	#[track_caller]

bodhi 2.0.1/src/data/release.rs

288	#[cfg(test)]
289	#[allow(clippy::unwrap_used)]
290	mod tests {

bounded-vec 0.7.1/src/bounded_vec.rs

154	pub fn first(&self) -> &T {
155	#[allow(clippy::unwrap_used)]
156	self.inner.first().unwrap()
169	pub fn last(&self) -> &T {
170	#[allow(clippy::unwrap_used)]
171	self.inner.last().unwrap()
251	}
252	#[allow(clippy::unwrap_used)]
253	Ok(BoundedVec::from_vec(out).unwrap())
283	}
284	#[allow(clippy::unwrap_used)]
285	Ok(BoundedVec::from_vec(out).unwrap())
313	pub fn split_last(&self) -> (&T, &[T]) {
314	#[allow(clippy::unwrap_used)]
315	self.inner.split_last().unwrap()

cl-traits 7.0.0/src/traits/capacity_upper_bound.rs

173	// `E0080` does not allow `T`s larger than `isize::MAX`
174	clippy::unwrap_used,
175	)]

conventional 0.5.0/src/lib.rs

109	#[cfg(test)]
110	#[allow(clippy::result_unwrap_used)]
111	mod tests {

conventional 0.5.0/src/parser.rs

174	#[cfg(test)]
175	#[allow(clippy::result_unwrap_used, clippy::non_ascii_literal)]
176	mod tests {

conventional-commit 0.1.0/src/lib.rs

243	#[cfg(test)]
244	#[allow(clippy::result_unwrap_used)]
245	mod tests {

correspondent 0.3.1/src/nsd/windows/mod.rs

9	#[allow(clippy::semicolon_if_nothing_returned)]
10	#[allow(clippy::unwrap_used)]
11	mod bindings;

cosmrs 0.11.0/src/dev.rs

108	// TODO(tarcieri): better conversion or unified `Hash` type, see tendermint-rs#1221
109	#[allow(clippy::unwrap_used)]
110	let tx_hash = tendermint::Hash::Sha256(tx_hash.as_ref().try_into().unwrap());

cross 0.2.4/src/tests.rs

16	let mut msg_info = crate::shell::Verbosity::Verbose.into();
17	#[allow(clippy::unwrap_used)]
18	WORKSPACE.get_or_init(\|\| {

css_mod 0.1.5/src/parsing/ast.rs

126	#[cfg(test)]
127	#[allow(clippy::unwrap_used)]
128	impl Default for Module {
216	#[cfg(test)]
217	#[allow(clippy::unwrap_used)]
218	fn add_test_module(&mut self, input: &str) -> Result<&Module> {
368	#[cfg(test)]
369	#[allow(clippy::unwrap_used)]
370	mod tests {

cucumber 0.19.1/src/feature.rs

176	// contains this capture group.
177	#[allow(clippy::unwrap_used)]
178	let name = cap.get(1).unwrap().as_str();

depcon 0.3.0/src/container.rs

215	#[cfg(test)]
216	#[allow(clippy::unwrap_used)]
217	mod test {

depict 0.2.0/src/graph_drawing.rs

802	}
803	#[allow(clippy::unwrap_used)]
804	let max_level = *hops_by_level.keys().max().unwrap();
805	#[allow(clippy::unwrap_used)]
806	let max_width = hops_by_level.values().map(\|paths\| paths.len()).max().unwrap();
1288	hops_by_edge.iter().map(\|((vl, wl), hops)\| {
1289	#[allow(clippy::unwrap_used)] // an edge with no hops really should panic
1290	let (lvl, (mhr, nhr)) = hops.iter().rev().next().unwrap();
1757	.map(\|(vl, wl)\| {
1758	#[allow(clippy::unwrap_used)]
1759	let (lvl, (mhr, _nhr)) = hops_by_edge[&(vl.clone(), wl.clone())].iter().next().unwrap();
1765	.map(\|(vl, wl)\| {
1766	#[allow(clippy::unwrap_used)]
1767	let (lvl, (mhr, _nhr)) = hops_by_edge[&(vl.clone(), wl.clone())].iter().rev().next().unwrap();

deranged-macros 0.1.0/src/lib.rs

117	// The validity of the casts are verified by the enum discriminant.
118	#[allow(clippy::unwrap_used)]
119	match Self::from_min_max(min, max)? {

duration-human 0.1.10/src/lib.rs

23	#[cfg(test)]
24	#[allow(clippy::unwrap_in_result, clippy::unwrap_used, clippy::expect_used)]
25	mod test;

duration-human 0.1.10/src/parser.rs

170	#[allow(clippy::unwrap_used)] // somehow the RE has four groups
171	let unit = group

eosio 0.3.1/src/bytes/mod.rs

237	#[test]
238	#[allow(clippy::result_unwrap_used)]
239	fn test_read_pos() {
273	#[test]
274	#[allow(clippy::result_unwrap_used)]
275	fn test_write_pos() {

ergo-chain-types 0.9.0/src/digest32.rs

162	/// Arbitrary
163	#[allow(clippy::unwrap_used)]
164	#[cfg(feature = "arbitrary")]

ergo-chain-types 0.9.0/src/ec_point.rs

20	#[allow(clippy::unwrap_used)]
21	impl std::fmt::Debug for EcPoint {
51	fn from(value: EcPoint) -> String {
52	#[allow(clippy::unwrap_used)]
53	{
157	#[allow(clippy::unwrap_used)]
158	#[cfg(test)]

ergo-chain-types 0.9.0/src/header.rs

72	let mut n_bits_writer = vec![];
73	#[allow(clippy::unwrap_used)]
74	n_bits_writer
113	let mut reader = std::io::Cursor::new(n_bits_buf);
114	#[allow(clippy::unwrap_used)]
115	{
270	#[cfg(feature = "arbitrary")]
271	#[allow(clippy::unwrap_used)]
272	mod arbitrary {
382	#[allow(clippy::unwrap_used, clippy::panic)]
383	#[cfg(test)]

ergo-chain-types 0.9.0/src/json/votes.rs

36	.map(\|n\| {
37	#[allow(clippy::unwrap_used)]
38	{

ergo-chain-types 0.9.0/src/peer_addr.rs

31	let s: String = "http://".to_string() + &self.0.to_string();
32	#[allow(clippy::unwrap_used)]
33	Url::from_str(&s).unwrap()

ergo-lib 0.22.0/src/chain/contract.rs

40	#[cfg(test)]
41	#[allow(clippy::unwrap_used)]
42	mod tests {

ergo-lib 0.22.0/src/chain/ergo_box/box_builder.rs

130	// Won't be overflowing an i64, so unwrap is safe.
131	#[allow(clippy::unwrap_used)]
132	Ok(
254	// Won't be overflowing an i64, so unwrap is safe.
255	#[allow(clippy::unwrap_used)]
256	let min_box_value: BoxValue = (box_size_bytes as i64 * self.min_value_per_byte as i64)
276	#[cfg(test)]
277	#[allow(clippy::unwrap_used)]
278	mod tests {

ergo-lib 0.22.0/src/chain/json/context_extension.rs

42	#[cfg(test)]
43	#[allow(clippy::unwrap_used)]
44	mod tests {

ergo-lib 0.22.0/src/chain/transaction/unsigned.rs

95	#[allow(clippy::unwrap_used)]
96	// safe since the serialization error is impossible here
124	#[cfg(feature = "arbitrary")]
125	#[allow(clippy::unwrap_used)]
126	pub mod arbitrary {
150	#[cfg(test)]
151	#[allow(clippy::unwrap_used, clippy::panic)]
152	pub mod tests {

ergo-lib 0.22.0/src/chain/transaction.rs

179	) -> Result<bool, TransactionSignatureVerificationError> {
180	#[allow(clippy::unwrap_used)]
181	// since we have a tx with tx_id at this point, serialization is safe to unwrap
230	impl SigmaSerializable for Transaction {
231	#[allow(clippy::unwrap_used)]
232	fn sigma_serialize<W: SigmaByteWrite>(&self, w: &mut W) -> SigmaSerializeResult {

ergo-lib-c 0.22.0/src/address.rs

52	) {
53	#[allow(clippy::unwrap_used)]
54	{
70	pub unsafe extern "C" fn ergo_lib_address_type_prefix(address: ConstAddressPtr) -> u8 {
71	#[allow(clippy::unwrap_used)]
72	(address_type_prefix(address).unwrap() as u8)

ergo-lib-c 0.22.0/src/batchmerkleproof.rs

15	// Unwrap should be safe to use here unless the caller passes a null ptr (undefined)
16	#[allow(clippy::unwrap_used)]
17	batchmerkleproof_valid(proof, root_hash).unwrap()
34	) -> ErrorPtr {
35	#[allow(clippy::unwrap_used)]
36	// Unwrap is safe, CString::new only errors if the argument contains a 0 byte

ergo-lib-c 0.22.0/src/block_header.rs

31	) {
32	#[allow(clippy::unwrap_used)]
33	block_header_id(block_header_ptr, block_id_out).unwrap();

ergo-lib-c 0.22.0/src/box_builder.rs

27	) {
28	#[allow(clippy::unwrap_used)]
29	ergo_box_candidate_builder_new(value_ptr, contract_ptr, creation_height, builder_out).unwrap()
37	) {
38	#[allow(clippy::unwrap_used)]
39	ergo_box_candidate_builder_set_min_box_value_per_byte(builder_mut, new_min_value_per_byte)
47	) -> u32 {
48	#[allow(clippy::unwrap_used)]
49	ergo_box_candidate_builder_min_box_value_per_byte(builder_ptr).unwrap()
57	) {
58	#[allow(clippy::unwrap_used)]
59	ergo_box_candidate_builder_set_value(builder_mut, value_ptr).unwrap();
67	) {
68	#[allow(clippy::unwrap_used)]
69	ergo_box_candidate_builder_value(builder_ptr, value_out).unwrap();

ergo-lib-c-core 0.22.0/src/rest/api/node.rs

160	}
161	#[allow(clippy::unwrap_used)]
162	let seeds_bounded_vec = bounded_vec::NonEmptyVec::from_vec(seeds_vec).unwrap();
179	for mut peer in peers {
180	#[allow(clippy::unwrap_used)]
181	peer.set_port(Some(9053)).unwrap();

ergo-lib-wasm 0.22.0/src/ast/js_conv.rs

80	}
81	#[allow(clippy::unwrap_used)]
82	Ok(Constant {
172	let bigint_str = bigint.to_string();
173	#[allow(clippy::unwrap_used)]
174	// since BigInt256 bounds are less the JS BigInt it should not fail
178	fn js_bigint_to_ergo_bigint(bigint: js_sys::BigInt) -> Result<BigInt256, ConvError> {
179	#[allow(clippy::unwrap_used)]
180	// safe, because it can only return an error on invalid radix

ergo-lib-wasm 0.22.0/src/block_header.rs

129	if headers.len() == 10 {
130	#[allow(clippy::unwrap_used)]
131	Ok(headers.try_into().unwrap())

ergo-lib-wasm 0.22.0/src/json.rs

69	// Following unwraps are fine since we're converting from BoundedVec to Vec.
70	#[allow(clippy::unwrap_used)]
71	UnsignedTransactionJsonEip12 {
207	#[cfg(test)]
208	#[allow(clippy::unwrap_used)]
209	mod tests {

ergo-lib-wasm 0.22.0/src/rest/api.rs

164	let n = u16::max(max_parallel_requests, 1);
165	#[allow(clippy::unwrap_used)]
166	let max_parallel_requests = bounded_integer::BoundedU16::new(n).unwrap();
172	for mut url in res {
173	#[allow(clippy::unwrap_used)]
174	url.set_port(Some(9053)).unwrap();
220	let n = u16::max(max_parallel_requests, 1);
221	#[allow(clippy::unwrap_used)]
222	let max_parallel_requests = bounded_integer::BoundedU16::new(n).unwrap();
232	for mut url in res {
233	#[allow(clippy::unwrap_used)]
234	url.set_port(Some(9053)).unwrap();

ergo-merkle-tree 0.9.0/src/batchmerkleproof.rs

196	#[cfg(feature = "arbitrary")]
197	#[allow(clippy::unwrap_used, clippy::panic)]
198	mod test {

ergo-merkle-tree 0.9.0/src/lib.rs

32	// Unwrap is safe here since the hash is guaranteed to be 32 bytes
33	#[allow(clippy::unwrap_used)]
34	// Generates a hash of data prefixed with `prefix`
42	#[allow(clippy::unwrap_used)]
43	// Generates a hash of data prefixed with `prefix`, allows for an optional second hash

ergo-merkle-tree 0.9.0/src/merkleproof.rs

125	#[cfg(feature = "json")]
126	#[allow(clippy::unwrap_used)]
127	mod test {

ergo-merkle-tree 0.9.0/src/merkletree.rs

161	pub fn new(nodes: impl Into<Vec<MerkleNode>>) -> Self {
162	#[allow(clippy::unwrap_used)]
163	fn build_nodes(nodes: &mut [MerkleNode]) {
275	#[cfg(test)]
276	#[allow(clippy::unwrap_used, clippy::panic)]
277	mod test {
347	#[cfg(test)]
348	#[allow(clippy::unwrap_used)]
349	mod arbitrary {

ergo-nipopow 0.9.0/src/autolykos_pow_scheme.rs

44	let mut height_bytes = Vec::with_capacity(4);
45	#[allow(clippy::unwrap_used)]
46	height_bytes.write_u32::<BigEndian>(header.height).unwrap();
58	let mut concat = vec![];
59	#[allow(clippy::unwrap_used)]
60	concat.write_u32::<BigEndian>(idx).unwrap();
66	// sum as byte array is always about 32 bytes
67	#[allow(clippy::unwrap_used)]
68	let array = as_unsigned_byte_array(32, f2).unwrap();
78	let mut bytes = Vec::with_capacity(8);
79	#[allow(clippy::unwrap_used)]
80	bytes.write_u64::<BigEndian>(x).unwrap();
163	// The following paramter values are mandated by Ergo-node Autolykos implementation.
164	#[allow(clippy::unwrap_used)]
165	AutolykosPowScheme {

ergo-nipopow 0.9.0/src/nipopow_algos.rs

79	};
80	#[allow(clippy::unwrap_used)]
81	Ok(acc
96	let order = order();
97	#[allow(clippy::unwrap_used)]
98	let required_target = (order / decode_compact_bits(header.n_bits))
100	.unwrap();
101	#[allow(clippy::unwrap_used)]
102	let real_target = self.pow_scheme.pow_hit(header)?.to_f64().unwrap();
156	let suffix_tail: Vec<Header> = suffix[1..].iter().map(\|p\| p.header.clone()).collect();
157	#[allow(clippy::unwrap_used)]
158	let max_level: i32 = if chain.len() > (k as usize) {
412	#[allow(clippy::unwrap_used)]
413	#[cfg(test)]

ergo-rest 0.7.0/src/api/node.rs

25	pub async fn get_info(node: NodeConf) -> Result<NodeInfo, NodeError> {
26	#[allow(clippy::unwrap_used)]
27	let url = node.addr.as_http_url().join("info").unwrap();
42	path.push_str("/header");
43	#[allow(clippy::unwrap_used)]
44	let url = node.addr.as_http_url().join(&path).unwrap();
136	path.push_str(&header_str);
137	#[allow(clippy::unwrap_used)]
138	let url = node.addr.as_http_url().join(&path).unwrap();
160	path.push_str(&tx_id_str);
161	#[allow(clippy::unwrap_used)]
162	let url = node.addr.as_http_url().join(&path).unwrap();
172	#[allow(clippy::unwrap_used)]
173	#[cfg(test)]

ergo-rest 0.7.0/src/api/peer_discovery_internals/chrome.rs

191	let mut url = peer.get_url().clone();
192	#[allow(clippy::unwrap_used)]
193	url.set_port(None).unwrap();
237	Msg::AddActiveNode(mut url) => {
238	#[allow(clippy::unwrap_used)]
239	url.set_port(None).unwrap();
262	Msg::InfoRequestFailedWithoutTimeout(mut url) => {
263	#[allow(clippy::unwrap_used)]
264	url.set_port(None).unwrap();
276	Msg::InfoRequestFailedWithTimeout(mut url) => {
277	#[allow(clippy::unwrap_used)]
278	url.set_port(None).unwrap();
290	Msg::PeersAllRequestFailedWithoutTimeout(mut url) => {
291	#[allow(clippy::unwrap_used)]
292	url.set_port(None).unwrap();

ergotree-interpreter 0.22.0/src/contracts.rs

1	#[allow(clippy::unwrap_used)]
2	#[cfg(test)]

ergotree-interpreter 0.22.0/src/eval/apply.rs

33	#[cfg(test)]
34	#[allow(clippy::unwrap_used)]
35	mod tests {

ergotree-interpreter 0.22.0/src/eval/atleast.rs

54	#[allow(clippy::unwrap_used)]
55	#[allow(clippy::panic)]

ergotree-interpreter 0.22.0/src/eval/bin_op.rs

323	#[cfg(test)]
324	#[allow(clippy::unwrap_used)]
325	mod tests {

ergotree-interpreter 0.22.0/src/eval/bit_inversion.rs

26	#[allow(clippy::unwrap_used)]
27	#[cfg(test)]

ergotree-interpreter 0.22.0/src/eval/byte_array_to_bigint.rs

1	#![allow(clippy::unwrap_used)]
2	use ergotree_ir::bigint256::BigInt256;
29	#[allow(clippy::unwrap_used)]
30	#[allow(clippy::panic)]

ergotree-interpreter 0.22.0/src/eval/coll_append.rs

59	#[allow(clippy::unwrap_used)]
60	#[allow(clippy::panic)]

ergotree-interpreter 0.22.0/src/eval/coll_by_index.rs

43	#[allow(clippy::unwrap_used)]
44	#[cfg(test)]

ergotree-interpreter 0.22.0/src/eval/coll_exists.rs

57	#[allow(clippy::unwrap_used)]
58	#[cfg(test)]

ergotree-ir 0.22.0/src/bigint256.rs

41	fn try_from(value: BigUint) -> Result<Self, Self::Error> {
42	#[allow(clippy::unwrap_used)]
43	if value > Self::max_value().0 .0.to_biguint().unwrap() {
279	#[allow(clippy::unwrap_used)]
280	#[cfg(test)]

ergotree-ir 0.22.0/src/chain/address.rs

177	Address::P2Pk(prove_dlog) => {
178	#[allow(clippy::unwrap_used)]
179	// Since ProveDlog is a simple IR node we can be sure no other errors besides OOM could be here
190	Address::P2Pk(prove_dlog) => {
191	#[allow(clippy::unwrap_used)]
192	// Since ProveDlog is a simple IR node we can be sure no other errors besides OOM could be here
419	.collect();
420	#[allow(clippy::unwrap_used)]
421	v.as_slice().try_into().unwrap()
517	#[cfg(feature = "arbitrary")]
518	#[allow(clippy::unwrap_used)]
519	pub(crate) mod arbitrary {
546	#[cfg(test)]
547	#[allow(clippy::unwrap_used)]
548	#[allow(clippy::panic)]

ergotree-ir 0.22.0/src/chain/ergo_box/box_id.rs

69	#[allow(clippy::unwrap_used)]
70	#[allow(clippy::panic)]

ergotree-ir 0.22.0/src/chain/ergo_box/box_value.rs

239	#[allow(clippy::panic)]
240	#[allow(clippy::unwrap_used)]
241	#[cfg(test)]

ergotree-ir 0.22.0/src/chain/ergo_box/register.rs

237	#[allow(clippy::unwrap_used)] // it could only fail on OOM, etc.
238	fn sigma_serialize_bytes(&self) -> Vec<u8> {

fedora-update-feedback 2.0.2/src/checks.rs

100	// this unwrap is safe since we definitely inserted a value for every update
101	#[allow(clippy::unwrap_used)]
102	for build in builds_for_update.get(update.alias.as_str()).unwrap() {

fedora-update-feedback 2.0.2/src/main.rs

367	// this unwrap is safe since we definitely inserted a value for every update earlier
368	#[allow(clippy::unwrap_used)]
369	let builds = builds_for_update.get(update.alias.as_str()).unwrap();

fedora-update-feedback 2.0.2/src/parse.rs

71	#[cfg(test)]
72	#[allow(clippy::unwrap_used)]
73	mod tests {

fedora-update-feedback 2.0.2/src/sysinfo.rs

        // these unwraps are safe because the length is definitely 2
        #[allow(clippy::unwrap_used)]
        let source = parts.get(0).unwrap();
        #[allow(clippy::unwrap_used)]
        let binary = parts.get(1).unwrap();
        // these unwraps are safe because the length is definitely 2
        #[allow(clippy::unwrap_used)]
        let binary = parts.get(0).unwrap();
        #[allow(clippy::unwrap_used)]
        let installtime = parts.get(1).unwrap();

fetcher-core 0.10.0/src/action/regex.rs

134	#[allow(clippy::unwrap_used)]
135	#[allow(unused)]

gauge 0.4.1/src/state.rs

208	#[cfg(test)]
209	#[allow(clippy::unwrap_used)]
210	mod tests {

gf2_192 0.22.0/src/gf2_192.rs

665	#[cfg(test)]
666	#[allow(clippy::unwrap_used)]
667	mod tests {

gf2_192 0.22.0/src/gf2_192poly.rs

133	for i in 1..=self.degree {
134	#[allow(clippy::unwrap_used)]
135	self.coefficients[i]
204	#[cfg(test)]
205	#[allow(clippy::unwrap_used)]
206	mod tests {

girt-git 2.2.0/src/testutil/with_temp_repository.rs

28	/// If the repository cannot be created for any reason, this function will panic.
29	#[allow(clippy::panic, clippy::unwrap_used)]
30	#[inline]

goff 0.1.0/src/lib.rs

50	#[cfg(test)]
51	#[allow(clippy::unwrap_used)]
52	mod tests

gpu-allocator 0.22.0/src/allocator/dedicated_block_allocator/mod.rs

54	#[allow(clippy::unwrap_used)]
55	let dummy_id = std::num::NonZeroU64::new(1).unwrap();

gpu-allocator 0.22.0/src/allocator/free_list_allocator/mod.rs

63	pub(crate) fn new(size: u64) -> Self {
64	#[allow(clippy::unwrap_used)]
65	let initial_chunk_id = std::num::NonZeroU64::new(1).unwrap();

halfbrown 0.1.18/src/vecmap/entry.rs

370	#[inline]
371	#[allow(clippy::unwrap_used)]
372	pub fn replace_entry(self, value: V) -> (K, V) {
405	#[inline]
406	#[allow(clippy::unwrap_used)]
407	pub fn replace_key(self) -> K {

i3-insert-workspace 1.0.1/src/docker_name.rs

596	// `choose` only returns none on empty arrays
597	#[allow(clippy::unwrap_used)]
598	/// Generate a new name

iced-x86 1.18.0/src/data_reader.rs

58	#[cfg(any(feature = "gas", feature = "intel", feature = "masm", feature = "nasm"))]
59	#[allow(clippy::unwrap_used)]
60	pub(crate) fn read_ascii_str(&mut self) -> &'a str {

iced-x86 1.18.0/src/decoder/handlers.rs

176	#[inline]
177	#[allow(clippy::unwrap_used)]
178	pub(super) fn new(
209	#[inline]
210	#[allow(clippy::unwrap_used)]
211	pub(super) fn new(
249	#[inline]
250	#[allow(clippy::unwrap_used)]
251	pub(super) fn new(group_handlers: Vec<(OpCodeHandlerDecodeFn, &'static OpCodeHandler)>) -> (OpCodeHandlerDecodeFn, Self) {
272	impl OpCodeHandler_AnotherTable {
273	#[allow(clippy::unwrap_used)]
274	#[inline]

iced-x86 1.18.0/src/decoder/table_de/mod.rs

201	#[must_use]
202	#[allow(clippy::unwrap_used)]
203	fn read_handler_or_null_instance(&mut self) -> (OpCodeHandlerDecodeFn, &'static OpCodeHandler) {
235	#[allow(clippy::get_unwrap)]
236	#[allow(clippy::unwrap_used)]
237	fn read_handler_reference(&mut self) -> (OpCodeHandlerDecodeFn, &'static OpCodeHandler) {
247	#[allow(clippy::get_unwrap)]
248	#[allow(clippy::unwrap_used)]
249	fn read_array_reference(&mut self, kind: u32) -> Vec<(OpCodeHandlerDecodeFn, &'static OpCodeHandler)> {
270	#[allow(clippy::get_unwrap)]
271	#[allow(clippy::unwrap_used)]
272	fn table(&mut self, index: usize) -> Vec<(OpCodeHandlerDecodeFn, &'static OpCodeHandler)> {

iced-x86 1.18.0/src/decoder.rs

729	#[inline]
730	#[allow(clippy::unwrap_used)]
731	pub fn new(bitness: u32, data: &'a [u8], options: u32) -> Decoder<'a> {

icu_calendar 1.1.0/src/calendar_arithmetic.rs

152	debug_assert!(day <= C::month_days(year, month) as i32);
153	#[allow(clippy::unwrap_used)]
154	// The day is expected to be within the range of month_days of C

icu_calendar 1.1.0/src/coptic.rs

227	#[allow(clippy::unwrap_used)] // day and month have the correct bounds
228	*Date::try_new_coptic_date(year, month, day).unwrap().inner()

icu_calendar 1.1.0/src/ethiopian.rs

262	#[allow(clippy::unwrap_used)] // Coptic and Ethiopic have the same allowed ranges for dates
263	*Date::try_new_ethiopian_date(

icu_calendar 1.1.0/src/iso.rs

347	let (time, extra_days) = types::Time::from_minute_with_remainder_days(minute);
348	#[allow(clippy::unwrap_used)] // constant date
349	let unix_epoch = DateTime::try_new_iso_datetime(1970, 1, 1, 0, 0, 0).unwrap();
426	#[allow(clippy::unwrap_used)] // month in 1..=12, day <= month_days
427	Date::try_new_iso_date(year, month, day).unwrap()
453	fn iso_new_year(year: i32) -> i32 {
454	#[allow(clippy::unwrap_used)] // valid day and month
455	Self::fixed_from_iso_integers(year, 1, 1).unwrap()
461	let prior_days = date - Self::iso_new_year(year);
462	#[allow(clippy::unwrap_used)] // valid day and month
463	let correction = if date < Self::fixed_from_iso_integers(year, 3, 1).unwrap() {
470	let month = quotient(12 * (prior_days + correction) + 373, 367) as u8; // in 1..12 < u8::MAX
471	#[allow(clippy::unwrap_used)] // valid day and month
472	let day = (date - Self::fixed_from_iso_integers(year, month, 1).unwrap() + 1) as u8; // <= days_in_month < u8::MAX

icu_calendar 1.1.0/src/julian.rs

267	#[allow(clippy::unwrap_used)] // day and month have the correct bounds
268	*Date::try_new_julian_date(year, month, day).unwrap().inner()

icu_calendar 1.1.0/src/types.rs

484	let (hours, minutes) = (minute_in_day / 60, minute_in_day % 60);
485	#[allow(clippy::unwrap_used)] // values are moduloed to be in range
486	(

icu_codepointtrie 0.4.0/src/planes.rs

197	);
198	#[allow(clippy::unwrap_used)] // TODO(#1668) Clippy exceptions need docs or fixing.
199	trie_result.unwrap()

icu_collator 1.1.0/src/comparison.rs

326	// https://github.com/rust-lang/rust/issues/15701
327	#[allow(clippy::unwrap_used)]
328	let variable_top = if self.options.alternate_handling() == AlternateHandling::NonIgnorable {
343	// https://github.com/rust-lang/rust/issues/15701
344	#[allow(clippy::unwrap_used)]
345	let numeric_primary = if self.options.numeric() {
359	// https://github.com/rust-lang/rust/issues/15701
360	#[allow(clippy::unwrap_used)]
361	let mut left = CollationElements::new(
374	// https://github.com/rust-lang/rust/issues/15701
375	#[allow(clippy::unwrap_used)]
376	let mut right = CollationElements::new(

icu_collator 1.1.0/src/elements.rs

1918	// digit to even start numeric processing.
1919	#[allow(clippy::unwrap_used)]
1920	let mut value = u32::from(*digit_iter.next().unwrap());
2003	// `unwrap` succeeds by construction
2004	#[allow(clippy::unwrap_used)]
2005	let mut pair = if len & 1 == 1 {
2176	// means the `unwrap()` must succeed.
2177	#[allow(clippy::unwrap_used)]
2178	let combining = self.next_internal().unwrap().c_and_c;

icu_collator 1.1.0/src/provider.rs

142	if let Some(slice) = self.contexts.get_subslice(index..self.contexts.len()) {
143	#[allow(clippy::unwrap_used)]
144	if slice.len() >= 2 {
438	impl<'data> CollationSpecialPrimariesV1<'data> {
439	#[allow(clippy::unwrap_used)]
440	pub(crate) fn last_primary_for_group(&self, max_variable: MaxVariable) -> u32 {

icu_collections 1.1.0/src/codepointinvlist/builder.rs

29	let inv_list: ZeroVec<u32> = ZeroVec::alloc_from_slice(&self.intervals);
30	#[allow(clippy::unwrap_used)] // by invariant
31	CodePointInversionList::try_from_inversion_list(inv_list).unwrap()

icu_collections 1.1.0/src/codepointinvlist/conversions.rs

23	let inv_list: ZeroVec<u32> = ZeroVec::alloc_from_slice(&set);
24	#[allow(clippy::unwrap_used)] // valid
25	Ok(CodePointInversionList::try_from_inversion_list(inv_list).unwrap())

icu_collections 1.1.0/src/codepointinvlist/utils.rs

14	#[allow(clippy::indexing_slicing)] // windows
15	#[allow(clippy::unwrap_used)] // by is_empty check
16	pub fn is_valid_zv(inv_list_zv: &ZeroVec<'_, u32>) -> bool {

icu_collections 1.1.0/src/codepointtrie/planes.rs

172	];
173	#[allow(clippy::unwrap_used)] // valid bytes
174	let index: ZeroVec<u16> = ZeroVec::parse_byte_slice(index_array_as_bytes).unwrap();
175	#[allow(clippy::unwrap_used)] // valid bytes
176	let data: ZeroVec<u8> = ZeroVec::parse_byte_slice(data_8_array).unwrap();
193	#[allow(clippy::unwrap_used)] // valid data
194	CodePointTrie::try_new(trie_header, index, data).unwrap()

icu_datetime 1.1.0/src/fields/length.rs

115	fn from_unaligned(unaligned: Self::ULE) -> Self {
116	#[allow(clippy::unwrap_used)] // OK because the ULE is pre-validated
117	Self::from_idx(unaligned.0).unwrap()

icu_datetime 1.1.0/src/fields/symbols.rs

176	fn from_unaligned(unaligned: Self::ULE) -> Self {
177	#[allow(clippy::unwrap_used)] // OK because the ULE is pre-validated
178	Self::from_idx(unaligned.0).unwrap()

icu_datetime 1.1.0/src/pattern/item/ule.rs

130	let value = unaligned.0;
131	#[allow(clippy::unwrap_used)] // validated
132	if PatternItemULE::determine_field_from_u8(value[0]) {
265	} else {
266	#[allow(clippy::unwrap_used)] // validated
267	Self::Literal(

icu_datetime 1.1.0/src/pattern/reference/generic.rs

25	GenericPatternItem::Placeholder(idx) => {
26	#[allow(clippy::unwrap_used)] // idx is a valid base-10 digit
27	let replacement = replacements.get(idx as usize).ok_or_else(\|\| {

icu_datetime 1.1.0/src/pattern/runtime/generic.rs

64	GenericPatternItem::Placeholder(idx) => {
65	#[allow(clippy::unwrap_used)] // idx is a valid base-10 digit
66	return Err(PatternError::UnknownSubstitution(

icu_list 1.1.0/src/provider/serde_dfa.rs

156	/// Returns the represented [`DFA`]
157	#[allow(clippy::unwrap_used)] // by invariant
158	pub fn deref(&'data self) -> DFA<&'data [u8]> {

icu_locid 1.1.0/src/helpers.rs

114	match v.len() {
115	#[allow(clippy::unwrap_used)]
116	// we know that the vec has exactly one element left
136	0 => ShortVec::Empty,
137	#[allow(clippy::unwrap_used)] // we know that the vec is not empty
138	1 => ShortVec::Single(v.into_iter().next().unwrap()),

icu_normalizer 1.1.0/src/lib.rs

1170	// Now we need to check if composition with an upcoming starter is possible.
1171	#[allow(clippy::unwrap_used)]
1172	if self.decomposition.pending.is_some() {

icu_provider 1.1.0/src/hello_world.rs

273	fn supported_locales(&self) -> Result<Vec<DataLocale>, DataError> {
274	#[allow(clippy::unwrap_used)] // datagen
275	Ok(Self::DATA

icu_provider_adapters 1.1.0/src/fallback/algorithms.rs

177	if let Some(value) = self.backup_extension.take() {
178	#[allow(clippy::unwrap_used)] // not reachable unless extension_key is present
179	locale.set_unicode_ext(self.config.extension_key.unwrap(), value);

icu_testdata 1.1.1/src/lib.rs

145	// The statically compiled data file is valid.
146	#[allow(clippy::unwrap_used)]
147	LocaleFallbackProvider::try_new_unstable(unstable_no_fallback()).unwrap()
165	// The baked data is valid.
166	#[allow(clippy::unwrap_used)]
167	LocaleFallbackProvider::try_new_with_any_provider(any_no_fallback()).unwrap()
182	// The statically compiled data file is valid.
183	#[allow(clippy::unwrap_used)]
184	LocaleFallbackProvider::try_new_with_buffer_provider(buffer_no_fallback()).unwrap()

icu_uniset 0.5.0/src/builder.rs

28

        let inv_list: ZeroVec<u32> = ZeroVec::alloc_from_slice(&self.intervals);

29

        #[allow(clippy::unwrap_used)] // TODO(#1668) Clippy exceptions need docs or fixing.

30

        UnicodeSet::from_inversion_list(inv_list).unwrap()

icu_uniset 0.5.0/src/conversions.rs

23	let inv_list: ZeroVec<u32> = ZeroVec::alloc_from_slice(&set);
24	#[allow(clippy::unwrap_used)] // TODO(#1668) Clippy exceptions need docs or fixing.
25	Ok(UnicodeSet::from_inversion_list(inv_list).unwrap())

icu4x_ecma402 0.8.0/src/lib.rs

40	fn from_ecma_locale<L: ecma402_traits::Locale>(other: L) -> Self {
41	#[allow(clippy::unwrap_used)] // ecma402_traits::Locale::to_string is a valid locale
42	Self(

icu4x_ecma402 0.8.0/src/pluralrules.rs

113	let nstr = fixed_format(n, &opts);
114	#[allow(clippy::unwrap_used)] // TODO(#1668) Clippy exceptions need docs or fixing.
115	let ret = nstr.parse().unwrap();

iir_filters 0.1.2/src/util.rs

33	#[allow(clippy::unwrap_used)]
34	pub(crate) fn sort_lex_with_map<F: Float, MAP>(list: &mut [Complex<F>], keys: &[Keys],

jrk-g2 2.0.0/examples/stm32-i2c.rs

fn main() -> ! {
    #[allow(clippy::unwrap_used)]
    let cp = cortex_m::Peripherals::take().unwrap();
    #[allow(clippy::unwrap_used)]
    let dp = pac::Peripherals::take().unwrap();

jrk-g2 2.0.0/examples/stm32-serial.rs

fn main() -> ! {
    #[allow(clippy::unwrap_used)]
    let cp = cortex_m::Peripherals::take().unwrap();
    #[allow(clippy::unwrap_used)]
    let dp = pac::Peripherals::take().unwrap();

jsonschema-equivalent 0.1.0/src/keywords/mod.rs

299	) -> Value {
300	#[allow(clippy::option_unwrap_used)]
301	preserve_keys(map.as_object_mut().unwrap(), keywords_to_remove);

kanidm_tools 1.1.0-alpha.11/src/cli/session.rs

155	// We flush stdout so it'll write the buffer to screen, continuing operation. Without it, the application halts.
156	#[allow(clippy::unwrap_used)]
157	io::stdout().flush().unwrap();

kbs2 0.6.0/src/kbs2/agent.rs

96	// the error by using `Result<Vec<_>, _>` with `collect`.
97	#[allow(clippy::unwrap_used)]
98	let data: Result<Vec<_>, _> = reader

kbs2 0.6.0/src/kbs2/command.rs

30	#[allow(clippy::unwrap_used)]
31	if config_dir.join(config::CONFIG_BASENAME).exists()
39	#[allow(clippy::unwrap_used)]
40	let store_dir = matches.get_one::<PathBuf>("store-dir").unwrap().as_path();
47	#[allow(clippy::unwrap_used)]
48	let password = if !*matches.get_one::<bool>("insecure-not-wrapped").unwrap() {
63	let mut agent = agent::Agent::new()?;
64	#[allow(clippy::unwrap_used)]
65	if !matches.get_one::<bool>("foreground").unwrap() {
87	#[allow(clippy::unwrap_used)]
88	if *matches.get_one::<bool>("quit").unwrap() {

kbs2 0.6.0/src/kbs2/generator.rs

64	// Safe unwrap: alphabet.chars() is always nonempty.
65	#[allow(clippy::unwrap_used)]
66	secret.push(alphabet.chars().choose(&mut rng).unwrap());

kbs2 0.6.0/src/kbs2/input.rs

80	// Unwrap safety: take_terse_fields checks FIELD_COUNT to ensure sufficient elements.
81	#[allow(clippy::unwrap_used)]
82	(fields.pop().unwrap(), fields.pop().unwrap())
117	// Unwrap safety: take_terse_fields checks FIELD_COUNT to ensure sufficient elements.
118	#[allow(clippy::unwrap_used)]
119	(fields.pop().unwrap(), fields.pop().unwrap())
143	// Unwrap safety: take_terse_fields checks FIELD_COUNT to ensure sufficient elements.
144	#[allow(clippy::unwrap_used)]
145	let contents = Self::take_terse_fields()?.pop().unwrap();

kmp 0.1.1/src/table.rs

19	for needle_char in &needle[1..] {
20	#[allow(clippy::option_unwrap_used)]
21	let mut distance: usize = *lsp.last().unwrap();

kukoo 0.1.0/src/lib.rs

375	#[inline]
376	#[allow(clippy::unwrap_used)]
377	pub fn get_or_insert(&self, key: K, value: V, guard: &'guard Guard) -> &'guard V {

lcov2cobertura 1.0.1/src/demangle.rs

27	// safety: stdin/stdout is only taken once, panic unlikely
28	#[allow(clippy::unwrap_used)]
29	pub fn new(cmd: &str) -> io::Result<Self> {
71	// safety: regex is known to compile fine, no panic
72	#[allow(clippy::unwrap_used)]
73	pub fn new() -> Self {

lcov2cobertura 1.0.1/src/lib.rs

176	// panic though.
177	#[allow(clippy::unwrap_used)]
178	impl CoverageData {
559	// safety: guaranteed, using sorted keys as input
560	#[allow(clippy::unwrap_used)]
561	let cd_line = cd.lines.get(line_number).unwrap();

lecturn 0.1.9/src/commands.rs

18	#[must_use]
19	#[allow(clippy::unwrap_used)]
20	/// # Panics

libzetta 0.3.1/src/zfs/errors.rs

62	#[allow(clippy::option_unwrap_used)]
63	#[allow(clippy::wildcard_enum_match_arm)]

libzetta 0.3.1/src/zfs/open3.rs

66	#[allow(clippy::option_unwrap_used)]
67	#[allow(clippy::result_unwrap_used)]
68	fn list<N: Into<PathBuf>>(&self, prefix: N) -> Result<Vec<(DatasetKind, PathBuf)>> {
165	impl ZfsOpen3 {
166	#[allow(clippy::option_unwrap_used)]
167	fn stdout_to_list_of_datasets(z: &mut Command) -> Result<Vec<PathBuf>, Error> {

libzetta 0.3.1/src/zpool/description.rs

61	#[allow(clippy::option_unwrap_used, clippy::wildcard_enum_match_arm)]
62	pub(crate) fn from_pest_pair(pair: Pair<'_, Rule>) -> Zpool {
121	#[inline]
122	#[allow(clippy::option_unwrap_used, clippy::result_unwrap_used, clippy::wildcard_enum_match_arm)]
123	fn get_error_statistics_from_pair(pair: Pair<'_, Rule>) -> ErrorStatistics {
133	#[inline]
134	#[allow(clippy::option_unwrap_used, clippy::wildcard_enum_match_arm)]
135	fn set_stats_and_reason_from_pool_line(pool_line: Pair<'_, Rule>, zpool: &mut ZpoolBuilder) {
191	#[inline]
192	#[allow(clippy::option_unwrap_used, clippy::wildcard_enum_match_arm)]
193	fn get_stats_and_reason_from_pairs(pairs: Pairs<'_, Rule>) -> (ErrorStatistics, Option<Reason>) {

libzetta 0.3.1/src/zpool/mod.rs

192	/// Try to convert stderr into internal error type.
193	#[allow(clippy::option_unwrap_used)]
194	pub fn from_stderr(stderr_raw: &[u8]) -> ZpoolError {

litemap 0.6.1/src/map.rs

117	match self.find_index(key) {
118	#[allow(clippy::unwrap_used)] // find_index returns a valid index
119	Ok(found) => Some(self.values.lm_get(found).unwrap().1),
254	match self.find_index(key) {
255	#[allow(clippy::unwrap_used)] // find_index returns a valid index
256	Ok(found) => Some(self.values.lm_get_mut(found).unwrap().1),
318	match self.values.lm_binary_search_by(\|k\| k.cmp(&key)) {
319	#[allow(clippy::unwrap_used)] // Index came from binary_search
320	Ok(found) => Some((

litemap 0.6.1/src/serde.rs

39	while i < self.values.lm_len() {
40	#[allow(clippy::unwrap_used)] // i is in range
41	let (k, v) = self.values.lm_get(i).unwrap();

litemap 0.6.1/src/store/mod.rs

113	while i < self.lm_len() {
114	#[allow(clippy::unwrap_used)] // i is in range
115	let (k, v) = self.lm_get(i).unwrap();

llvm-bitstream 0.0.3/src/parser.rs

192	// `last()` cannot fail.
193	#[allow(clippy::unwrap_used)]
194	self.scopes.last().unwrap()
200	// `last()` cannot fail.
201	#[allow(clippy::unwrap_used)]
202	self.scopes.last_mut().unwrap()
268	// Unwrap safety: we check for at least one scope above, so this cannot fail.
269	#[allow(clippy::unwrap_used)]
270	let scope = self.scopes.pop().unwrap();

llvm-constants 0.0.2/build.rs

4	// Unwrap safety: None. If this fails, the build fails, and that's intended.
5	#[allow(clippy::unwrap_used)]
6	fn main() {

llvm-mapper 0.0.4/src/record/datalayout.rs

115	// Unwrap safety: we check for a nonempty spec above.
116	#[allow(clippy::unwrap_used)]
117	match spec.chars().next().unwrap() {

llvm-mapper 0.0.4/src/unroll.rs

329	// bitstream here, but it's difficult to represent that at the type level during unrolling.
330	#[allow(clippy::unwrap_used)]
331	let block = entry.unwrap()?.as_block().ok_or_else(\|\| {
485	#[allow(clippy::unwrap_used)]
486	Ok(BitcodeModule {

llvm-support 0.0.3/build.rs

4	// Unwrap safety: None. If this fails, the build fails, and that's intended.
5	#[allow(clippy::unwrap_used)]
6	fn main() {

llvm-support 0.0.3/src/align.rs

341	// Unwrap safety: we check for a nonempty string above.
342	#[allow(clippy::unwrap_used)]
343	let id = value.chars().next().unwrap();
469	// into an infallible constant.
470	#[allow(clippy::unwrap_used)]
471	Self(vec![
499	// Unwrap safety: `pos` is a valid index returned above.
500	#[allow(clippy::unwrap_used)]
501	let mut other = self.0.get_mut(pos).unwrap();
727	// Unwrap safety: `pos` is a valid index returned above.
728	#[allow(clippy::unwrap_used)]
729	let mut other = self.0.get_mut(pos).unwrap();

locked-voter 0.5.8/src/locker.rs

44	#[cfg(test)]
45	#[allow(clippy::integer_arithmetic, clippy::unwrap_used)]
46	mod tests {

locked-voter 0.5.8/src/state.rs

137	#[cfg(test)]
138	#[allow(clippy::unwrap_used)]
139	mod tests {

lockfree-cuckoohash 0.1.0/src/lib.rs

369	#[inline]
370	#[allow(clippy::unwrap_used)]
371	pub fn get_or_insert(&self, key: K, value: V, guard: &'guard Guard) -> &'guard V {
523	/// `load_inner` atomically loads the `MapInner` of hashmap.
524	#[allow(clippy::unwrap_used)]
525	fn load_inner(&self, guard: &'guard Guard) -> &'guard map_inner::MapInner<K, V> {

lucia 0.5.0/src/misc/request_limit.rs

21	// u16::MAX is greater than 0
22	allow(clippy::missing_panics_doc, clippy::unwrap_used)
23	]

lucia-macros 0.2.0/src/pkg.rs

56	// Option will always exist
57	clippy::unwrap_used
58	)]

mangling 0.2.3/src/clib/test.rs

9	#[test]
10	#[allow(clippy::result_unwrap_used)]
11	fn mangling() {

mangling 0.2.3/src/test.rs

43	#[test]
44	#[allow(clippy::result_unwrap_used)]
45	fn demangling() {

matrix-sdk-sql 0.1.0-beta.2/src/cryptostore.rs

1348	#[allow(clippy::unwrap_used)]
1349	static TMP_DIR: Lazy<TempDir> = Lazy::new(\|\| tempdir().unwrap());

matrix_uri 0.1.1/src/lib.rs

619	#[allow(clippy::unwrap_used)]
620	#[cfg(test)]

meiosis 0.1.0/src/neighbour.rs

49	{
50	#[allow(clippy::unwrap_used)]
51	self.random_forward_neighbour(rng, NonZeroUsize::new(1).unwrap())
63	{
64	#[allow(clippy::unwrap_used)]
65	self.random_backward_neighbour(rng, NonZeroUsize::new(1).unwrap())

memcached 0.4.4/src/lib.rs

84	#[allow(clippy::result_unwrap_used, clippy::option_unwrap_used)]
85	#[cfg(test)]

mop-solvers 0.5.0/src/genetic_algorithm/spea2.rs

317	#[allow(clippy::unwrap_used)]
318	fn sort_partial_by<F, T>(slice: &mut [T], f: F)

mure 0.2.1/src/github/repo.rs

53	static GITHUB_HTTPS_URL: Lazy<Regex> = Lazy::new(\|\| {
54	#[allow(clippy::unwrap_used)]
55	Regex::new("^https?://(?P<domain>github\\.com)/(?P<owner>.?)/(?P<repo>.?)(/?\|(?:\\.git))$")
59	static GITHUB_GIT_URL: Lazy<Regex> = Lazy::new(\|\| {
60	#[allow(clippy::unwrap_used)]
61	Regex::new("^git@(?P<domain>github\\.com):(?P<owner>.?)/(?P<repo>.?)(?:\\.git)?$").unwrap()
64	static GITHUB_SSH_URL: Lazy<Regex> = Lazy::new(\|\| {
65	#[allow(clippy::unwrap_used)]
66	Regex::new(

mure 0.2.1/src/test_fixture.rs

15	#[cfg(test)]
16	#[allow(clippy::expect_used, clippy::unwrap_used)]
17	impl Fixture {

ndsparse 0.8.1/src/csl/csl_line_constructor.rs

145	// self.curr_dim_idx always points to a valid reference
146	clippy::unwrap_used
147	)]
154	// Constructor doesn't contain empty dimensions
155	clippy::unwrap_used
156	)]

ndstruct 1.0.0/src/csl/csl_line_constructor.rs

145	// self.curr_dim_idx always points to a valid reference
146	clippy::unwrap_used
147	)]
154	// Constructor doesn't contain empty dimensions
155	clippy::unwrap_used
156	)]

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

142	let progress_println = \|msg: &dyn AsRef<str>\| {
143	#[allow(clippy::unwrap_used)]
144	progress.as_ref().unwrap().println(msg);

necessist-core 0.1.0-beta.6/src/framework/impls/hardhat_ts/mod.rs

71	let mut parser = Parser::new_from(lexer);
72	#[allow(clippy::unwrap_used)]
73	let module = parser

necessist-core 0.1.0-beta.6/src/framework/impls/rust/mod.rs

74	let content = read_to_string(test_file)?;
75	#[allow(clippy::unwrap_used)]
76	let file = parse_file(&content).with_context(\|\| {

necessist-core 0.1.0-beta.6/src/framework/impls/rust/visitor.rs

441	#[allow(clippy::unwrap_used)]
442	fn readme_contains_code_bulleted_list(items: &[&str]) -> bool {

necessist-core 0.1.0-beta.6/src/framework/mod.rs

23	pub trait Interface: std::fmt::Debug {
24	#[allow(clippy::unwrap_used)]
25	fn name(&self) -> String {

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

64	#[allow(clippy::expect_used)]
65	#[allow(clippy::unwrap_used)]
66	fn rewrite(&mut self, start: usize, end: usize, replacement: &str) -> String {

necessist-core 0.1.0-beta.6/src/source_file.rs

22	#[allow(clippy::unwrap_used)]
23	fn relative_path(&self) -> &Path {

necessist-core 0.1.0-beta.6/src/sqlite.rs

167	#[allow(clippy::unwrap_used)]
168	let path = remote

necessist-core 0.1.0-beta.6/src/warn.rs

81	#[allow(clippy::unwrap_used)]
82	let mut warning_state_map = WARNING_STATE_MAP.lock().unwrap();

northstar-runtime 0.7.0/src/common/container.rs

112	#[test]
113	#[allow(clippy::unwrap_used)]
114	fn try_from() {

northstar-runtime 0.7.0/src/common/name.rs

150	#[test]
151	#[allow(clippy::unwrap_used)]
152	fn serialize() {
159	#[test]
160	#[allow(clippy::unwrap_used)]
161	fn deserialize() {
170	#[should_panic]
171	#[allow(clippy::unwrap_used)]
172	fn deserialize_name_contains_slash() {

northstar-runtime 0.7.0/src/common/non_nul_string.rs

159	#[test]
160	#[allow(clippy::unwrap_used)]
161	fn serialize() {
168	#[test]
169	#[allow(clippy::unwrap_used)]
170	fn deserialize() {

northstar-runtime 0.7.0/src/npk/manifest/console.rs

65	#[allow(clippy::unwrap_used)]
66	impl fmt::Display for Permission {
167	#[cfg(test)]
168	#[allow(clippy::unwrap_used)]
169	mod test {

northstar-runtime 0.7.0/src/npk/manifest/mod.rs

161	impl ToString for Manifest {
162	#[allow(clippy::unwrap_used)]
163	fn to_string(&self) -> String {
171	#[cfg(test)]
172	#[allow(clippy::unwrap_used)]
173	mod tests {

nu-command 0.75.0/src/network/http/get.rs

412	// it always or never fails
413	#[allow(clippy::unwrap_used)]
414	fn http_client() -> reqwest::blocking::Client {

nu-command 0.75.0/src/network/http/post.rs

434	// it always or never fails
435	#[allow(clippy::unwrap_used)]
436	fn http_client(allow_insecure: bool) -> reqwest::blocking::Client {

nuts 0.2.1/src/nut/activity/activity_container.rs

61

        // If anyone ever find this to be a performance bottleneck in a real application, this can be fixed with some smarter implementation.

62

        #[allow(clippy::unwrap_used)]

63

        if let Some(index) = self.data.iter().position(|maybe_activity| {

nuts 0.2.1/src/nut/iac/managed_state/domain_state.rs

65	/// Returns a reference to a value of the specified type, if such a value has previously been stored to the domain.
66	#[allow(clippy::unwrap_used)]
67	pub fn try_get<T: Any>(&self) -> Option<&T> {
72	/// Same as [`try_get`](#try_get) but grants mutable access to the object.
73	#[allow(clippy::unwrap_used)]
74	pub fn try_get_mut<T: Any>(&mut self) -> Option<&mut T> {
81	/// Return two mutable references to domain objects
82	#[allow(clippy::unwrap_used)]
83	pub fn try_get_2_mut<T1: Any, T2: Any>(&mut self) -> (Option<&mut T1>, Option<&mut T2>) {
115	/// [`try_get()`](#try_get) is usually recommended instead.
116	#[allow(clippy::unwrap_used)]
117	pub fn get<T: Any>(&self) -> &T {
123	/// [`try_get_mut()`](#try_get_mut) is usually recommended instead.
124	#[allow(clippy::unwrap_used)]
125	pub fn get_mut<T: Any>(&mut self) -> &mut T {

paper 0.4.0/src/io/fs.rs

96	match good {
97	#[allow(clippy::unwrap_used)] // Supplier::produce() cannot fail.
98	Self::Good::Read { path } => self

pdbtbx 0.10.1/src/error/context.rs

100	/// Creates a new context to highlight a certain position
101	#[allow(clippy::unwrap_used)]
102	pub fn position(pos: &Position<'_>) -> Context {

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

133	}
134	#[allow(clippy::unwrap_used)]
135	parse_matrix(s, get_f64(&single.content, &context),pdb.scale.as_mut().unwrap(), &context)
140	}
141	#[allow(clippy::unwrap_used)]
142	parse_matrix(s, get_f64(&single.content, &context),pdb.origx.as_mut().unwrap(), &context)
365	// The previous lines make sure that there is no error in the vector.
366	#[allow(clippy::unwrap_used)]
367	let positions: Vec<Option<usize>> = positions_.iter().map(\|i\| *i.as_ref().unwrap()).collect();
436	{
437	#[allow(clippy::unwrap_used)]
438	Some([
482	(*pdb_pointer).add_model(Model::new(model_number));
483	#[allow(clippy::unwrap_used)]
484	(*pdb_pointer).models_mut().rev().next().unwrap()

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

383	let mut charge = 0;
384	#[allow(clippy::unwrap_used)]
385	if chars.len() >= 80 && !(chars[78] == ' ' && chars[79] == ' ') {

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

610	/// Adds all bonds to the PDB, has to be done after all Atoms are already in place
611	#[allow(clippy::unwrap_used)]
612	fn add_bonds(pdb: &mut PDB, bonds: Vec<(Context, LexItem)>) -> Vec<PDBError> {

pdbtbx 0.10.1/src/save/mmcif.rs

46	/// It does change the output format based on the StrictnessLevel given.
47	#[allow(clippy::unwrap_used)]
48	pub fn save_mmcif_raw<T: Write>(pdb: &PDB, mut sink: BufWriter<T>) {

plow_cli 0.4.8/src/config/files/workspace_manifest.rs

106	// in the upcoming architectural changes soon.
107	#[allow(clippy::unwrap_used)]
108	#[allow(clippy::fallible_impl_from)]

plow_cli 0.4.8/src/config.rs

140	// Although there are plans to expand support for custom registries in the future.
141	#[allow(clippy::unwrap_used)]
142	#[allow(clippy::missing_panics_doc)]

plow_cli 0.4.8/src/git.rs

233	#[allow(clippy::missing_panics_doc)]
234	#[allow(clippy::unwrap_used)]
235	#[allow(clippy::unwrap_in_result)]

plow_cli 0.4.8/src/manifest.rs

186	#[allow(clippy::unwrap_used)]
187	#[allow(clippy::missing_panics_doc)]

plow_cli 0.4.8/src/resolve.rs

18	#[allow(clippy::missing_panics_doc)]
19	#[allow(clippy::unwrap_used)]
20	#[allow(clippy::too_many_lines)]
39	#[allow(clippy::unwrap_used)]
40	// We run this one after linting.

plow_cli 0.4.8/src/subcommand/init/workspace/fields.rs

135	#[allow(clippy::unwrap_in_result)]
136	#[allow(clippy::unwrap_used)]
137	pub fn fill_from_backup(root: &Utf8Path) -> Result<Self, CliError> {
167	#[allow(clippy::unwrap_used)]
168	pub fn extend_from_root_excluding_fields_dir_and_plow_backup(
243	#[allow(clippy::indexing_slicing)]
244	#[allow(clippy::unwrap_used)]
245	pub fn write_with_children(&mut self) -> Result<(), CliError> {

plow_cli 0.4.8/src/subcommand/init/workspace.rs

112	#[allow(clippy::unwrap_used)]
113	let root_field_name = root_field_manifest.field_namespace_and_name().unwrap();

plow_linter 0.2.8/src/lint/helpers.rs

157	// Filter underscores and '@' since they are the only allowed chars other than alphanumeric ones.
158	#[allow(clippy::unwrap_used)]
159	let name = namespace_and_name.pop().unwrap().replace('_', "");
161	#[allow(clippy::unwrap_used)]
162	let namespace = namespace_and_name

plow_linter 0.2.8/src/lints/exists_registry_license.rs

44	// We explicitly pass valid data, unwrap is safe here.
45	#[allow(clippy::unwrap_used)]
46	let annotations = graph

plow_linter 0.2.8/src/lints/exists_registry_license_spdx.rs

43	// We explicitly pass valid data, unwrap is safe here.
44	#[allow(clippy::unwrap_used)]
45	let annotations = graph

plow_linter 0.2.8/src/lints/has_at_least_one_valid_license_annotation.rs

29	// TODO: Refactor and finish this function later
30	#[allow(clippy::unwrap_used)]
31	fn run(&self, linter: &Linter) -> LintResult {

plow_linter 0.2.8/src/lints/has_canonical_prefix.rs

37	// We explicitly pass valid data, unwrap is safe here.
38	#[allow(clippy::unwrap_used)]
39	let annotations = rdf_graph_borrow
58	// We know that `annotations` has at least one member here.
59	#[allow(clippy::unwrap_used)]
60	let annotation = annotations.iter().next().unwrap();

plow_linter 0.2.8/src/lints/has_ontology_declaration.rs

16	// TODO: Refactor unwraps
17	#[allow(clippy::unwrap_used)]
18	impl Lint for HasOntologyDeclaration {
32	// We explicitly pass valid data, unwrap is safe here.
33	#[allow(clippy::unwrap_used)]
34	let graph_borrow = linter.graph.inner.borrow();
50	// We explicitly pass valid data, unwrap is safe here.
51	#[allow(clippy::unwrap_used)]
52	if !has_exact_ontology_declaration {

plow_package_management 0.3.1/src/metadata.rs

60	// We explicitly pass valid data, unwrap is safe here.
61	#[allow(clippy::unwrap_used)]
62	let annotations = rdf_graph_borrow
93	// We explicitly pass valid data, unwrap is safe here.
94	#[allow(clippy::unwrap_used)]
95	let annotations = rdf_graph_borrow

plow_package_management 0.3.1/src/registry/on_disk_git.rs

87	if let Some(ssh_priv_key) = ssh_priv_key_to_callback {
88	#[allow(clippy::unwrap_used)]
89	callbacks.credentials(move \|_url, username_from_url, _allowed_types\| {

plow_package_management 0.3.1/src/resolve.rs

420	#[allow(clippy::unwrap_used)]
421	// This is fine, we have just inserted it.
439	#[allow(clippy::unwrap_used)]
440	let mut valid_versions_for_package = self

pmtiles2 0.1.6/src/tile_manager.rs

250	#[test]
251	#[allow(clippy::unwrap_used)]
252	fn test_get_tile_some() -> Result<()> {

pmtiles2 0.1.6/src/util/read_directories.rs

105	#[cfg(test)]
106	#[allow(clippy::unwrap_used)]
107	mod test {

poise 0.5.2/src/framework/mod.rs

98	// point framework_cell has been initialized
99	#[allow(clippy::unwrap_used)]
100	let framework = framework_cell_2.get().unwrap().clone();

preroll 0.10.1/src/middleware/honeycomb/propagation.rs

169	#[test]
170	#[allow(clippy::unwrap_used)]
171	fn test_unmarshal_with_dataset() {

preroll 0.10.1/src/middleware/logger.rs

75	#[cfg(feature = "panic-on-error")]
76	#[allow(clippy::unwrap_used)]
77	if let Some(error) = res.error() {

probe-rs 0.16.0/src/debug/debug_info.rs

623	//UNWRAP: Checked at beginning of loop, functions must contain at least one value
624	#[allow(clippy::unwrap_used)]
625	let last_function = functions.last().unwrap();
749	// If we encountered INLINED functions (all `StackFrames`s in this Vec, except for the last one, which is the containing NON-INLINED function), these are simply added to the list of stack_frames we return.
750	#[allow(clippy::unwrap_used)]
751	let inlined_frame = cached_stack_frames.pop().unwrap(); // unwrap is safe while .len() > 1
760	// If there is only one stack frame, then it is a NON-INLINED function, and we will attempt to unwind further.
761	#[allow(clippy::unwrap_used)]
762	cached_stack_frames.pop().unwrap() // unwrap is safe for .len==1

probe-rs 0.16.0/src/debug/mod.rs

218	#[allow(clippy::unwrap_used, clippy::expect_used)]
219	pub(crate) fn _print_all_attributes(

probe-rs 0.16.0/src/debug/unit_info.rs

919	{
920	#[allow(clippy::unwrap_used)]
921	// Use of `unwrap` below is safe because we first check for `is_none()`.

probe-rs-debugger 0.16.0/src/debug_adapter/protocol.rs

402	#[cfg(test)]
403	#[allow(clippy::unwrap_used)]
404	mod test {

probe-rs-debugger 0.16.0/src/debugger/session_data.rs

257	{
258	#[allow(clippy::unwrap_used)]
259	match target_core.attach_to_rtt(

quarry-mine 5.2.0/src/quarry.rs

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

quarry-mine 5.2.0/src/rewarder.rs

45	#[cfg(test)]
46	#[allow(clippy::unwrap_used)]
47	mod tests {

quarry-mine-ntoken 5.0.3/src/quarry.rs

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

quarry-mine-ntoken 5.0.3/src/rewarder.rs

45	#[cfg(test)]
46	#[allow(clippy::unwrap_used)]
47	mod tests {

reddit-rs 0.1.1/src/client.rs

68	pub async fn from_env(client_name: &str) -> Result<Self, RedditError> {
69	#[allow(clippy::unwrap_used)]
70	Self::try_from_env(client_name).await.unwrap()

requeuest 0.6.0/src/client.rs

170	let (sender, receiver) = oneshot::channel();
171	#[allow(clippy::unwrap_used)] // We don't handle poisoning
172	self.response_sender.lock().unwrap().insert(uuid, sender);
203	let (sender, receiver) = oneshot::channel();
204	#[allow(clippy::unwrap_used)] // We don't handle poisoning
205	self.response_sender.lock().unwrap().insert(uuid, sender);

requeuest 0.6.0/src/job.rs

86	#[allow(clippy::unwrap_used)] // We don't handle poisoning
87	let sender = sender.0.lock().unwrap().remove(&job.id()).ok_or(JobError::MissingSender)?;

rspc 0.1.2/src/router_builder.rs

302	#[cfg(debug_assertions)]
303	#[allow(clippy::unwrap_used)]
304	if let Some(export_path) = export_path {

run-down 0.1.1/src/rundown_ref.rs

202	#[test]
203	#[allow(clippy::result_unwrap_used)]
204	fn test_wait_when_protected() {

russh 0.36.0/src/cipher/chacha20poly1305.rs

177

        cipher.seek(<ChaCha20LegacyCore as BlockSizeUser>::BlockSize::to_usize());

178

        #[allow(clippy::indexing_slicing, clippy::unwrap_used)]

179

        cipher.apply_keystream(&mut plaintext_in_ciphertext_out[PACKET_LENGTH_LEN..]);

russh 0.36.0/src/cipher/gcm.rs

196	#[allow(clippy::indexing_slicing, clippy::unwrap_used)]
197	let tag_out = self

russh 0.36.0/src/key.rs

33	PublicKey::RSA { ref key, .. } => {
34	#[allow(clippy::unwrap_used)] // type known
35	let rsa = key.0.rsa().unwrap();

russh 0.36.0/src/mac/crypto.rs

45	fn compute(&self, sequence_number: u32, payload: &[u8], output: &mut [u8]) {
46	#[allow(clippy::unwrap_used)]
47	let mut hmac = <M as digest::Mac>::new_from_slice(&self.key).unwrap();

russh 0.36.0/src/server/encrypted.rs

48	#[allow(clippy::unwrap_used)]
49	let mut enc = self.common.encrypted.as_mut().unwrap();
144	#[allow(clippy::unwrap_used)]
145	let mut enc = self.common.encrypted.as_mut().unwrap();

russh 0.36.0/src/ssh_read.rs

116	#[allow(clippy::unwrap_used)]
117	pub async fn read_ssh_id(&mut self) -> Result<&[u8], Error> {

russh-keys 0.24.0/src/agent/client.rs

110	#[cfg(feature = "openssl")]
111	#[allow(clippy::unwrap_used)] // key is known to be private
112	key::KeyPair::RSA { ref key, .. } => {
297	#[allow(clippy::indexing_slicing, clippy::unwrap_used)]
298	// length is checked, hash already checked

russh-keys 0.24.0/src/encoding.rs

56	impl Encoding for Vec<u8> {
57	#[allow(clippy::unwrap_used)] // writing into Vec<> can't panic
58	fn extend_ssh_string(&mut self, s: &[u8]) {
63	#[allow(clippy::unwrap_used)] // writing into Vec<> can't panic
64	fn extend_ssh_string_blank(&mut self, len: usize) -> &mut [u8] {
72	#[allow(clippy::unwrap_used)] // writing into Vec<> can't panic
73	#[allow(clippy::indexing_slicing)] // length is known

russh-keys 0.24.0/src/format/openssh.rs

120	let rounds = kdfopts.read_u32()?;
121	#[allow(clippy::unwrap_used)] // parameters are static
122	#[allow(clippy::indexing_slicing)] // output length is static
134	b"aes128-cbc" => {
135	#[allow(clippy::unwrap_used)] // parameters are static
136	let cipher = cbc::Decryptor::<Aes128>::new_from_slices(key, iv).unwrap();
140	b"aes256-cbc" => {
141	#[allow(clippy::unwrap_used)] // parameters are static
142	let cipher = cbc::Decryptor::<Aes256>::new_from_slices(key, iv).unwrap();
146	b"aes128-ctr" => {
147	#[allow(clippy::unwrap_used)] // parameters are static
148	let mut cipher = Ctr64LE::<Aes128>::new_from_slices(key, iv).unwrap();
152	b"aes256-ctr" => {
153	#[allow(clippy::unwrap_used)] // parameters are static
154	let mut cipher = Ctr64LE::<Aes256>::new_from_slices(key, iv).unwrap();

rust_filen 0.3.0/src/filen_settings.rs

11	#[allow(clippy::unwrap_used)]
12	static DEFAULT_API_SERVERS: Lazy<Vec<Url>> = Lazy::new(\|\| {
25	#[allow(clippy::unwrap_used)]
26	static DEFAULT_DOWNLOAD_SERVERS: Lazy<Vec<Url>> = Lazy::new(\|\| {
39	#[allow(clippy::unwrap_used)]
40	static DEFAULT_UPLOAD_SERVERS: Lazy<Vec<Url>> = Lazy::new(\|\| {

rust_filen 0.3.0/src/queries.rs

17	#[allow(clippy::unwrap_used)]
18	#[cfg(feature = "async")]
22	#[allow(clippy::unwrap_used)]
23	#[cfg(feature = "async")]

rust_filen 0.3.0/src/test_utils.rs

38	#[allow(clippy::unwrap_used)]
39	pub fn init_server() -> (MockServer, FilenSettings) {

s3-server 0.2.0/src/ops/put_object.rs

96	#[allow(clippy::unwrap_used)]
97	let multipart = ctx.multipart.as_ref().unwrap();

s3s 0.2.0/src/signature_v4/methods.rs

82	#[allow(clippy::unwrap_used)]
83	let s = from_ascii(buf.as_ref()).unwrap();

s3s 0.2.0/src/utils.rs

49	/// on-stack formatting
50	#[allow(clippy::unwrap_used)]
51	pub fn fmt_timestamp<T>(val: &Timestamp, fmt: TimestampFormat, f: impl FnOnce(&[u8]) -> T) -> T {

s3s 0.2.0/src/xml/de.rs

129	/// Peeks the next event
130	#[allow(clippy::unwrap_used, clippy::unwrap_in_result)]
131	fn peek_event(&mut self) -> DeResult<DeEvent<'xml>> {

serenity 0.11.5/src/builder/create_message.rs

219

    /// Set the reference message this message is a reply to.

220

    #[allow(clippy::unwrap_used)] // allowing unwrap here because serializing MessageReference should never error

221

    pub fn reference_message(&mut self, reference: impl Into<MessageReference>) -> &mut Self {

serenity 0.11.5/src/client/mod.rs

354	#[allow(clippy::unwrap_used)] // Allowing unwrap because all should be Some() by this point
355	#[instrument(skip(self))]

serenity 0.11.5/src/collector/component_interaction_collector.rs

214	/// Use the given configuration to build the [`ComponentInteractionCollector`].
215	#[allow(clippy::unwrap_used)]
216	#[must_use]
251	type Output = Option<Arc<MessageComponentInteraction>>;
252	#[allow(clippy::unwrap_used)]
253	fn poll(mut self: Pin<&mut Self>, ctx: &mut FutContext<'_>) -> Poll<Self::Output> {

serenity 0.11.5/src/collector/event_collector.rs

170	/// Only events with types passed to [`Self::add_event_type`] as counted towards this limit.
171	#[allow(clippy::unwrap_used)]
172	pub fn filter_limit(mut self, limit: u32) -> Self {
181	/// passes all the requirements.
182	#[allow(clippy::unwrap_used)]
183	pub fn collect_limit(mut self, limit: u32) -> Self {
192	/// This is the last step to pass for a event to count as collected.
193	#[allow(clippy::unwrap_used)]
194	pub fn filter<F: Fn(&Arc<Event>) -> bool + 'static + Send + Sync>(
204	/// If an event does not have one of these types, it won't be received.
205	#[allow(clippy::unwrap_used)]
206	pub fn add_event_type(mut self, event_type: EventType) -> Self {
213	/// If an event does not have this ID, it won't be received.
214	#[allow(clippy::unwrap_used)]
215	pub fn add_user_id(mut self, user_id: impl Into<UserId>) -> Self {

serenity 0.11.5/src/collector/message_collector.rs

186	/// passes all the requirements.
187	#[allow(clippy::unwrap_used)]
188	#[must_use]

shio 0.3.0/src/ext/net.rs

17	#[cfg_attr(feature = "cargo-clippy", allow(result_unwrap_used))]
18	fn to_socket_addrs_ext(&self) -> io::Result<Self::Iter> {

siderophile 0.2.1/src/callgraph_gen.rs

128	#[allow(clippy::missing_panics_doc, clippy::unwrap_used)]
129	#[must_use]

siderophile 0.2.1/src/trawl_source/ast_walker.rs

305	/// Scan a single file for `unsafe` usage.
306	#[allow(clippy::unwrap_used)]
307	pub fn find_unsafe_in_file(

siderophile 0.2.1/src/trawl_source/mod.rs

125	#[allow(clippy::expect_used, clippy::unwrap_used)]
126	fn find_rs_files_in_package(pack: &Package) -> Vec<RsFile> {
182	/// downloads fail
183	#[allow(clippy::unwrap_used)]
184	fn get_many<'a>(

siderophile 0.2.1/src/utils.rs

20	#[allow(clippy::missing_panics_doc, clippy::unwrap_used)]
21	#[must_use]
86	#[allow(clippy::missing_panics_doc, clippy::expect_used, clippy::unwrap_used)]
87	pub fn configure_rustup_toolchain() {

sigma-ser 0.11.0/src/scorex_serialize.rs

189	#[allow(clippy::unwrap_used)]
190	#[cfg(test)]

sigma-ser 0.11.0/src/vlq_encode.rs

56	fn put_usize_as_u16_unwrapped(&mut self, v: usize) -> io::Result<()> {
57	#[allow(clippy::unwrap_used)]
58	Self::put_u16(self, u16::try_from(v).unwrap())
62	fn put_usize_as_u32_unwrapped(&mut self, v: usize) -> io::Result<()> {
63	#[allow(clippy::unwrap_used)]
64	Self::put_u32(self, u32::try_from(v).unwrap())
261	#[allow(clippy::unwrap_used)]
262	#[cfg(test)]

signalo_filters 0.6.0/src/median/mod.rs

391	unsafe fn median_unchecked(&mut self) -> T {
392	#[allow(clippy::unwrap_used)]
393	self.median().unwrap()

sigstore 0.6.0/src/registry/oci_caching_client.rs

84	#[allow(clippy::unwrap_used)]
85	pub fn image(&self) -> oci_distribution::Reference {
175	#[allow(clippy::unwrap_used)]
176	pub fn image(&self) -> oci_distribution::Reference {

simdutf8 0.1.4/tests/tests.rs

28	for _ in 0..count {
29	#[allow(clippy::unwrap_used)]
30	res.write_all(x).unwrap();

simulated_annealing 0.2.0/src/schedule.rs

48	#[allow(clippy::unwrap_in_result)]
49	#[allow(clippy::unwrap_used)]
50	pub fn cool(&self, k: usize, t: F, t_0: F) -> Result<F> {

skillratings 0.24.0/src/dwz.rs

736	#[allow(clippy::unwrap_used)]
737	let player = get_first_dwz(
823	#[allow(clippy::unwrap_used)]
824	let bad_player = get_first_dwz(
851	#[allow(clippy::unwrap_used)]
852	let really_bad_player = get_first_dwz(

skyspell 1.0.1/src/interactor.rs

20	fn input(&self, prompt: &str) -> String {
21	#[allow(clippy::unwrap_used)]
22	Input::new()
29	fn input_letter(&self, prompt: &str, choices: &str) -> String {
30	#[allow(clippy::unwrap_used)]
31	Input::new()
44	fn select(&self, prompt: &str, choices: &[&str]) -> Option<usize> {
45	#[allow(clippy::unwrap_used)]
46	Select::new()
57	fn confirm(&self, prompt: &str) -> bool {
58	#[allow(clippy::unwrap_used)]
59	Confirm::new().with_prompt(prompt).interact().unwrap()

slice-deque 0.3.0/src/lib.rs

2303	#[cfg(feature = "unstable")]
2304	#[allow(clippy::option_unwrap_used)]
2305	#[inline]

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

2303	#[cfg(feature = "unstable")]
2304	#[allow(clippy::option_unwrap_used)]
2305	#[inline]

sn_interface 0.16.20/src/network_knowledge/sections_dag.rs

1135	// inserted, providing no new information. Useful in `SectionTree` proptest where we want new_information_only.
1136	#[allow(clippy::unwrap_used)]
1137	pub(crate) fn arb_sections_dag_and_proof_chains(

sn_interface 0.16.20/src/types/keys/ed25519.rs

78	#[cfg(feature = "proptest")]
79	#[allow(clippy::unwrap_used)]
80	pub mod proptesting {

snapshots 0.2.8/src/instructions/sync.rs

160	#[cfg(test)]
161	#[allow(clippy::unwrap_used)]
162	mod test {

snapshots-math 0.2.8/src/lib.rs

76	#[cfg(test)]
77	#[allow(clippy::unwrap_used, clippy::integer_arithmetic)]
78	mod tests {

sqlx-database-tester 0.4.2/src/lib.rs

54	#[cfg(test)]
55	#[allow(clippy::unwrap_used)]
56	mod tests {

sqlx-database-tester 0.4.2/tests/mod.rs

32	#[should_panic(expected = "test")]
33	#[allow(unreachable_code, clippy::unwrap_used)]
34	async fn test_own_transaction_panic() {

stable-swap 1.8.1/src/processor/admin.rs

263	#[cfg(test)]
264	#[allow(clippy::unwrap_used, clippy::integer_arithmetic)]
265	mod tests {

stable-swap 1.8.1/src/processor/mod.rs

13	#[cfg(test)]
14	#[allow(clippy::unwrap_used)]
15	mod test_utils;
37	#[cfg(test)]
38	#[allow(clippy::unwrap_used)]
39	mod tests {

stable-swap 1.8.1/src/processor/swap.rs

840	#[cfg(test)]
841	#[allow(clippy::unwrap_used)]
842	mod tests {

stable-swap-client 1.8.1/src/fees.rs

83	#[cfg(test)]
84	#[allow(clippy::unwrap_used)]
85	mod tests {

stable-swap-client 1.8.1/src/instruction.rs

794	#[cfg(test)]
795	#[allow(clippy::unwrap_used)]
796	mod tests {

stable-swap-client 1.8.1/src/state.rs

183	#[cfg(test)]
184	#[allow(clippy::unwrap_used)]
185	mod tests {

stable-swap-math 1.8.1/src/curve.rs

402	#[allow(
403	clippy::unwrap_used,
404	clippy::integer_arithmetic,

stable-swap-math 1.8.1/src/math.rs

108	#[cfg(test)]
109	#[allow(clippy::unwrap_used)]
110	mod tests {

stable-swap-math 1.8.1/src/pool_converter.rs

63	#[cfg(test)]
64	#[allow(clippy::unwrap_used, clippy::integer_arithmetic)]
65	mod tests {

stable-swap-math 1.8.1/src/price.rs

114	#[cfg(test)]
115	#[allow(clippy::unwrap_used)]
116	mod tests {

strict-env 0.1.2/src/lib.rs

174	clippy::missing_const_for_fn,
175	clippy::unwrap_used,
176	clippy::wildcard_imports

sunxdcc 0.1.1/src/lib.rs

166	// Unwrap safety: BASE_URL is a correct URL and our parameters cannot cause an error.
167	#[allow(clippy::unwrap_used)]
168	let url = Url::parse_with_params(

swarm-bot 0.3.4/src/client/physics/mod.rs

211	// we know there is at least one value
212	#[allow(clippy::unwrap_used)]
213	let face_idx = IntoIterator::into_iter(faces)

swarm-bot 0.3.4/src/schematic.rs

63	#[allow(unused, clippy::unwrap_used)]
64	pub fn width(&self) -> u64 {
68	#[allow(unused, clippy::unwrap_used)]
69	pub fn height(&self) -> u64 {
73	#[allow(unused, clippy::unwrap_used)]
74	pub fn length(&self) -> u64 {
78	#[allow(unused, clippy::unwrap_used, clippy::indexing_slicing)]
79	pub fn blocks(&self) -> impl Iterator<Item = (BlockLocation, BlockState)> + '_ {

sxd_html 0.1.1/examples/github_trending.rs

16	let user = evaluate_xpath_node(repo_a, "./span/text()")?.into_string();
17	#[allow(clippy::unwrap_used)]
18	let name = repo_a

tor-basic-utils 0.5.0/src/iter.rs

156	#[cfg(test)]
157	#[allow(clippy::unwrap_used)]
158	mod test {

tor-bytes 0.6.0/src/writer.rs

180	#[cfg(test)]
181	#[allow(clippy::unwrap_used)]
182	mod tests {

tor-cert 0.6.0/src/encode.rs

159	#[cfg(test)]
160	#[allow(clippy::unwrap_used)]
161	mod test {

tor-chanmgr 0.8.0/src/event.rs

397	#[cfg(test)]
398	#[allow(clippy::unwrap_used, clippy::cognitive_complexity)]
399	mod test {

tor-circmgr 0.7.0/src/mgr.rs

695	// These try_into() calls can't fail, so unwrap() can't panic.
696	#[allow(clippy::unwrap_used)]
697	UnusedTimings {
1510	mod test {
1511	#![allow(clippy::unwrap_used)]
1512	use super::*;

tor-config 0.7.0/src/lib.rs

422	#[cfg(test)]
423	#[allow(clippy::unwrap_used)] // why is this not the default in tests
424	mod test {

tor-config 0.7.0/src/load.rs

654	#[allow(unreachable_pub)] // impl_standard_builder wants to make pub fns
655	#[allow(clippy::unwrap_used)] // OK in tests
656	mod test {

tor-congestion 0.4.0/src/rtt.rs

250	#[cfg(test)]
251	#[allow(clippy::unwrap_used, clippy::print_stderr)]
252	mod test {

tor-dirmgr 0.9.0/src/bootstrap.rs

629	// Unwrap should be safe due to parent `.is_some()` check
630	#[allow(clippy::unwrap_used)]
631	let _ = on_usable.take().unwrap().send(());
676	mod test {
677	#![allow(clippy::unwrap_used)]
678	use super::*;

tor-dirmgr 0.9.0/src/event.rs

817	#[allow(clippy::unwrap_used)]
818	#[cfg(test)]

tor-llcrypto 0.4.0/src/util/rand_compat.rs

119	// so this conversion will succeed, so this unwrap can't panic.
120	#[allow(clippy::unwrap_used)]
121	let nz: NonZeroU32 = OldError::CUSTOM_START.try_into().unwrap();
127	mod test {
128	#![allow(clippy::unwrap_used)]
129	use super::*;

tor-netdir 0.7.0/src/params.rs

380	#[allow(clippy::many_single_char_names)]
381	#[allow(clippy::unwrap_used)]
382	#[allow(clippy::cognitive_complexity)]

tor-netdir 0.7.0/src/weight.rs

140	// The unwrap() is safe because array is nonempty.
141	#[allow(clippy::unwrap_used)]
142	fn max_weight(&self) -> u32 {
318	// The unwrap() is safe because `w` is nonempty.
319	#[allow(clippy::unwrap_used)]
320	let w_max = w.iter().map(RelayWeight::max_weight).max().unwrap();
401	mod test {
402	#![allow(clippy::unwrap_used)]
403	use super::*;

tor-netdoc 0.6.0/src/doc/authcert.rs

211	// returned an Error
212	#[allow(clippy::unwrap_used)]
213	let first_item = body.first_item().unwrap();
223	// returned an Error
224	#[allow(clippy::unwrap_used)]
225	let last_item = body.last_item().unwrap();
286	// have already returned an Error
287	#[allow(clippy::unwrap_used)]
288	let mut tag = crosscert.obj_tag().unwrap();
309	// returned an Error
310	#[allow(clippy::unwrap_used)]
311	let start_offset = body.first_item().unwrap().offset_in(s).unwrap();
416	mod test {
417	#![allow(clippy::unwrap_used)]
418	use super::*;

tor-netdoc 0.6.0/src/doc/microdesc.rs

262	// had there not been at least one item.
263	#[allow(clippy::unwrap_used)]
264	let first = body.first_item().unwrap();
270	// Unwrap is safe here because we are parsing these strings from s
271	#[allow(clippy::unwrap_used)]
272	util::str::str_offset(s, first.kwd_str()).unwrap()
456	mod test {
457	#![allow(clippy::unwrap_used)]
458	use super::*;

tor-rtcompat 0.8.0/src/scheduler.rs

279	#[test]
280	#[allow(clippy::unwrap_used)]
281	fn it_dies_if_dropped() {

trace4rs 0.5.0/src/env/mod.rs

8	#[allow(clippy::unwrap_used)] // ok since its a lit and tests hit this.
9	static RE: once_cell::sync::Lazy<regex::Regex> =

trace4rs-fmtorp 0.5.0/src/lib.rs

126	// unwrap ok since idxs coming from same vec
127	#[allow(clippy::unwrap_used)]
128	let field = self.field_from_id(i).unwrap();

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

188	let ptr = heap as *mut BinaryHeap<T>;
189	#[allow(clippy::unwrap_used)]
190	let mut data = (0..heap.len())

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

414	}
415	#[allow(clippy::unwrap_used)]
416	(0..index).fold(self.head, \|node, _\| unsafe { node.unwrap().as_ref().prev })
699	}
700	#[allow(clippy::unwrap_used)] // Index is valid
701	if index <= self.len / 2 {

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

162	}
163	#[allow(clippy::unwrap_used)] // We already the index is valid
164	(0..index).fold(self.top, \|node, _\| unsafe { node.unwrap().as_ref() }.prev)

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

105	#[inline(always)]
106	#[allow(clippy::unwrap_used, clippy::uninit_vec)]
107	fn parse_array(&mut self, len: usize) -> Value<'input> {
122	#[inline(always)]
123	#[allow(clippy::unwrap_used)]
124	fn parse_map(&mut self, len: usize) -> Value<'input> {
153	mod test {
154	#![allow(clippy::unwrap_used)]
155	use super::*;

ttyrec 0.3.3/src/creator.rs

52	#[cfg(test)]
53	#[allow(clippy::unwrap_used)]
54	mod test {

ttyrec 0.3.3/src/frame.rs

45	#[cfg(test)]
46	#[allow(clippy::unwrap_used)]
47	mod test {

twilight-bucket 0.2.2/src/lib.rs

175	/// If the `id` is 0 or when the usage count is over [`u16::MAX`]
176	#[allow(clippy::unwrap_used, clippy::integer_arithmetic)]
177	pub fn register(&self, id: u64) {
215	#[must_use]
216	#[allow(clippy::unwrap_in_result, clippy::unwrap_used)]
217	pub fn limit_duration(&self, id: u64) -> Option<Duration> {
233	#[allow(clippy::unwrap_used)]
234	#[tokio::test]
250	#[allow(clippy::unwrap_used)]
251	#[tokio::test]

twilight-error 0.12.0/src/lib.rs

91	/// If the fallback message or webhook content is somehow invalid
92	#[allow(clippy::unwrap_used, unused_must_use, clippy::print_stderr)]
93	pub async fn handle(&self, http: &Client, error: impl Display + Send) {
117	/// message
118	#[allow(unused_must_use, clippy::unwrap_used)]
119	async fn maybe_create_message(&self, http: &Client, error_message: &mut String) {
141	/// message
142	#[allow(unused_must_use, clippy::unwrap_used)]
143	async fn maybe_execute_webhook(&self, http: &Client, error_message: &mut String) {

twilight-webhook 0.14.0/src/cache.rs

109	/// If the webhook that was just inserted to the cache somehow doesn't exist
110	#[allow(clippy::unwrap_used)]
111	pub async fn get_infallible(
257	#[allow(clippy::unwrap_used)]
258	async fn mock_update(cache: &WebhooksCache, event: &Event) {

unchecked_unwrap 4.0.0/benches/benches.rs

54	for _ in 0..1000 {
55	#[allow(clippy::unwrap_used)]
56	black_box(black_box(result).unwrap());

up-rs 0.13.3/src/config.rs

194	#[cfg(test)]
195	#[allow(clippy::unwrap_used)]
196	mod yaml_paths_tests {

venko 0.1.1/src/state.rs

86	#[cfg(test)]
87	#[allow(clippy::unwrap_used)]
88	mod tests {

vsmtp-plugin-mysql 1.4.0-rc.10/src/lib.rs

39	clippy::indexing_slicing,
40	clippy::unwrap_used,
41	clippy::unwrap_in_result,
58	pub extern "C" fn module_entrypoint() -> Shared<Module> {
59	#[allow(clippy::unwrap_used)]
60	set_ahash_seed(Some([1, 2, 3, 4])).unwrap();

watchexec-cli 1.21.0/src/config/runtime.rs

313	// UNWRAP: checked by first if branch
314	#[allow(clippy::unwrap_used)]
315	let (shprog, shopts) = sh.split_first().unwrap();

wavegen 0.4.1/src/lib.rs

631	#[allow(clippy::iter_nth_zero)]
632	#[allow(clippy::unwrap_used)]
633	fn nth_and_next_give_same_results() {

xmp_toolkit 1.0.1/src/ffi.rs

73	impl CXmpError {
74	#[allow(dead_code, clippy::unwrap_used)] // only used in test code
75	pub(crate) fn new(had_error: bool, id: i32, debug_message: Option<&str>) -> Self {

xorsum 4.0.0/src/module.rs

90	}
91	#[allow(clippy::unwrap_used)]
92	String::from_utf8(v).unwrap()

yi 0.4.0/src/state.rs

99	#[cfg(test)]
100	#[allow(clippy::unwrap_used, clippy::integer_arithmetic)]
101	mod tests {

zerovec 0.9.2/src/flexzerovec/slice.rs

546	let new_count = 1 + (self.data.len() / old_width);
547	#[allow(clippy::unwrap_used)] // panic is documented in function contract
548	let new_bytes_len = new_count

zerovec 0.9.2/src/map/borrowed.rs

230	pub fn iter_keys<'b>(&'b self) -> impl Iterator<Item = &'a <K as ZeroMapKV<'a>>::GetType> + 'b {
231	#[allow(clippy::unwrap_used)] // idx in 0..keys.zvl_len()
232	(0..self.keys.zvl_len()).map(move \|idx\| self.keys.zvl_get(idx).unwrap())
238	) -> impl Iterator<Item = &'a <V as ZeroMapKV<'a>>::GetType> + 'b {
239	#[allow(clippy::unwrap_used)] // idx in 0..keys.zvl_len() == values.zvl_len()
240	(0..self.values.zvl_len()).map(move \|idx\| self.values.zvl_get(idx).unwrap())
261	(
262	#[allow(clippy::unwrap_used)] // idx in 0..keys.zvl_len()
263	self.keys.zvl_get(idx).unwrap(),
264	#[allow(clippy::unwrap_used)] // idx in 0..keys.zvl_len() = values.zvl_len()
265	self.values.get(idx).unwrap(),
284	(
285	#[allow(clippy::unwrap_used)] // idx in 0..keys.zvl_len()
286	ZeroSlice::get(keys, idx).unwrap(),

zerovec 0.9.2/src/map/map.rs

298	(
299	#[allow(clippy::unwrap_used)] // idx is in-range
300	self.keys.zvl_get(idx).unwrap(),
301	#[allow(clippy::unwrap_used)] // idx is in-range
302	self.values.zvl_get(idx).unwrap(),
310	) -> impl ExactSizeIterator<Item = &'b <K as ZeroMapKV<'a>>::GetType> {
311	#[allow(clippy::unwrap_used)] // idx is in-range
312	(0..self.keys.zvl_len()).map(move \|idx\| self.keys.zvl_get(idx).unwrap())
318	) -> impl ExactSizeIterator<Item = &'b <V as ZeroMapKV<'a>>::GetType> {
319	#[allow(clippy::unwrap_used)] // idx is in-range
320	(0..self.values.zvl_len()).map(move \|idx\| self.values.zvl_get(idx).unwrap())

zune-jpeg 0.2.0/src/bitstream.rs

268	clippy::cast_sign_loss,
269	clippy::unwrap_used
270	)]

zune-jpeg 0.2.0/src/worker.rs

140	clippy::needless_pass_by_value,
141	clippy::unwrap_used
142	)]

advent-of-code 2022.0.46/benches/benchmark.rs

5	pub fn criterion_benchmark(c: &mut Criterion) {
6	#![allow(clippy::unwrap_used)]
7	for year in 2015..=2022 {

advent-of-code 2022.0.46/benches/iai.rs

4	fn problem_2015_1_1() {
5	#![allow(clippy::unwrap_used)]
6	let input = read_to_string("src/year2015/day01_input.txt").unwrap();
10	fn problem_2015_1_2() {
11	#![allow(clippy::unwrap_used)]
12	let input = read_to_string("src/year2015/day01_input.txt").unwrap();
16	fn problem_2015_2_1() {
17	#![allow(clippy::unwrap_used)]
18	let input = read_to_string("src/year2015/day02_input.txt").unwrap();
22	fn problem_2015_2_2() {
23	#![allow(clippy::unwrap_used)]
24	let input = read_to_string("src/year2015/day02_input.txt").unwrap();
28	fn problem_2015_3_1() {
29	#![allow(clippy::unwrap_used)]
30	let input = read_to_string("src/year2015/day03_input.txt").unwrap();

advent-of-code 2022.0.46/src/year2020/day22.rs

22	) -> Winner {
23	#![allow(clippy::unwrap_used)]
24	let mut seen_1 = HashSet::new();

advent-of-code 2022.0.46/src/year2022/day25.rs

26	fn decimal_to_snafu(mut decimal: i64) -> String {
27	#![allow(clippy::unwrap_used)]
28	if decimal == 0 {

Aetherus 0.1.1/src/lib.rs

34	clippy::unreachable,
35	clippy::unwrap_used
36	)]

arith_traits 0.3.2/src/xl_types/big_int/unit_tests.rs

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

arith_traits 0.3.2/src/xl_types/big_uint/unit_tests.rs

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

arranged 0.1.2/src/range/inclusive/into_iter_ri/unit_tests.rs

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

arranged 0.1.2/src/range/inclusive/unit_tests.rs

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

arranged 0.1.2/src/ranged/unit_tests.rs

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

arti 1.1.0/src/cfg.rs

237	#![allow(clippy::single_char_pattern)]
238	#![allow(clippy::unwrap_used)]
239	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

arti-bench 0.8.0/src/main.rs

43	// because it's OK if tests and benchmarks simply crash if things go wrong.
44	#![allow(clippy::unwrap_used)]

arti-client 0.8.0/examples/advanced_isolation.rs

7	#![allow(clippy::single_char_pattern)]
8	#![allow(clippy::unwrap_used)]
9	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

arti-client 0.8.0/examples/hook-tcp.rs

7	#![allow(clippy::single_char_pattern)]
8	#![allow(clippy::unwrap_used)]
9	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

arti-client 0.8.0/examples/lazy-init.rs

7	#![allow(clippy::single_char_pattern)]
8	#![allow(clippy::unwrap_used)]
9	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

arti-client 0.8.0/examples/readme.rs

7	#![allow(clippy::single_char_pattern)]
8	#![allow(clippy::unwrap_used)]
9	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

arti-client 0.8.0/src/address.rs

371	mod test {
372	#![allow(clippy::unwrap_used)]
373	use super::*;

arti-client 0.8.0/src/client.rs

1133	mod test {
1134	#![allow(clippy::unwrap_used)]

arti-client 0.8.0/src/config.rs

551	mod test {
552	#![allow(clippy::unwrap_used)]
553	use super::*;

arti-hyper 0.8.0/examples/hyper.rs

7	#![allow(clippy::single_char_pattern)]
8	#![allow(clippy::unwrap_used)]
9	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

atlasserver 0.3.0/src/schema/mod.rs

2	#![allow(clippy::pedantic)]
3	#![allow(clippy::unwrap_used)]
4	#![allow(clippy::nursery)]

axum-cometd 0.9.0-alpha.4/src/types/id.rs

97	mod tests {
98	#![allow(clippy::unwrap_used)]

axum-cometd 0.9.0-alpha.4/src/types/messages/de.rs

26	mod tests {
27	#![allow(clippy::unwrap_used)]

axum-named-routes 0.2.2/src/lib.rs

371	mod tests {
372	#![allow(clippy::unwrap_used)]

babbage 0.1.1/src/lib.rs

28	clippy::unreachable,
29	clippy::unwrap_used
30	)]

blake2-rfc_bellman_edition 0.0.1/src/blake2b.rs

56	mod tests {
57	#![cfg_attr(feature = "cargo-clippy", allow(result_unwrap_used))]

blake2-rfc_bellman_edition 0.0.1/src/blake2s.rs

54	mod tests {
55	#![cfg_attr(feature = "cargo-clippy", allow(result_unwrap_used))]

bodhi 2.0.1/src/tests/mod.rs

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

c2pa 1.0.0/src/assertion.rs

610	pub mod tests {
611	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/actions.rs

307	#![allow(clippy::panic)]
308	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/creative_work.rs

106	#![allow(clippy::expect_used)]
107	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/data_hash.rs

246	#![allow(clippy::panic)]
247	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/ingredient.rs

143	#![allow(clippy::panic)]
144	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/metadata.rs

263	#![allow(clippy::expect_used)]
264	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/schema_org.rs

207	#![allow(clippy::expect_used)]
208	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/thumbnail.rs

87	#![allow(clippy::expect_used)]
88	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/user.rs

74	#![allow(clippy::expect_used)]
75	#![allow(clippy::unwrap_used)]

c2pa 1.0.0/src/assertions/user_cbor.rs

74	#![allow(clippy::expect_used)]
75	#![allow(clippy::unwrap_used)]

c2patool 0.3.9/src/main.rs

237	pub mod tests {
238	#![allow(clippy::unwrap_used)]

cargo-asm 0.1.16/src/main.rs

5	allow(
6	missing_docs_in_private_items, option_unwrap_used, result_unwrap_used
7	)

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

1039	#![allow(deprecated)]
1040	#![allow(clippy::unwrap_used)]

cartograph 0.1.2/src/lib.rs

28	clippy::unreachable,
29	clippy::unwrap_used
30	)]

confget 5.0.1/src/tests.rs

33	#![allow(clippy::panic_in_result_fn)]
34	#![allow(clippy::unwrap_used)]

core_arch 0.1.5/tests/cpu-detection.rs

2	#![cfg_attr(stdsimd_strict, deny(warnings))]
3	#![allow(clippy::option_unwrap_used, clippy::print_stdout, clippy::use_debug)]

coresimd 0.1.2/tests/cpu-detection.rs

4	feature = "cargo-clippy",
5	allow(option_unwrap_used, print_stdout, use_debug)
6	)]

deca 0.0.10/tests/integration_tests.rs

1	#![allow(clippy::unwrap_used)]
2	// Runs the BonCoder/BestCoder test (BC_test). It requires SUPER-CHIP quirks compatibility, and

deltachat_message_parser 0.4.0/src/parser/link_url.rs

378	mod test {
379	#![allow(clippy::unwrap_used)]
380	use crate::parser::link_url::{parse_url, punycode_encode, UrlInfo};

deranged 0.3.0/src/tests.rs

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

diffuse 0.1.1/src/lib.rs

28	clippy::unreachable,
29	clippy::unwrap_used
30	)]

dxr 0.5.1/src/checks.rs

1	#![allow(unused_imports)]
2	#![allow(clippy::unwrap_used)]

dxr 0.5.1/src/tests.rs

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

dxr_shared 0.5.1/src/checks.rs

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

dxr_shared 0.5.1/src/tests.rs

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

dylint 2.1.3/src/driver_builder.rs

225	mod test {
226	#![allow(clippy::unwrap_used)]

dylint 2.1.3/src/lib.rs

525	mod test {
526	#![allow(clippy::unwrap_used)]

dylint 2.1.3/src/package_options/revs.rs

130	mod test {
131	#![allow(clippy::unwrap_used)]

dylint_driver 2.1.3/src/lib.rs

312	mod test {
313	#![allow(clippy::unwrap_used)]

dylint-link 2.1.3/src/main.rs

275	mod test {
276	#![allow(clippy::unwrap_used)]

ext-php-rs 0.10.0/src/zend/ce.rs

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

ferium 4.3.4/src/subcommands/list.rs

1	#![allow(clippy::unwrap_used)] // GitHub API wrapper `Option`s every damn thing for some reason

fetcher-core 0.10.0/src/read_filter/newer.rs

74	mod tests {
75	#![allow(clippy::unwrap_used)]
76	use super::*;

file-with-meta 0.2.0/src/tests.rs

29	#![allow(clippy::print_stdout)]
30	#![allow(clippy::unwrap_used)]
31	#![allow(clippy::use_debug)]

fs-mistrust 0.6.0/src/dir.rs

250	mod test {
251	#![allow(clippy::unwrap_used)]
252	use super::*;

fs-mistrust 0.6.0/src/lib.rs

580	mod test {
581	#![allow(clippy::unwrap_used)]
582	use super::*;

fs-mistrust 0.6.0/src/user/serde_support.rs

146	mod test {
147	#![allow(clippy::unwrap_used)]
148	use super::*;

fs-mistrust 0.6.0/src/user.rs

261	mod test {
262	#![allow(clippy::unwrap_used)]
263	use super::*;

fs-mistrust 0.6.0/src/walk.rs

389	mod test {
390	#![allow(clippy::unwrap_used)]
391	use super::*;

gitig 0.3.0/src/helpers.rs

6	// `#![...]` it onto the entire module.
7	#![allow(clippy::result_unwrap_used)]
8	use log::{info, trace};

human-time 0.1.6/src/lib.rs

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

icu_provider_fs 1.1.0/src/export/mod.rs

72	clippy::indexing_slicing,
73	clippy::unwrap_used,
74	clippy::expect_used,

imdl 0.1.12/src/invariant.rs

6	fn invariant_unwrap<D: Display>(self, invariant: D) -> T {
7	#![allow(clippy::unwrap_used)]
8	self.invariant(invariant).unwrap()

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

12	clippy::indexing_slicing,
13	clippy::unwrap_used,
14	clippy::needless_borrow,

lcov2cobertura 1.0.1/src/tests.rs

1	// safety: if tests panic we see it on CI
2	#![allow(clippy::unwrap_used)]

libpass 0.4.0/src/tests.rs

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

metrics-prometheus 0.3.1/src/storage/immutable.rs

138	// PANIC: `RwLock` usage is fully panic-safe here.
139	#![allow(clippy::unwrap_used)]

metrics-prometheus 0.3.1/src/storage/mutable.rs

119	clippy::unwrap_in_result,
120	clippy::unwrap_used
121	)]
174	clippy::unwrap_in_result,
175	clippy::unwrap_used
176	)]
246	clippy::unwrap_in_result,
247	clippy::unwrap_used
248	)]

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

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

octopt 1.0.0/tests/tests.rs

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

ofnn 0.1.3/examples/cifar10.rs

1	//! CIFAR10 example.
2	#![allow(clippy::missing_docs_in_private_items, clippy::print_stdout, clippy::unwrap_used)]

ofnn 0.1.3/examples/simple-categorical.rs

1	//! Simple categorical example.
2	#![allow(clippy::missing_docs_in_private_items, clippy::print_stdout, clippy::unwrap_used)]

ofnn 0.1.3/examples/simple.rs

1	//! Simple example.
2	#![allow(clippy::missing_docs_in_private_items, clippy::print_stdout, clippy::unwrap_used)]

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

1	#![allow(clippy::unwrap_used)]
2	use super::lexitem::*;

preroll 0.10.1/src/test_utils/mod.rs

27	#![allow(clippy::unwrap_used)]

ranged_type 0.1.0/src/ranged_i32/unit_tests.rs

1	#![allow(clippy::unwrap_used, clippy::wildcard_imports, non_snake_case)]
2	use super::*;

rdma 0.3.0/src/lib.rs

8	clippy::expect_used,
9	clippy::unwrap_used,
10	clippy::wildcard_imports,

renovate 0.2.23/src/repo/git.rs

1	#![allow(clippy::unwrap_used)]
2	use git2::{Error, IndexAddOption, Object, ObjectType, Oid, Repository, Signature};

requeuest 0.6.0/src/request.rs

191	mod tests {
192	#![allow(clippy::unwrap_used)]
193	use reqwest::{

requeuest 0.6.0/tests/send.rs

3	#![allow(clippy::unwrap_used, clippy::expect_used)]

romu 0.5.1/src/lib.rs

720	mod tests {
721	#![allow(clippy::unwrap_used)]
722	use super::*;

rss2email 1.0.1/benches/benchmarks/mod.rs

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

safelog 0.2.0/src/flags.rs

182	mod test {
183	#![allow(clippy::unwrap_used)]
184	use super::*;

safelog 0.2.0/src/lib.rs

304	mod test {
305	#![allow(clippy::unwrap_used)]
306	use super::*;

shallow-tees 0.1.1/src/tests.rs

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

simd-json 0.7.0/src/serde.rs

402	mod test {
403	#![allow(clippy::unwrap_used)]
404	use crate::{

skyspell_core 1.0.3/src/tests.rs

1	#![allow(clippy::unwrap_used)] // this is test code, it's ok to unwrap
2	use tempfile::TempDir;

slice-deque 0.3.0/benches/insert.rs

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

slice-deque 0.3.0/benches/pop_back.rs

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

slice-deque 0.3.0/benches/pop_front.rs

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

slice-deque 0.3.0/benches/remove.rs

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

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

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

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

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

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

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

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

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

sparkle-cache 0.14.1/src/lib.rs

52	clippy::implicit_return,
53	clippy::unwrap_used,
54	clippy::multiple_inherent_impl,

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

53	clippy::implicit_return,
54	clippy::unwrap_used,
55	clippy::multiple_inherent_impl,

sqm_parser 1.0.1/src/lib.rs

4	clippy::implicit_return,
5	clippy::result_unwrap_used,
6	clippy::option_unwrap_used,
7	clippy::print_stdout,

std_detect 0.1.5/tests/cpu-detection.rs

2	#![cfg_attr(stdsimd_strict, deny(warnings))]
3	#![allow(clippy::option_unwrap_used, clippy::use_debug, clippy::print_stdout)]

std_detect 0.1.5/tests/macro_trailing_commas.rs

2	#![cfg_attr(stdsimd_strict, deny(warnings))]
3	#![allow(clippy::option_unwrap_used, clippy::use_debug, clippy::print_stdout)]

stdsimd 0.1.2/tests/cpu-detection.rs

4	feature = "cargo-clippy",
5	allow(option_unwrap_used, use_debug, print_stdout)
6	)]

stringmetrics 2.2.2/src/lib.rs

210	clippy::expect_used,
211	clippy::unwrap_used,
212	clippy::implicit_return,

svgplot 2022.0.46/src/circle.rs

18	pub(crate) fn write<W: Write>(&self, id: Option<SvgId>, writer: &mut W) {
19	#![allow(clippy::unwrap_used)]
20	writer

svgplot 2022.0.46/src/color.rs

30	#![allow(clippy::panic)]
31	#![allow(clippy::unwrap_used)]
32	match self {

svgplot 2022.0.46/src/common_attributes.rs

29	pub(crate) fn write<W: Write>(&self, writer: &mut W) {
30	#![allow(clippy::unwrap_used)]
31	if let Some(style) = &self.style {

svgplot 2022.0.46/src/group.rs

39	pub(crate) fn write<W: Write>(&self, id: Option<SvgId>, writer: &mut W) {
40	#![allow(clippy::unwrap_used)]
41	writer.write_all(b"<g").unwrap();

svgplot 2022.0.46/src/id.rs

10	pub(crate) fn write<W: Write>(self, writer: &mut W) {
11	#![allow(clippy::unwrap_used)]
12	writer

svgplot 2022.0.46/src/lib.rs

110	pub fn to_svg_string(&self) -> String {
111	#![allow(clippy::unwrap_used)]
112	let mut buffer = Vec::new();

svgplot 2022.0.46/src/path.rs

64	pub(crate) fn write<W: Write>(&self, id: Option<SvgId>, writer: &mut W) {
65	#![allow(clippy::unwrap_used)]
66	writer.write_all(b"<path").unwrap();
176	pub fn data_string(&self) -> String {
177	#![allow(clippy::unwrap_used)]
178	let mut buffer = Vec::new();
183	pub(crate) fn write<W: Write>(&self, writer: &mut W) {
184	#![allow(clippy::unwrap_used)]
185	for element in &self.elements {

svgplot 2022.0.46/src/rect.rs

43	pub(crate) fn write<W: Write>(&self, id: Option<SvgId>, buffer: &mut W) {
44	#![allow(clippy::unwrap_used)]
45	buffer

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

1	#![allow(clippy::indexing_slicing)]
2	#![allow(clippy::unwrap_used)]
3	#![allow(clippy::panic)]

swarm-bot 0.3.4/src/main.rs

61	clippy::module_name_repetitions,
62	clippy::unwrap_used,
63	clippy::indexing_slicing,

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

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

symbologyl2 0.1.1/src/us/equities/parser.rs

551	mod tests {
552	#![allow(clippy::unwrap_used, clippy::too_many_lines, clippy::similar_names)]
553	use super::*;

tor-basic-utils 0.5.0/src/futures.rs

540	#![allow(clippy::single_char_pattern)]
541	#![allow(clippy::unwrap_used)]
542	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-basic-utils 0.5.0/src/n_key_set.rs

594	#![allow(clippy::single_char_pattern)]
595	#![allow(clippy::unwrap_used)]
596	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-basic-utils 0.5.0/src/test_rng.rs

232	mod test {
233	#![allow(clippy::unwrap_used)]
234	use std::env::VarError;

tor-bytes 0.6.0/src/impls.rs

302	mod tests {
303	#![allow(clippy::unwrap_used)]
304	use crate::{Reader, Writer};

tor-bytes 0.6.0/src/reader.rs

338	mod tests {
339	#![allow(clippy::unwrap_used)]
340	#![allow(clippy::cognitive_complexity)]

tor-cert 0.6.0/src/lib.rs

525	mod test {
526	#![allow(clippy::unwrap_used)]
527	use super::*;

tor-chanmgr 0.8.0/src/builder.rs

226	mod test {
227	#![allow(clippy::unwrap_used)]
228	use super::*;

tor-chanmgr 0.8.0/src/config.rs

43	#![allow(clippy::single_char_pattern)]
44	#![allow(clippy::unwrap_used)]
45	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-chanmgr 0.8.0/src/mgr/state/padding_test.rs

9	#![allow(clippy::single_char_pattern)]
10	#![allow(clippy::unwrap_used)]
11	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-chanmgr 0.8.0/src/mgr/state.rs

535	#![allow(clippy::single_char_pattern)]
536	#![allow(clippy::unwrap_used)]
537	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-chanmgr 0.8.0/src/mgr.rs

520	mod test {
521	#![allow(clippy::unwrap_used)]
522	use super::*;

tor-chanmgr 0.8.0/src/transport/default.rs

137	#![allow(clippy::single_char_pattern)]
138	#![allow(clippy::unwrap_used)]
139	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-chanmgr 0.8.0/src/transport/proxied.rs

414	mod test {
415	#![allow(clippy::unwrap_used)]
416	#[allow(unused_imports)]

tor-checkable 0.4.0/src/signed.rs

39	mod test {
40	#![allow(clippy::unwrap_used)]
41	use super::*;

tor-circmgr 0.7.0/src/build.rs

504	mod test {
505	#![allow(clippy::unwrap_used)]
506	use super::*;

tor-circmgr 0.7.0/src/config.rs

296	mod test {
297	#![allow(clippy::unwrap_used)]
298	use super::*;

tor-circmgr 0.7.0/src/isolation.rs

400	pub(crate) mod test {
401	#![allow(clippy::unwrap_used)]
402	use super::*;

tor-circmgr 0.7.0/src/lib.rs

783	mod test {
784	#![allow(clippy::unwrap_used)]
785	use super::*;

tor-circmgr 0.7.0/src/mgr/streams.rs

118	mod test {
119	#![allow(clippy::unwrap_used)]
120	use super::*;

tor-circmgr 0.7.0/src/path/dirpath.rs

87	#![allow(clippy::single_char_pattern)]
88	#![allow(clippy::unwrap_used)]
89	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-circmgr 0.7.0/src/path/exitpath.rs

293	mod test {
294	#![allow(clippy::unwrap_used)]
295	#![allow(clippy::clone_on_copy)]

tor-circmgr 0.7.0/src/path.rs

215	fn assert_same_path_when_owned(path: &TorPath<'_>) {
216	#![allow(clippy::unwrap_used)]
217	let owned: OwnedPath = path.try_into().unwrap();

tor-config 0.7.0/src/cmdline.rs

132	mod test {
133	#![allow(clippy::unwrap_used)]
134	use super::*;

tor-config 0.7.0/src/err.rs

168	mod test {
169	#![allow(clippy::unwrap_used)]
170	use super::*;

tor-config 0.7.0/src/list_builder.rs

746	#![allow(clippy::single_char_pattern)]
747	#![allow(clippy::unwrap_used)]
748	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-config 0.7.0/src/misc.rs

394	#![allow(clippy::single_char_pattern)]
395	#![allow(clippy::unwrap_used)]
396	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-config 0.7.0/src/path.rs

246	mod test {
247	#![allow(clippy::unwrap_used)]
248	use super::*;
341	#![allow(clippy::single_char_pattern)]
342	#![allow(clippy::unwrap_used)]
343	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-config 0.7.0/src/sources.rs

409	#![allow(clippy::single_char_pattern)]
410	#![allow(clippy::unwrap_used)]
411	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-consdiff 0.4.0/src/lib.rs

557	mod test {
558	#![allow(clippy::unwrap_used)]
559	use super::*;

tor-dirclient 0.6.0/src/lib.rs

455	mod test {
456	#![allow(clippy::unwrap_used)]
457	use super::*;

tor-dirclient 0.6.0/src/request.rs

512	mod test {
513	#![allow(clippy::unwrap_used)]
514	use super::*;

tor-dirclient 0.6.0/src/response.rs

178	#![allow(clippy::single_char_pattern)]
179	#![allow(clippy::unwrap_used)]
180	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-dirclient 0.6.0/src/util.rs

24	mod test {
25	#![allow(clippy::unwrap_used)]
26	use super::*;

tor-dirmgr 0.9.0/src/authority.rs

80	mod test {
81	#![allow(clippy::unwrap_used)]
82	use super::*;

tor-dirmgr 0.9.0/src/bridgedesc/bdtest.rs

9	#![allow(clippy::single_char_pattern)]
10	#![allow(clippy::unwrap_used)]
11	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-dirmgr 0.9.0/src/config.rs

326	mod test {
327	#![allow(clippy::unwrap_used)]
328	#![allow(clippy::unnecessary_wraps)]

tor-dirmgr 0.9.0/src/docid.rs

285	mod test {
286	#![allow(clippy::unwrap_used)]
287	use super::*;

tor-dirmgr 0.9.0/src/lib.rs

1116	mod test {
1117	#![allow(clippy::unwrap_used)]
1118	use super::*;

tor-dirmgr 0.9.0/src/shared_ref.rs

96	mod test {
97	#![allow(clippy::unwrap_used)]
98	use super::*;

tor-dirmgr 0.9.0/src/state.rs

1237	mod test {
1238	#![allow(clippy::unwrap_used)]
1239	#![allow(clippy::cognitive_complexity)]

tor-error 0.4.0/src/internal.rs

256	#![allow(clippy::single_char_pattern)]
257	#![allow(clippy::unwrap_used)]
258	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-events 0.4.0/src/lib.rs

287	mod test {
288	#![allow(clippy::unwrap_used)]
289	use crate::{

tor-guardmgr 0.8.0/src/bridge/config.rs

612	#![allow(clippy::single_char_pattern)]
613	#![allow(clippy::unwrap_used)]
614	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-guardmgr 0.8.0/src/config.rs

42	#![allow(clippy::single_char_pattern)]
43	#![allow(clippy::unwrap_used)]
44	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-guardmgr 0.8.0/src/dirstatus.rs

66	mod test {
67	#![allow(clippy::unwrap_used)]
68	use super::*;

tor-guardmgr 0.8.0/src/fallback/set.rs

239	#![allow(clippy::single_char_pattern)]
240	#![allow(clippy::unwrap_used)]
241	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-guardmgr 0.8.0/src/filter.rs

156	mod test {
157	#![allow(clippy::unwrap_used)]
158	use super::*;

tor-guardmgr 0.8.0/src/guard.rs

942	mod test {
943	#![allow(clippy::unwrap_used)]
944	use super::*;

tor-guardmgr 0.8.0/src/lib.rs

1830	mod test {
1831	#![allow(clippy::unwrap_used)]
1832	use super::*;

tor-guardmgr 0.8.0/src/sample.rs

1019	mod test {
1020	#![allow(clippy::unwrap_used)]
1021	use tor_linkspec::{HasRelayIds, RelayIdType};

tor-guardmgr 0.8.0/src/skew.rs

232	mod test {
233	#![allow(clippy::unwrap_used)]
234	use super::*;

tor-guardmgr 0.8.0/src/util.rs

63	mod test {
64	#![allow(clippy::unwrap_used)]
65	use super::*;

tor-linkspec 0.6.0/src/ids/by_id.rs

163	mod test {
164	#![allow(clippy::unwrap_used)]

tor-linkspec 0.6.0/src/ids/set.rs

145	#![allow(clippy::single_char_pattern)]
146	#![allow(clippy::unwrap_used)]
147	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-linkspec 0.6.0/src/ids.rs

354	mod test {
355	#![allow(clippy::unwrap_used)]
356	use hex_literal::hex;

tor-linkspec 0.6.0/src/ls.rs

167	mod test {
168	#![allow(clippy::unwrap_used)]
169	use super::*;

tor-linkspec 0.6.0/src/owned.rs

271	mod test {
272	#![allow(clippy::unwrap_used)]
273	use super::*;

tor-linkspec 0.6.0/src/traits.rs

296	mod test {
297	#![allow(clippy::unwrap_used)]
298	use super::*;

tor-linkspec 0.6.0/src/transport.rs

744	mod test {
745	#![allow(clippy::unwrap_used)]
746	use super::*;

tor-llcrypto 0.4.0/src/pk/keymanip.rs

168	mod tests {
169	#![allow(clippy::unwrap_used)]
170	use super::*;

tor-llcrypto 0.4.0/src/pk.rs

69	mod test {
70	#![allow(clippy::unwrap_used)]
71	#[test]

tor-llcrypto 0.4.0/src/util.rs

80	mod tests {
81	#![allow(clippy::unwrap_used)]
82	// A cert generated by chutney

tor-netdir 0.7.0/src/lib.rs

1214	mod test {
1215	#![allow(clippy::unwrap_used)]
1216	#![allow(clippy::cognitive_complexity)]

tor-netdir 0.7.0/src/testnet.rs

13	#![allow(clippy::missing_panics_doc)]
14	#![allow(clippy::unwrap_used)]

tor-netdoc 0.6.0/src/doc/authcert/build.rs

132	mod test {
133	#![allow(clippy::unwrap_used)]
134	use super::*;

tor-netdoc 0.6.0/src/doc/microdesc/build.rs

149	mod test {
150	#![allow(clippy::unwrap_used)]
151	use super::*;

tor-persist 0.6.0/src/fs/clean.rs

100	mod test {
101	#![allow(clippy::unwrap_used)]
102	use super::*;

tor-persist 0.6.0/src/fs.rs

257	mod test {
258	#![allow(clippy::unwrap_used)]
259	use super::*;

tor-persist 0.6.0/src/testing.rs

176	mod test {
177	#![allow(clippy::unwrap_used)]
178	use super::*;

tor-proto 0.8.0/src/channel/circmap.rs

241	mod test {
242	#![allow(clippy::unwrap_used)]
243	use super::*;

tor-proto 0.8.0/src/channel/codec.rs

65	pub(crate) mod test {
66	#![allow(clippy::unwrap_used)]
67	use futures::io::{AsyncRead, AsyncWrite, Cursor, Result};

tor-proto 0.8.0/src/channel/handshake.rs

620	pub(super) mod test {
621	#![allow(clippy::unwrap_used)]
622	use hex_literal::hex;

tor-proto 0.8.0/src/channel/padding.rs

412	#![allow(clippy::single_char_pattern)]
413	#![allow(clippy::unwrap_used)]
414	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-proto 0.8.0/src/channel/reactor.rs

467	pub(crate) mod test {
468	#![allow(clippy::unwrap_used)]
469	use super::*;

tor-proto 0.8.0/src/channel.rs

701	// reactor code; there are just a few more cases to examine here.
702	#![allow(clippy::unwrap_used)]
703	use super::*;

tor-proto 0.8.0/src/circuit/celltypes.rs

70	mod test {
71	#![allow(clippy::unwrap_used)]
72	use super::*;

tor-proto 0.8.0/src/circuit/halfstream.rs

82	mod test {
83	#![allow(clippy::unwrap_used)]
84	use super::*;

tor-proto 0.8.0/src/circuit/sendme.rs

281	mod test {
282	#![allow(clippy::unwrap_used)]
283	use super::*;

tor-proto 0.8.0/src/circuit/streammap.rs

220	mod test {
221	#![allow(clippy::unwrap_used)]
222	use super::*;

tor-protover 0.4.0/src/lib.rs

465	mod test {
466	#![allow(clippy::unwrap_used)]
467	use super::*;

tor-ptmgr 0.2.0/src/ipc.rs

785	#![allow(clippy::single_char_pattern)]
786	#![allow(clippy::unwrap_used)]
787	//! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

tor-rtcompat 0.8.0/src/async_std.rs

151	mod test {
152	#![allow(clippy::unwrap_used)]
153	use super::*;

tor-rtcompat 0.8.0/src/lib.rs

331	mod test {
332	#![allow(clippy::unwrap_used, clippy::unnecessary_wraps)]
333	use crate::Runtime;

tor-rtcompat 0.8.0/src/tokio.rs

221	mod test {
222	#![allow(clippy::unwrap_used)]
223	use super::*;

tor-rtmock 0.7.0/src/io.rs

184	mod test {
185	#![allow(clippy::unwrap_used)]
186	use super::*;

tor-rtmock 0.7.0/src/net.rs

515	mod test {
516	#![allow(clippy::unwrap_used)]
517	use super::*;

tor-rtmock 0.7.0/src/time.rs

443	mod test {
444	#![allow(clippy::unwrap_used)]
445	use super::*;

tor-socksproto 0.6.0/src/handshake/client.rs

313	#![allow(clippy::single_char_pattern)]
314	#![allow(clippy::unwrap_used)]
315	//! <!-- @@ end test lint list

tor-socksproto 0.6.0/src/handshake/proxy.rs

301	mod test {
302	#![allow(clippy::unwrap_used)]
303	use super::*;

tor-socksproto 0.6.0/src/handshake.rs

93	#![allow(clippy::single_char_pattern)]
94	#![allow(clippy::unwrap_used)]
95	//! <!-- @@ end test lint list

tor-socksproto 0.6.0/src/msg.rs

395	mod test {
396	#![allow(clippy::unwrap_used)]
397	use super::*;

tor-units 0.4.0/src/lib.rs

493	mod tests {
494	#![allow(clippy::unwrap_used)]
495	use float_cmp::assert_approx_eq;

tremor-common 0.13.0-rc.11/src/asy/file.rs

86	mod test {
87	#![allow(clippy::unwrap_used)]
88	use crate::errors::Error;

tremor-common 0.13.0-rc.11/src/file.rs

84	mod test {
85	#![allow(clippy::unwrap_used)]
86	use crate::errors::Error;

tremor-common 0.13.0-rc.11/src/string.rs

40	mod test {
41	#![allow(clippy::unwrap_used)]

tremor-influx 0.13.0-rc.11/src/lib.rs

55	mod tests {
56	#![allow(clippy::unwrap_used)]

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

13	// limitations under the License.
14	#![allow(clippy::unwrap_used)]
15	use super::*;

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

37	mod tests {
38	#![allow(clippy::unwrap_used)]
39	use super::*;

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

404	clippy::non_ascii_literal,
405	clippy::unwrap_used
406	)]

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

632	mod tests {
633	#![allow(clippy::unwrap_used)]
634	use super::*;

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

29	mod test {
30	#![allow(clippy::unwrap_used)]
31	use crate::Value;

twilight-cache-any-backend 0.13.0/src/lib.rs

52	clippy::implicit_return,
53	clippy::unwrap_used,
54	clippy::multiple_inherent_impl,

up-rs 0.13.3/src/tasks/git/update.rs

1	// TODO(gib): Use https://lib.rs/crates/indicatif for progress bars and remove this.
2	#![allow(clippy::print_stdout, clippy::unwrap_used)]
3	use std::{

vp9-parser 0.3.1/src/ivf/mod.rs

152	mod tests {
153	#![allow(clippy::unwrap_used)]
154	#![allow(clippy::panic)]

wave-insight-lib 0.1.3/src/lib.rs

43	clippy::indexing_slicing, // TODO
44	clippy::unwrap_used, // TODO
45	)]

webauthn-rs-core 0.4.9/src/core.rs

2451	) -> Result<(CreationChallengeResponse, RegistrationState), WebauthnError> {
2452	#![allow(clippy::unwrap_used)]

xmp_toolkit 1.0.1/src/tests/mod.rs

18	#![allow(clippy::panic)]
19	#![allow(clippy::unwrap_used)]

151	// these unwraps are safe because the length is definitely 2
152	#[allow(clippy::unwrap_used)]
153	let source = parts.get(0).unwrap();
154	#[allow(clippy::unwrap_used)]
155	let binary = parts.get(1).unwrap();
193	// these unwraps are safe because the length is definitely 2
194	#[allow(clippy::unwrap_used)]
195	let binary = parts.get(0).unwrap();
196	#[allow(clippy::unwrap_used)]
197	let installtime = parts.get(1).unwrap();

21	fn main() -> ! {
22	#[allow(clippy::unwrap_used)]
23	let cp = cortex_m::Peripherals::take().unwrap();
24	#[allow(clippy::unwrap_used)]
25	let dp = pac::Peripherals::take().unwrap();