a_r_c_h_e_r_y 0.4.3/src/shared_pointer/test.rs

202	#[allow(clippy::cyclomatic_complexity)]
203	#[test]

actionable-macros 0.2.0/src/actionable.rs

142	#[allow(clippy::cognitive_complexity)]
143	// The complexity is because of the multiple big quote! macros, but I don't see a way to make

actix-router 0.5.1/src/resource.rs

1227	#[allow(clippy::cognitive_complexity)]
1228	#[test]

actix-router 0.5.1/src/router.rs

148	#[allow(clippy::cognitive_complexity)]
149	#[test]

actori-web 2.0.0/src/info.rs

28	#[allow(clippy::cognitive_complexity)]
29	fn new(req: &RequestHead, cfg: &AppConfig) -> ConnectionInfo {

advantage 0.1.0/src/acontext.rs

262	#[test]
263	#[allow(clippy::cognitive_complexity)]
264	fn acontext_record() {

advantage 0.1.0/src/drivers/abs_normal.rs

434	#[test]
435	#[allow(clippy::cognitive_complexity)]
436	fn abs_decompose() {

aerospike 1.2.0/src/commands/buffer.rs

713	#[allow(clippy::cognitive_complexity)]
714	pub fn set_query(

aerospike 1.2.0/src/key.rs

127	#[test]
128	#[allow(clippy::cognitive_complexity)]
129	fn int_keys() {

alacritty_terminal 0.17.0/src/ansi.rs

1132	#[allow(clippy::cognitive_complexity)]
1133	#[inline]

alexcrichton-cranelift-codegen-meta 0.53.0/src/isa/x86/encodings.rs

2352	#[allow(clippy::cognitive_complexity)]
2353	pub(crate) fn define(

alexcrichton-cranelift-codegen-meta 0.53.0/src/shared/legalize.rs

10	#[allow(clippy::many_single_char_names, clippy::cognitive_complexity)]
11	pub(crate) fn define(insts: &InstructionGroup, imm: &Immediates) -> TransformGroups {

alexcrichton-cranelift-reader 0.53.0/src/lexer.rs

463	/// Return None when the end of the source is encountered.
464	#[allow(clippy::cognitive_complexity)]
465	pub fn next(&mut self) -> Option<Result<LocatedToken<'a>, LocatedError>> {

alloc-compose 0.5.0/src/stats.rs

759	#[rustfmt::skip]
760	#[allow(clippy::cognitive_complexity)]
761	fn filtered_counter() {

alloc-fmt 0.2.0/src/bin/assert.rs

12	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
13	fn main() {

alloc-fmt 0.2.0/src/lib.rs

409	#[allow(unused)]
410	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
411	fn never_called() {

amadeus-derive 0.4.3/src/lib.rs

90	/// Implement on regular named or unit structs.
91	#[allow(clippy::cognitive_complexity)]
92	fn impl_struct(

amadeus-parquet-derive 0.1.1/src/lib.rs

73	/// Implement on regular named or unit structs.
74	#[allow(clippy::cognitive_complexity)]
75	fn impl_struct(

apca 0.26.1/src/client.rs

277	/// Issue a request.
278	#[allow(clippy::cognitive_complexity)]
279	async fn issue_<R>(&self, request: Request<Body>) -> Result<R::Output, RequestError<R::Error>>

apple-crash-report-parser 0.5.0/src/parser.rs

244	#[allow(clippy::cognitive_complexity)]
245	fn from_line_iter<'a, I>(iter: I) -> Result<AppleCrashReport, ParseError>

aptos-types 0.2.7/src/proof/position/position_test.rs

416	#[test]
417	#[allow(clippy::cognitive_complexity)]
418	fn test_position_extended() {

arabic_reshaper 0.4.1/src/algorithm.rs

56	#[allow(clippy::cognitive_complexity)]
57	pub fn reshape(&mut self, text: &str) -> String {

arbitrary-model-tests 0.1.0/src/lib.rs

327	impl<'s> quote::ToTokens for OperationEnum<'s> {
328	#[allow(clippy::cognitive_complexity)]
329	fn to_tokens(&self, tokens: &mut pm2::TokenStream) {

archery 0.4.0/src/shared_pointer/test.rs

192	#[allow(clippy::cyclomatic_complexity)]
193	#[test]

arctk 2.0.7/src/render/shader.rs

31	/// Construct a new instance.
32	#[allow(clippy::too_many_arguments, clippy::cognitive_complexity)]
33	#[inline]

arti-bench 0.8.0/src/main.rs

281	#[allow(clippy::cognitive_complexity)]
282	fn main() -> Result<()> {

asciii 3.10.0/src/bin/cli/app.rs

8	#[allow(clippy::cognitive_complexity)]
9	pub fn with_cli<F> (app_handler:F) where F: Fn(App<'_, '_>) {

asciii 3.10.0/src/document_export/mod.rs

116	#[cfg(feature="document_export")]
117	#[allow(clippy::cognitive_complexity)] // sorry
118	fn project_to_doc(project: &Project, config: &ExportConfig<'_>) -> Result<Option<PathBuf>, Error> {

asteracea_proc-macro-definitions 0.0.2/src/component_declaration.rs

419	impl ComponentDeclaration {
420	#[allow(clippy::cognitive_complexity)]
421	pub fn into_tokens(self) -> Result<TokenStream> {

atree 0.5.2/src/token.rs

1170	#[test]
1171	#[allow(clippy::cognitive_complexity)]
1172	fn replace_node() {

audio-mixer 0.1.2/src/coefficient.rs

148	// ChannelMap would be used as a hash table to check the existence of channels.
149	#[allow(clippy::cognitive_complexity)]
150	fn build_mixing_matrix(

automate-derive 0.4.0/src/attribute/listener.rs

8	#[allow(clippy::cognitive_complexity)]
9	fn infer_event_type(dispatch_type: &str) -> Option<&'static str> {

av1an-core 0.4.0/src/parse.rs

305	#[test]
306	#[allow(clippy::cognitive_complexity)]
307	fn valid_params_works() {

aw-fel 0.5.2/src/soc.rs

618	#[allow(clippy::cyclomatic_complexity)]
619	#[test]

badder_lang 0.1.1/src/parser.rs

1282	#[cfg(test)]
1283	#[allow(clippy::cognitive_complexity)]
1284	mod parser_test {

bashdoc 0.5.2/src/docs.rs

196	/// Nom function to convert a given string in to a `Doc`
197	#[allow(clippy::cyclomatic_complexity)]
198	pub fn parse_doc<'a>(input: &'a str, delims: Delimiters) -> IResult<&'a str, Doc> {

basic-lang 0.7.1/src/lang/parse.rs

533	impl Statement {
534	#[allow(clippy::cognitive_complexity)]
535	fn expect(parse: &mut BasicParser) -> Result<Statement> {

basic-lang 0.7.1/src/mach/runtime.rs

382	#[allow(clippy::cognitive_complexity)]
383	fn execute_loop(&mut self, iterations: usize) -> Result<Event> {

basicaf 0.1.2/src/codegen/quads.rs

76	// giant match statement.
77	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
78	fn emit_step(quad: BFQuad, comment: bool) -> Vec<BFQuad> {

bevy_hecs_macros 0.3.0/src/lib.rs

28	/// other derives like `serde::Deserialize`.
29	#[allow(clippy::cognitive_complexity)]
30	#[proc_macro_derive(Bundle)]

bincode2 2.0.1/src/config.rs

339	#[allow(clippy::cognitive_complexity)] // https://github.com/rust-lang/rust-clippy/issues/3900
340	impl Config {

birli 0.8.0/src/cli.rs

521	// TODO: try struct instead of builder
522	#[allow(clippy::cognitive_complexity)]
523	fn get_matches<I, T>(args: I) -> Result<clap::ArgMatches, BirliError>

birli 0.8.0/src/test_common.rs

422	// TODO: make this less shitty
423	#[allow(clippy::cognitive_complexity)]
424	pub fn compare_ms_with_csv(

blend 0.6.1/src/runtime.rs

117	#[allow(clippy::cognitive_complexity)]
118	fn fmt_instance(

bls12_381 0.7.1/src/hash_to_curve/chain.rs

17	#[allow(clippy::cognitive_complexity)]
18	/// addchain for 1000602388805416848354447456433976039139220704984751971333014534031007912622709466110671907282253916009473568139946
324	#[allow(clippy::cognitive_complexity)]
325	/// addchain for 1001205140483106588246484290269935788605945006208159541241399033561623546780709821462541004956387089373434649096260670658193992783731681621012512651314777238193313314641988297376025498093520728838658813979860931248214124593092835

bls12_381_plus 0.7.0/src/hash_to_curve/chain.rs

17	#[allow(clippy::cognitive_complexity)]
18	/// addchain for 1000602388805416848354447456433976039139220704984751971333014534031007912622709466110671907282253916009473568139946
324	#[allow(clippy::cognitive_complexity)]
325	/// addchain for 1001205140483106588246484290269935788605945006208159541241399033561623546780709821462541004956387089373434649096260670658193992783731681621012512651314777238193313314641988297376025498093520728838658813979860931248214124593092835

bodhi-cli 2.0.1/src/main.rs

107	#[allow(clippy::cognitive_complexity)]
108	#[tokio::main]

bonsaidb-core 0.4.1/src/key.rs

626	#[test]
627	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)] // couldn't figure out how to macro-ize it
628	fn composite_key_tests() {
981	#[test]
982	#[allow(clippy::cognitive_complexity)] // I disagree - @ecton
983	fn primitive_key_encoding_tests() -> anyhow::Result<()> {

boolector 0.4.3/src/btor.rs

56	/// Set an option to a particular value.
57	#[allow(clippy::cognitive_complexity)]
58	pub fn set_opt(&self, opt: BtorOption) {

bpaf_derive 0.3.3/src/field/named_field.rs

126	} else if attr.path.is_ident("bpaf") {
127	#[allow(clippy::cognitive_complexity)]
128	attr.parse_args_with(\|input: ParseStream\| loop {

bumpalo 3.12.0/src/lib.rs

1955	#[test]
1956	#[allow(clippy::cognitive_complexity)]
1957	fn test_realloc() {

bustle 0.5.0/src/lib.rs

279	/// violated during the benchmark.
280	#[allow(clippy::cognitive_complexity)]
281	pub fn run_silently<T: Collection>(&self) -> Measurement

cabocha 0.2.0/src/parser.rs

131	// for macro https://github.com/rust-lang/rust-clippy/issues/3900
132	#[allow(clippy::cognitive_complexity)]
133	#[test]

cachepot 0.1.0-rc.1/src/cache/cache.rs

296

/// Get a suitable `Storage` implementation from configuration.

297

#[allow(clippy::cognitive_complexity)] // TODO simplify!

298

pub fn storage_from_config(config: &Config, pool: &tokio::runtime::Handle) -> Arc<dyn Storage> {

cachepot 0.1.0-rc.1/src/compiler/args.rs

716	#[test]
717	#[allow(clippy::cognitive_complexity)]
718	fn test_arginfo_cmp() {

cachepot 0.1.0-rc.1/src/compiler/rust.rs

1807	impl pkg::InputsPackager for RustInputsPackager {
1808	#[allow(clippy::cognitive_complexity)] // TODO simplify this method.
1809	fn write_inputs(self: Box<Self>, wtr: &mut dyn io::Write) -> Result<dist::PathTransformer> {
2428	#[test]
2429	#[allow(clippy::cognitive_complexity)]
2430	fn test_parse_arguments_simple() {

capsule 0.1.5/src/dpdk/port.rs

499	/// Creates the `Port`.
500	#[allow(clippy::cognitive_complexity)]
501	pub(crate) fn finish(

capsule 0.1.5/src/runtime/core_map.rs

215	#[allow(clippy::cognitive_complexity)]
216	pub(crate) fn finish(&'a mut self) -> Result<CoreMap> {

capsule 0.1.5/src/runtime/mod.rs

79	/// Builds a runtime from config settings.
80	#[allow(clippy::cognitive_complexity)]
81	pub fn build(config: RuntimeConfig) -> Result<Self> {
562	/// Shuts down all the cores to stop task execution.
563	#[allow(clippy::cognitive_complexity)]
564	fn shutdown_cores(&mut self) {

cargo-cache 0.8.3/src/main.rs

106	// the default main function
107	#[allow(clippy::cognitive_complexity)]
108	#[cfg(not(feature = "ci-autoclean"))]

cargo_crates-io_docs-rs_test 0.5.0/src/lib.rs

47	/// Converts value returned by NNG method into `error::Error`.
48	#[allow(clippy::cyclomatic_complexity)]
49	pub fn from_i32(value: i32) -> Option<nng_errno_enum> {

cargo-deny 0.13.7/src/cargo-deny/list.rs

137	#[allow(clippy::cognitive_complexity)]
138	pub fn cmd(

cargo-wix 0.3.4/src/create.rs

397	/// Creates, or builds, an installer within a built context.
398	#[allow(clippy::cognitive_complexity)]
399	pub fn run(self) -> Result<()> {

cargo-wix 0.3.4/src/print/wxs.rs

338	impl Execution {
339	#[allow(clippy::cognitive_complexity)]
340	/// Prints a WiX Source (wxs) file based on the built context.

casper-execution-engine 2.0.1/src/core/runtime/utils.rs

73	/// re-serialized `CLValue`.
74	#[allow(clippy::cognitive_complexity)]
75	fn rewrite_urefs(cl_value: CLValue, mut func: impl FnMut(&mut URef)) -> Result<CLValue, Error> {

casper-execution-engine 2.0.1/src/shared/transform.rs

622	#[test]
623	#[allow(clippy::cognitive_complexity)]
624	fn wrapping_addition_should_succeed() {

casper-types 1.5.0/src/cl_type.rs

614	#[test]
615	#[allow(clippy::cognitive_complexity)]
616	fn small_array_of_u8_should_work() {

casperlabs-contract-ffi 0.22.0/src/value/cl_type.rs

172	#[allow(clippy::cognitive_complexity)]
173	impl FromBytes for CLType {
551	#[test]
552	#[allow(clippy::cognitive_complexity)]
553	fn small_array_of_cl_type_should_work() {

casperlabs-engine-core 0.7.1/src/runtime/mod.rs

140	#[allow(clippy::cognitive_complexity)]
141	fn extract_urefs(cl_value: &CLValue) -> Result<Vec<URef>, Error> {

casperlabs-engine-shared 0.7.1/src/transform.rs

511	#[test]
512	#[allow(clippy::cognitive_complexity)]
513	fn wrapping_addition_should_succeed() {

casperlabs-types 0.6.1/src/cl_type.rs

183	#[allow(clippy::cognitive_complexity)]
184	impl FromBytes for CLType {
562	#[test]
563	#[allow(clippy::cognitive_complexity)]
564	fn small_array_of_cl_type_should_work() {

cddl 0.9.1/src/ast/mod.rs

1296	#[allow(clippy::cognitive_complexity)]
1297	impl<'a> fmt::Display for Type2<'a> {

cdx 0.1.21/src/comp.rs

1958	#[test]
1959	#[allow(clippy::cognitive_complexity)]
1960	fn num_cmp() {

cdx 0.1.21/src/text.rs

850	#[test]
851	#[allow(clippy::cognitive_complexity)]
852	fn uwild() {

celery 0.4.0-rcn.11/src/app/mod.rs

543	#[allow(clippy::cognitive_complexity)]
544	async fn _consume_from(self: Arc<Self>, queues: &[&str]) -> Result<(), CeleryError> {

celeste 2.0.1/src/binel/parser.rs

52	/// ```
53	#[allow(clippy::cognitive_complexity)]
54	pub fn take_elemattr<'a>(buf: &'a [u8], lookup: &[String]) -> IResult<&'a [u8], BinElAttr> {

cfg-expr 0.14.0/src/expr.rs

94	impl TargetMatcher for target_lexicon::Triple {
95	#[allow(clippy::cognitive_complexity)]
96	#[allow(clippy::match_same_arms)]

cfg-expr 0.14.0/tests/parser.rs

89	#[test]
90	#[allow(clippy::cognitive_complexity)]
91	fn handles_single_predicate() {

chargrid_graphical_gfx 0.1.0/src/input.rs

22	#[allow(clippy::cognitive_complexity)]
23	fn convert_keycode_keyboard_input(code: VirtualKeyCode, shift: bool) -> Option<KeyboardInput> {

chargrid_web 0.3.1/src/input.rs

9	#[allow(clippy::cognitive_complexity)]
10	fn keyboard_input_from_js_event_key_press(key_code: u8, shift: bool) -> Option<KeyboardInput> {

chargrid_wgpu 0.2.4/src/input.rs

23	#[allow(clippy::cognitive_complexity)]
24	fn convert_keycode_keyboard_input(code: VirtualKeyCode, shift: bool) -> Option<KeyboardInput> {

checkerboard 0.1.0/src/rufli.rs

747	/// Label each corner with their correct x/y index within the grid.
748	#[allow(clippy::cognitive_complexity)]
749	fn label_quad_group(

checksec 0.0.9/src/main.rs

158	}
159	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
160	fn main() {

chrono-wasi 0.4.11/src/naive/time.rs

523	/// ~~~~
524	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
525	pub fn overflowing_add_signed(&self, mut rhs: OldDuration) -> (NaiveTime, i64) {

chrono-wasi07 0.4.10/src/naive/time.rs

523	/// ~~~~
524	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
525	pub fn overflowing_add_signed(&self, mut rhs: OldDuration) -> (NaiveTime, i64) {

cita-evm 0.1.6/src/interpreter.rs

193	#[allow(clippy::cognitive_complexity)]
194	pub fn run(&mut self) -> Result<InterpreterResult, err::Error> {

cita-vm 0.3.4/src/evm/interpreter.rs

202	#[allow(clippy::cognitive_complexity)]
203	pub fn run(&mut self) -> Result<InterpreterResult, err::Error> {

ckb-sentry-core 0.21.0/src/scope/real.rs

224	/// Applies the contained scoped data to fill an event.
225	#[allow(clippy::cognitive_complexity)]
226	pub fn apply_to_event(&self, mut event: Event<'static>) -> Option<Event<'static>> {

ckb-tx-pool 0.107.0/src/component/tests/proposed.rs

220	#[test]
221	#[allow(clippy::cognitive_complexity)]
222	fn test_add_no_roots() {

ckb-tx-pool 0.107.0/src/service.rs

790	#[allow(clippy::cognitive_complexity)]
791	async fn process(mut service: TxPoolService, message: Message) {

ckb-vm 0.24.0-alpha/src/instructions/rvc.rs

92	#[allow(clippy::cognitive_complexity)]
93	pub fn factory<R: Register>(instruction_bits: u32, version: u32) -> Option<Instruction> {

clap 4.1.4/src/parser/parser.rs

49	// The actual parsing function
50	#[allow(clippy::cognitive_complexity)]
51	pub(crate) fn get_matches_with(

clap-v3 3.0.0-beta.1/src/build/app/mod.rs

1911	impl<'a> From<&'a Yaml> for App<'a> {
1912	#[allow(clippy::cognitive_complexity)]
1913	fn from(mut yaml: &'a Yaml) -> Self {

clap-v3 3.0.0-beta.1/src/build/app/settings.rs

981	#[allow(clippy::cognitive_complexity)]
982	#[test]

clap-v3 3.0.0-beta.1/src/build/arg/mod.rs

147	#[cfg(feature = "yaml")]
148	#[allow(clippy::cognitive_complexity)]
149	pub fn from_yaml(y: &yaml_rust::yaml::Hash) -> Arg {

clap-v3 3.0.0-beta.1/src/build/usage_parser.rs

258	#[allow(clippy::cognitive_complexity)]
259	#[test]

clap-v3 3.0.0-beta.1/src/parse/parser.rs

416	// The actual parsing function
417	#[allow(clippy::cognitive_complexity)]
418	pub fn get_matches_with(&mut self, matcher: &mut ArgMatcher, it: &mut Input) -> ClapResult<()> {
1456	#[allow(clippy::cognitive_complexity)]
1457	pub(crate) fn add_defaults(&mut self, matcher: &mut ArgMatcher) -> ClapResult<()> {

clap2 4.0.32/src/parser/parser.rs

49	// The actual parsing function
50	#[allow(clippy::cognitive_complexity)]
51	pub(crate) fn get_matches_with(

clickhouse-rs 1.0.0-alpha.1/src/types/column/factory.rs

52	impl dyn ColumnData {
53	#[allow(clippy::cognitive_complexity)]
54	pub(crate) fn load_data<W: ColumnWrapper, T: ReadEx>(

clickhouse-srv 0.3.1/src/types/column/factory.rs

56	impl dyn ColumnData {
57	#[allow(clippy::cognitive_complexity)]
58	pub(crate) fn load_data<W: ColumnWrapper, T: ReadEx>(

concread 0.4.1/src/arcache/mod.rs

1392	#[allow(clippy::cognitive_complexity)]
1393	fn evict<'a, S>(

const_sort_rs 0.3.3/src/lib.rs

84	clippy::doc_markdown,
85	clippy::cognitive_complexity,
86	clippy::cast_possible_truncation

const_sort_rs 0.3.3/src/test.rs

144	#[cfg_attr(miri, ignore)] // Miri is too slow
145	#[allow(clippy::cognitive_complexity)]
146	fn select_nth_unstable() {

constellation-rs 0.2.0-alpha.2/src/channel/mod.rs

220	// }
221	#[allow(clippy::cognitive_complexity)]
222	notifier.wait(\|_events, data\| {

cpp_macros 0.5.7/src/lib.rs

180	#[proc_macro_derive(__cpp_internal_closure)]
181	#[allow(clippy::cognitive_complexity)]
182	pub fn expand_internal(input: proc_macro::TokenStream) -> proc_macro::TokenStream {

cranelift-reader 0.92.0/src/lexer.rs

462	/// Return None when the end of the source is encountered.
463	#[allow(clippy::cognitive_complexity)]
464	pub fn next(&mut self) -> Option<Result<LocatedToken<'a>, LocatedError>> {

ctest 0.2.22/src/lib.rs

1041	#[allow(clippy::cognitive_complexity)]
1042	fn default_cfg(target: &str) -> Vec<(String, Option<String>)> {

ctest2 0.4.5/src/lib.rs

1045	#[allow(clippy::cognitive_complexity)]
1046	fn default_cfg(target: &str) -> Vec<(String, Option<String>)> {

curb 0.1.6/src/main.rs

47	#[allow(clippy::cyclomatic_complexity)]
48	fn main() {

cursive 0.20.0/src/backends/blt.rs

390	#[allow(clippy::cognitive_complexity)]
391	fn blt_keycode_to_char_impl(kc: KeyCode, shift: bool) -> char {

dactyl 0.4.7/src/traits/btou.rs

165	#[cfg(target_endian = "little")]
166	#[allow(clippy::cognitive_complexity)] // Manual indexing wins.
167	#[must_use]
233	#[cfg(target_endian = "little")]
234	#[allow(clippy::cognitive_complexity)] // Manual indexing wins.
235	#[allow(clippy::too_many_lines)] // Agreed! These numbers are fucking huge!

data-encoding 2.3.3/src/lib.rs

1292	/// [`encode_len`]: struct.Encoding.html#method.encode_len
1293	#[allow(clippy::cognitive_complexity)]
1294	pub fn encode_mut(&self, input: &[u8], output: &mut [u8]) {
1409	/// [`written`]: struct.DecodePartial.html#structfield.written
1410	#[allow(clippy::cognitive_complexity)]
1411	pub fn decode_mut(&self, input: &[u8], output: &mut [u8]) -> Result<usize, DecodePartial> {

databend-thrift 0.17.0/src/protocol/compact.rs

1553	#[allow(clippy::cognitive_complexity)]
1554	#[test]
1716	#[allow(clippy::cognitive_complexity)]
1717	#[test]
1890	#[allow(clippy::cognitive_complexity)]
1891	#[test]
2064	#[allow(clippy::cognitive_complexity)]
2065	#[test]
2236	#[allow(clippy::cognitive_complexity)]
2237	#[test]

dbs-virtio-devices 0.1.1/src/vsock/packet.rs

509	#[test]
510	#[allow(clippy::cognitive_complexity)]
511	fn test_tx_packet_assembly() {
657	#[test]
658	#[allow(clippy::cognitive_complexity)]
659	fn test_packet_hdr_accessors() {

delta_derive 0.1.0/src/lib.rs

385	#[allow(clippy::cognitive_complexity)]
386	fn generate_delta_body(

derivative 2.2.0/src/attr.rs

261	/// Parse the `derivative` attributes on a type.
262	#[allow(clippy::cognitive_complexity)] // mostly macros
263	pub fn from_ast(
446	/// Parse the `derivative` attributes on a type.
447	#[allow(clippy::cognitive_complexity)] // mostly macros
448	pub fn from_ast(

derive_more 0.99.17/src/add_like.rs

73	#[allow(clippy::cognitive_complexity)]
74	fn enum_content(

derive_more 0.99.17/src/try_into.rs

11

/// Provides the hook to expand `#[derive(TryInto)]` into an implementation of `TryInto`

12

#[allow(clippy::cognitive_complexity)]

13

pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStream> {

deterministic-pgp-keys 0.3.0/src/pgp/crypto/sym.rs

439	/// resynchronization after encrypting those BS+2 octets.
440	#[allow(clippy::cognitive_complexity)] // FIXME
441	pub fn encrypt_with_iv<'a>(

dex 0.5.0/src/encoded_value.rs

321	#[allow(clippy::cognitive_complexity)]
322	fn try_from_ctx(source: &'a [u8], dex: &super::Dex<S>) -> Result<(Self, Self::Size)> {

dez80 3.0.0/src/instruction.rs

430	/// Decodes a single instruction (opcode and operands).
431	#[allow(clippy::cognitive_complexity)]
432	#[rustfmt::skip]

dfw 1.2.1/src/bin/dfw.rs

180	#[allow(clippy::cognitive_complexity)]
181	#[cfg(unix)]

dfw 1.2.1/src/iptables/process.rs

616	impl Process<Iptables> for WiderWorldToContainerRule {
617	#[allow(clippy::cognitive_complexity)]
618	fn process(&self, ctx: &ProcessContext<Iptables>) -> Result<Option<Vec<IptablesRule>>> {

dhall 0.12.0/src/builtins.rs

310	#[allow(clippy::cognitive_complexity)]
311	fn apply_builtin<'cx>(

diem-types 0.0.3/src/proof/position/position_test.rs

416	#[test]
417	#[allow(clippy::cognitive_complexity)]
418	fn test_position_extended() {

directx_math 0.2.2/src/collision.rs

5214	/// <https://docs.microsoft.com/en-us/windows/win32/api/directxcollision/nf-directxcollision-intersects~r1>
5215	#[allow(clippy::cognitive_complexity)]
5216	#[inline]

divina_config 0.1.0/src/lib.rs

214	#[allow(clippy::cognitive_complexity)]
215	lua.context(\|ctx\| {

divvunspell 1.0.0-beta.1/src/tokenizer/word.rs

188	#[inline]
189	#[allow(clippy::cognitive_complexity)]
190	fn next(&mut self) -> Option<&'a str> {
431	#[inline]
432	#[allow(clippy::cognitive_complexity)]
433	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
434	fn next_back(&mut self) -> Option<&'a str> {

dlt-core 0.14.3/src/fibex.rs

672	impl<B: BufRead> Reader<B> {
673	#[allow(clippy::cognitive_complexity)]
674	pub fn read_event(&mut self) -> Result<Event, Error> {

dmd_core 0.6.3/src/cpu.rs

864	#[allow(clippy::cyclomatic_complexity)]
865	fn dispatch(&mut self, bus: &mut Bus) -> Result<i32, CpuError> {

dockertest 0.3.1/src/dockertest.rs

98	// NOTE(clippy): tracing generates cognitive complexity due to macro expansion.
99	#[allow(clippy::cognitive_complexity)]
100	pub fn run<T, Fut>(self, test: T)

domain 0.7.1/src/resolv/stub/conf.rs

511	impl fmt::Display for ResolvConf {
512	#[allow(clippy::cognitive_complexity)]
513	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

domain-resolv 0.5.1/src/stub/conf.rs

526	impl fmt::Display for ResolvConf {
527	#[allow(clippy::cognitive_complexity)]
528	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

doryen-extra 0.2.1/src/color.rs

1318	#[allow(clippy::enum_glob_use)]
1319	#[allow(clippy::cognitive_complexity)]
1320	fn by_name_and_level() {

dqcsim 0.4.1/src/core/common/log/proxy.rs

59	#[allow(clippy::cognitive_complexity)]
60	#[test]

dqcsim 0.4.1/src/core/common/types/matrix.rs

542	#[test]
543	#[allow(clippy::cognitive_complexity)]
544	fn basis_approx_eq() {

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

131	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
132	pub fn proc_macro(input: TokenStream) -> TokenStream {

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

195	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
196	pub fn proc_macro(input: TokenStream) -> TokenStream {

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

169	impl Variant {
170	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
171	fn generate(&self) -> TokenStream2 {

drone-cortex-m-macros 0.11.1/src/vtable.rs

150	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
151	pub fn proc_macro(input: TokenStream) -> TokenStream {

drone-stm32-macros 0.8.3/src/vtable.rs

84	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
85	pub fn proc_macro(input: TokenStream) -> TokenStream {

druid 0.8.2/src/tests/mod.rs

113	#[allow(clippy::cognitive_complexity)]
114	Harness::create_simple((), widget, \|harness\| {

druid 0.8.2/src/text/backspace.rs

21	#[allow(clippy::cognitive_complexity)]
22	fn backspace_offset(text: &impl EditableText, start: usize) -> usize {

druid 0.8.2/src/widget/flex.rs

1198	#[test]
1199	#[allow(clippy::cognitive_complexity)]
1200	fn test_main_axis_alignment_spacing() {

druid-shell 0.8.0/src/backend/mac/dialog.rs

55	#[allow(clippy::cognitive_complexity)]
56	pub(crate) unsafe fn build_panel(ty: FileDialogType, mut options: FileDialogOptions) -> id {

druid-shell 0.8.0/src/backend/windows/window.rs

708	#[allow(clippy::cognitive_complexity)]
709	fn window_proc(

dtparse 1.3.0/src/lib.rs

734	#[allow(clippy::cognitive_complexity)] // Imitating Python API is priority
735	fn parse_with_tokens(

dubp-wot 0.11.1/src/lib.rs

83	/// the implementation test.
84	#[allow(clippy::cognitive_complexity)]
85	pub fn generic_wot_test<W>()

duckdb 0.6.1/src/types/mod.rs

281	#[test]
282	#[allow(clippy::cognitive_complexity)]
283	#[ignore = "duckdb doesn't support this"]

durs-wot 0.9.0/lib.rs

60	/// the implementation test.
61	#[allow(clippy::cognitive_complexity)]
62	pub fn generic_wot_test<W>()

duvet 0.2.0/src/report/lcov.rs

63	#[allow(clippy::cognitive_complexity)]
64	pub fn report_source<Output: Write>(

dxf 0.5.0/src/object.rs

692	}
693	#[allow(clippy::cognitive_complexity)]
694	fn apply_custom_reader_material<I>(

dxf 0.5.0/src/table_cell_style.rs

40	impl TableCellStyle {
41	#[allow(clippy::cognitive_complexity)]
42	pub(crate) fn read<I>(iter: &mut CodePairPutBack<I>) -> DxfResult<Option<TableCellStyle>>

ecpdap 0.2.0/src/main.rs

14	#[allow(clippy::cognitive_complexity)]
15	fn main() -> anyhow::Result<()> {

ekvsb 0.0.13/src/main.rs

719	#[allow(clippy::cyclomatic_complexity)]
720	fn make_rocksdb_options(opt: &RocksDbOpt) -> Result<rocksdb::Options> {

electrs-rocksdb 0.15.1-rc1/tests/test_iterator.rs

26	#[test]
27	#[allow(clippy::cognitive_complexity)]
28	fn test_iterator() {

ellidri-tokens 0.1.0/src/mode.rs

298	#[allow(clippy::cognitive_complexity)]
299	#[cfg(test)]

encoding_rs 0.8.31/src/mem.rs

697	/// no RTL characters.
698	#[cfg_attr(feature = "cargo-clippy", allow(collapsible_if, cyclomatic_complexity))]
699	#[inline]

encoding_rs 0.8.31/src/utf_8.rs

231	#[cfg_attr(feature = "cargo-clippy", allow(never_loop, cyclomatic_complexity))]
232	pub fn convert_utf8_to_utf16_up_to_invalid(src: &[u8], dst: &mut [u16]) -> (usize, usize) {

endless-web 2.0.0/src/info.rs

28	#[allow(clippy::cognitive_complexity)]
29	fn new(req: &RequestHead, cfg: &AppConfig) -> ConnectionInfo {

enso-shapely-macros 0.2.1/src/derive_iterator.rs

323	/// into a final derivation output.
324	#[allow(clippy::cognitive_complexity)]
325	pub fn assemble_output(&self, parts:OutputParts) -> TokenStream {

eternal 0.3.2/src/web/info.rs

28	#[allow(clippy::cognitive_complexity)]
29	fn new(req: &RequestHead, cfg: &AppConfig) -> ConnectionInfo {

eth2_ssz_types 0.2.1/src/bitfield.rs

842	#[cfg(test)]
843	#[allow(clippy::cognitive_complexity)]
844	mod bitlist {

ethcontract 0.23.1/src/int.rs

1304	#[test]
1305	#[allow(clippy::cognitive_complexity)]
1306	fn std_num_conversion() {

ethers-core 1.0.2/src/types/i256.rs

1368	#[test]
1369	#[allow(clippy::cognitive_complexity)]
1370	fn std_num_conversion() {

exonum 1.0.0/src/runtime/error/error_match.rs

198	#[test]
199	#[allow(clippy::cognitive_complexity)] // More test code is fine
200	fn execution_error_matching() {

exonum-explorer 1.0.0/tests/explorer.rs

36	#[test]
37	#[allow(clippy::cognitive_complexity)]
38	fn test_explorer_basics() {

exonum-merkledb 1.0.0/src/indexes/sparse_list.rs

517	#[test]
518	#[allow(clippy::cognitive_complexity)]
519	fn test_list_index_methods() {

exonum-testkit 1.0.0/src/checkpoint_db.rs

228	#[test]
229	#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
230	fn interleaved_rollbacks() {

expanse 0.3.4/src/algo.rs

116	#[allow(clippy::cognitive_complexity)]
117	fn compute_internal(

f1-api 0.2.0/src/nineteen/status.rs

235	#[test]
236	#[allow(clippy::cognitive_complexity)]
237	fn decode_statuses_with_success() {

fancy-regex 0.11.0/src/vm.rs

424	/// Run the program with options.
425	#[allow(clippy::cognitive_complexity)]
426	pub(crate) fn run(

fawkes-crypto-powersoftau 0.2.0/src/batched_accumulator.rs

275

    /// Verifies a transformation of the `Accumulator` with the `PublicKey`, given a 64-byte transcript `digest`.

276

    #[allow(clippy::too_many_arguments, clippy::cognitive_complexity)]

277

    pub fn verify_transformation(

fb_failure_ext 0.1.3/src/macros.rs

163	#[allow(clippy::cognitive_complexity)]
164	#[test]

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

407	#[allow(clippy::cognitive_complexity)]
408	#[allow(clippy::too_many_lines)]

feroxfuzz 1.0.0-rc.8/src/std_ext/ops.rs

358	#[test]
359	#[allow(clippy::cognitive_complexity)]
360	#[allow(clippy::too_many_lines)]

ffp 1.3.0/src/main.rs

8	#[allow(clippy::cognitive_complexity)]
9	fn main() -> ffp::Result<()> {

fif 0.6.0/src/main.rs

30	#[doc(hidden)]
31	#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
32	fn main() {

filecoin-phase2 1.0.1/src/main.rs

1098	#[allow(clippy::cognitive_complexity)]
1099	fn main() {

fireplace_lib 3.0.2/src/handlers/workspaces/mod.rs

729	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
730	fn keyboard_key(&mut self, view: Option<&View>, time: u32, modifiers: Modifiers, key: Key,

fireplace_lib 3.0.2/src/handlers/workspaces/modes/bsp/mod.rs

308	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
309	fn keyboard_key(&mut self, view: Option<&View>, _time: u32, modifiers: Modifiers, key: Key,

fit 0.5.0/src/lib.rs

163	#[allow(clippy::cognitive_complexity)]
164	fn read_next_field<R>(

fit_no_io 0.1.0/src/lib.rs

450	#[allow(clippy::cognitive_complexity)]
451	pub fn read_next_field(

fleetfs 0.2.0/src/storage/message_handlers/transaction_coordinator.rs

583	#[allow(clippy::too_many_arguments)]
584	#[allow(clippy::cognitive_complexity)]
585	async fn rename_transaction_lock_context<'a>(

fm-index 0.1.2/src/sais.rs

134	#[allow(clippy::cognitive_complexity)]
135	fn sais_sub<T, C, K>(text: K, sa: &mut [u64], converter: &C)

frugalos 1.2.0/src/main.rs

36	renamed_and_removed_lints,
37	clippy::cyclomatic_complexity,
38	clippy::cognitive_complexity
39	)]

frugalos_mds 1.2.0/src/node/node.rs

343	#[allow(clippy::cognitive_complexity)]
344	fn handle_request(&mut self, request: Request) {

gaea 0.3.1/src/event.rs

554	impl fmt::Debug for Ready {
555	#[allow(clippy::cognitive_complexity)]
556	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

gemachain-ledger 1.8.0/src/blockstore/blockstore_purge.rs

586	#[test]
587	#[allow(clippy::cognitive_complexity)]
588	fn test_purge_transaction_status() {
859	#[test]
860	#[allow(clippy::cognitive_complexity)]
861	fn test_purge_transaction_status_exact() {

gemachain-ledger 1.8.0/src/blockstore.rs

4974	#[test]
4975	#[allow(clippy::cognitive_complexity)]
4976	pub fn test_forward_chaining_is_connected() {
6411	#[test]
6412	#[allow(clippy::cognitive_complexity)]
6413	fn test_transaction_status_index() {

gemachain-runtime 1.8.2/src/bank.rs

3082	#[allow(clippy::cognitive_complexity)]
3083	fn update_error_counters(error_counters: &ErrorCounters) {
6758	#[test]
6759	#[allow(clippy::cognitive_complexity)]
6760	fn test_rent_complex() {
6995	#[test]
6996	#[allow(clippy::cognitive_complexity)]
6997	fn test_rent_eager_across_epoch_without_gap_under_multi_epoch_cycle() {

genie-rec 0.1.1/src/ai.rs

530	impl InformationAI {
531	#[allow(clippy::cognitive_complexity)]
532	pub fn read_from(mut input: impl Read, version: f32) -> Result<Self> {

genie-rec 0.1.1/src/player.rs

48	#[allow(clippy::cognitive_complexity)]
49	pub fn read_from(mut input: impl Read, version: f32, num_players: u8) -> Result<Self> {

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

387	#[allow(clippy::cognitive_complexity)]
388	fn read_event_default(event: Event, key_bindings: &KeyBindings) -> Event {

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

264	#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
265	fn rebuild(&mut self, view_data: &ViewData) {

git-smash 0.1.0/src/config.rs

63	impl Config {
64	#[allow(clippy::cognitive_complexity)]
65	pub fn load(args: &Args) -> Result<Self> {

gitlab 0.1508.0/src/test/types.rs

1079	#[allow(clippy::cognitive_complexity)]
1080	#[test]
1168	#[allow(clippy::cognitive_complexity)]
1169	#[test]

gitui 0.22.1/src/components/branchlist.rs

213	//TODO: cleanup
214	#[allow(clippy::cognitive_complexity)]
215	fn event(&mut self, ev: &Event) -> Result<EventState> {

gitui 0.22.1/src/components/diff.rs

724	#[allow(clippy::cognitive_complexity)]
725	fn event(&mut self, ev: &Event) -> Result<EventState> {

gitui 0.22.1/src/tabs/status.rs

823	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
824	fn event(

glisp 0.0.4/src/compiler/tokenizer.rs

169	#[allow(clippy::cyclomatic_complexity)]
170	pub fn tokenize<'a>(

graphannis-core 2.4.2/src/graph/mod.rs

359	#[allow(clippy::cognitive_complexity)]
360	fn apply_update_in_memory<F>(&mut self, u: &mut GraphUpdate, progress_callback: F) -> Result<()>

grass_compiler 0.12.2/src/evaluate/visitor.rs

735	/// <https://sass-lang.com/documentation/at-rules/import#load-paths>
736	#[allow(clippy::cognitive_complexity)]
737	fn find_import(&self, path: &Path) -> Option<PathBuf> {

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

340	/// sequences can't be merged, returns `None`.
341	#[allow(clippy::cognitive_complexity)]
342	fn merge_final_combinators(

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

67	#[allow(clippy::too_many_lines)]
68	#[allow(clippy::cognitive_complexity)]
69	pub fn main() -> Result<()> {

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

136	#[allow(clippy::cognitive_complexity)]
137	#[allow(clippy::too_many_lines)]

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

18	#[allow(clippy::too_many_lines)]
19	#[allow(clippy::cognitive_complexity)]
20	pub fn parse_obu<'a>(

gstreamer 0.19.7/src/buffer.rs

1345	#[test]
1346	#[allow(clippy::cognitive_complexity)]
1347	fn test_memories() {

gstreamer 0.19.7/src/buffer_cursor.rs

431	#[test]
432	#[allow(clippy::cognitive_complexity)]
433	fn test_buffer_cursor() {
523	#[test]
524	#[allow(clippy::cognitive_complexity)]
525	fn test_buffer_cursor_ref() {

gstreamer 0.19.7/src/date_time.rs

538	#[allow(clippy::cognitive_complexity)]
539	#[test]

gstreamer 0.19.7/src/tags.rs

1192	#[test]
1193	#[allow(clippy::cognitive_complexity)]
1194	fn test_generic() {

gstreamer 0.19.7/src/toc_serde.rs

277	#[allow(clippy::cognitive_complexity)]
278	#[test]
406	#[allow(clippy::cognitive_complexity)]
407	#[test]

gstreamer 0.19.7/src/value_serde.rs

521	#[allow(clippy::cognitive_complexity)]
522	#[test]

half 2.2.1/src/bfloat.rs

1319	#[allow(
1320	clippy::cognitive_complexity,
1321	clippy::float_cmp,

half 2.2.1/src/binary16.rs

1334	#[allow(
1335	clippy::cognitive_complexity,
1336	clippy::float_cmp,

handy 0.1.4/src/lib.rs

704	#[cfg(test)]
705	#[allow(clippy::cognitive_complexity)]
706	fn assert_valid(&self) {

handy 0.1.4/src/typed.rs

947	// need to actually invoke the clone impl, and I don't feel like splitting this.
948	#[allow(clippy::clone_on_copy, clippy::cognitive_complexity)]
949	fn test_trait_impls() {

hbbft 0.1.1/tests/net_dynamic_hb.rs

89	// TODO: Add an observer node to the test network.
90	#[allow(clippy::needless_pass_by_value, clippy::cyclomatic_complexity)]
91	fn do_drop_and_re_add(cfg: TestConfig) {

hbbft 0.1.1/tests/net_util.rs

137	#[test]
138	#[allow(clippy::cyclomatic_complexity)]
139	fn network_from_u32_is_correct() {

hebo_codec 0.2.3/src/header.rs

134	#[allow(clippy::too_many_lines)]
135	#[allow(clippy::cognitive_complexity)]
136	fn try_from(v: u8) -> Result<Self, Self::Error> {

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

343	#[allow(clippy::cognitive_complexity)]
344	fn _mark_ready(

hime_redist 4.2.0/src/parsers/rnglr.rs

1171	/// The absence of value represents the unavailability of the required context.
1172	#[allow(clippy::cognitive_complexity)]
1173	fn get_context_priority(

hko 1.7.2/src/weather/name/string.rs

10	impl EnumNameDesc for Name {
11	#[allow(clippy::cognitive_complexity)]
12	fn name(&self, lang: Lang) -> String {

homebins 0.2.1/src/main.rs

247	#[allow(clippy::cognitive_complexity)]
248	fn process_args(matches: &clap::ArgMatches) -> anyhow::Result<()> {

httproxide-h3 0.0.0/src/qpack/prefix_string/decode.rs

380	#[test]
381	#[allow(clippy::cognitive_complexity)]
382	fn test_decode_single_value() {

httproxide-h3 0.0.0/src/qpack/prefix_string/encode.rs

451	#[test]
452	#[allow(clippy::cognitive_complexity)]
453	fn test_encode_single_value() {

humantime 2.1.0/src/duration.rs

342	#[test]
343	#[allow(clippy::cognitive_complexity)]
344	fn test_units() {

hwt 0.4.2/src/hwt.rs

249	/// beyond that and still gives them to the user.
250	#[allow(clippy::cognitive_complexity)]
251	pub fn nearest<'a>(

hygeia 0.3.2/src/cache/tests.rs

581	#[allow(clippy::cognitive_complexity)]
582	#[test]

ic_bls12_381 0.7.1/src/hash_to_curve/chain.rs

17	#[allow(clippy::cognitive_complexity)]
18	/// addchain for 1000602388805416848354447456433976039139220704984751971333014534031007912622709466110671907282253916009473568139946
324	#[allow(clippy::cognitive_complexity)]
325	/// addchain for 1001205140483106588246484290269935788605945006208159541241399033561623546780709821462541004956387089373434649096260670658193992783731681621012512651314777238193313314641988297376025498093520728838658813979860931248214124593092835

iced_aw 0.3.0/src/core/color.rs

106	#[allow(clippy::cognitive_complexity)]
107	#[test]
223	#[allow(clippy::cognitive_complexity)]
224	#[test]

iced_aw 0.3.0/src/native/number_input.rs

351	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
352	fn on_event(

illumex-sqlparser 0.28.1/src/ast/mod.rs

1534	// split up without extracting structs for each `Statement` variant.
1535	#[allow(clippy::cognitive_complexity)]
1536	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

ilp-node 0.6.0/src/node.rs

241	#[allow(clippy::cognitive_complexity)]
242	fn serve_node(&self) -> impl Future<Item = (), Error = ()> {
465	/// process or on the configured port.
466	#[allow(clippy::cognitive_complexity)]
467	fn serve_prometheus(&self) -> impl Future<Item = (), Error = ()> {

inferno 0.11.14/src/collapse/common.rs

480

/// Based on code in https://github.com/alexcrichton/rustc-demangle/blob/master/src/legacy.rs

481

#[allow(clippy::cognitive_complexity)]

482

pub(crate) fn fix_partially_demangled_rust_symbol(symbol: &str) -> Cow<str> {

inferno 0.11.14/src/flamegraph/mod.rs

404

/// [differential flame graph]: http://www.brendangregg.com/blog/2014-11-09/differential-flame-graphs.html

405

#[allow(clippy::cognitive_complexity)]

406

pub fn from_lines<'a, I, W>(opt: &mut Options<'_>, lines: I, writer: W) -> quick_xml::Result<()>

iop-morpheus-proto 0.0.16/src/data/diddoc.rs

458	#[test]
459	#[allow(clippy::cognitive_complexity)]
460	fn has_right_between() -> Result<()> {

irmaseal-curve 0.1.4/src/hash_to_curve/chain.rs

17	#[allow(clippy::cognitive_complexity)]
18	/// addchain for 1000602388805416848354447456433976039139220704984751971333014534031007912622709466110671907282253916009473568139946
324	#[allow(clippy::cognitive_complexity)]
325	/// addchain for 1001205140483106588246484290269935788605945006208159541241399033561623546780709821462541004956387089373434649096260670658193992783731681621012512651314777238193313314641988297376025498093520728838658813979860931248214124593092835

isla-cat 0.2.0/src/cat_lexer.rs

264	#[allow(clippy::cognitive_complexity)]
265	fn next(&mut self) -> Option<Self::Item> {

itmsink 0.1.4/src/itm.rs

72	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
73	fn parser<'cli>(

jemalloc-sys 0.5.2+5.3.0-patched/build.rs

39	// TODO: split main functions and remove following allow.
40	#[allow(clippy::cognitive_complexity)]
41	fn main() {

jsonlogic 0.5.1/src/operators/mod.rs

267	#[allow(clippy::cognitive_complexity)]
268	#[test]

kanidm 1.1.0-alpha/src/lib/be/mod.rs

104	/// execution log, so that it can be examined how an operation proceeded.
105	#[allow(clippy::cognitive_complexity)]
106	fn filter2idl(
848	// TODO: Can this be improved?
849	#[allow(clippy::cognitive_complexity)]
850	fn entry_index(

kanidm 1.1.0-alpha/src/lib/idm/authsession.rs

75	// TODO: Can this be improved?
76	#[allow(clippy::cognitive_complexity)]
77	impl CredHandler {

kanidm 1.1.0-alpha/src/lib/plugins/base.rs

46	// TODO: Can this be improved?
47	#[allow(clippy::cognitive_complexity)]
48	fn pre_create_transform(

kanidm 1.1.0-alpha/src/lib/plugins/memberof.rs

94	#[allow(clippy::cognitive_complexity)]
95	fn apply_memberof(

kdash 0.3.6/src/network/mod.rs

111	#[allow(clippy::cognitive_complexity)]
112	pub async fn handle_network_event(&mut self, io_event: IoEvent) {

keycode_macro 0.4.0/src/generate.rs

6	#[allow(clippy::cognitive_complexity)]
7	pub fn generate(key_maps: HashSet<KeyMap>) -> TokenStream {

koibumi 0.0.9/src/gui.rs

242	#[allow(clippy::cognitive_complexity)]
243	fn update(&mut self, message: Message) -> Command<Message> {

kpal 0.2.2/src/web/routes.rs

21

/// * `transmitters` The set of transmitters for sending messages into each peripheral thread

22

#[allow(clippy::cognitive_complexity)]

23

pub fn routes(request: &Request, libs: &[TSLibrary], txs: Arc<RwLock<Transmitters>>) -> Response {

krill 0.12.1/src/cli/client.rs

177	#[allow(clippy::cognitive_complexity)]
178	async fn certauth(&self, command: CaCommand) -> Result<ApiResponse, Error> {

krill 0.12.1/src/commons/bgp/report.rs

206	#[allow(clippy::cognitive_complexity)]
207	impl fmt::Display for BgpAnalysisSuggestion {
378	#[allow(clippy::cognitive_complexity)]
379	impl fmt::Display for BgpAnalysisReport {

kul 0.1.2/src/source_stream/char_iter_src_strm.rs

273	#[test]
274	#[allow(clippy::cyclomatic_complexity)]
275	fn source_stream() {

kul 0.1.2/src/source_stream/strish_iter_src_strm.rs

242	#[test]
243	#[allow(clippy::cyclomatic_complexity)]
244	fn source_stream() {

kul 0.1.2/src/text/chunk/pos_strish.rs

403	#[test]
404	#[allow(clippy::cyclomatic_complexity)]
405	fn refcnt_slice() {
573	#[test]
574	#[allow(unused_results, clippy::cyclomatic_complexity)]
575	fn pos_strish_srcstrm() {

labrador-ldpc 1.0.1/src/decoder.rs

349	/// not be of benefit).
350	#[allow(clippy::cognitive_complexity,clippy::many_single_char_names)]
351	pub fn decode_ms<T: DecodeFrom>(self, llrs: &[T], output: &mut [u8],

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

1889	#[test]
1890	#[allow(clippy::cognitive_complexity)]
1891	fn dir() {
1988	#[allow(clippy::cognitive_complexity)]
1989	#[test]

lattice-qcd-rs 0.2.1/src/statistics/distribution.rs

471	#[test]
472	#[allow(clippy::cognitive_complexity)]
473	fn distribution_creation() {

lattice-qcd-rs 0.2.1/src/utils.rs

387	#[allow(clippy::cognitive_complexity)]
388	#[test]

legion 0.4.0/src/internals/systems/schedule.rs

149	#[cfg(feature = "parallel")]
150	#[allow(clippy::cognitive_complexity)]
151	// TODO: we should break this up

legion-systems 0.2.4/src/schedule.rs

129	#[cfg(feature = "par-schedule")]
130	#[allow(clippy::cognitive_complexity)]
131	// TODO: we should break this up

lettre-openssl111 0.9.0/src/smtp/mod.rs

278	/// Sends an email
279	#[cfg_attr(feature = "cargo-clippy", allow(match_same_arms, cyclomatic_complexity))]
280	fn send(&mut self, email: SendableEmail) -> SmtpResult {

lib3h_crypto_api 0.0.42/src/crypto_system/crypto_system_test.rs

31	#[allow(clippy::cognitive_complexity)]
32	fn test_sec_buf(&self) {

libreauth 0.15.0/src/oath/key_uri.rs

195	/// Generate the final format.
196	#[allow(clippy::cognitive_complexity)]
197	pub fn finalize(&self) -> String {

libsignal-protocol 0.1.0/src/crypto/mod.rs

390	#[allow(clippy::cognitive_complexity)]
391	unsafe extern "C" fn internal_cipher(

libstratis 2.4.2/src/engine/shared.rs

218	#[test]
219	#[allow(clippy::cognitive_complexity)]
220	fn test_validate_name() {

lifxi 0.1.1/src/http/state.rs

354	/// Custom colors cannot be made with this method; use `Color::Custom(s)` instead.
355	#[allow(clippy::cyclomatic_complexity)]
356	fn from_str(s: &str) -> Result<Self, Self::Err> {

linkle 0.2.11/src/pki.rs

919	#[allow(clippy::cognitive_complexity)]
920	fn read_from_ini(&mut self, mut file: File) -> Result<(), Error> {
929	#[allow(clippy::cognitive_complexity)]
930	pub fn write<W: Write>(
941	#[allow(clippy::cognitive_complexity)]
942	#[allow(clippy::single_match)]

linux-libc-auxv 0.2.1/src/builder/serializer.rs

330	/// Example that includes all kinds of data (argv, env, different kinds of aux vars
331	#[allow(clippy::cognitive_complexity)]
332	#[test]

llvm-ir 0.8.2/src/function.rs

443	impl CallingConvention {
444	#[allow(clippy::cognitive_complexity)]
445	#[rustfmt::skip] // each calling convention on one line, even if lines get a little long

llvm-ir 0.8.2/tests/basic_tests.rs

137	#[test]
138	#[allow(clippy::cognitive_complexity)]
139	fn loopbc() {

llvm-ir 0.8.2/tests/llvm_8_tests.rs

99	#[allow(non_snake_case)]
100	#[allow(clippy::cognitive_complexity)]
101	fn DILocation_implicit_code_extra_checks() {

locustdb 0.3.4/src/bin/repl/main.rs

157	#[allow(clippy::cognitive_complexity)]
158	fn repl(locustdb: &LocustDB) {

locustdb 0.3.4/src/engine/execution/executor.rs

114	#[allow(clippy::cognitive_complexity)]
115	fn partition(&self) -> Vec<ExecutorStage> {

lpn 0.2.0/src/codes/stgen.rs

218	#[allow(clippy::cognitive_complexity)]
219	fn generator_matrix(&self) -> &BinMatrix {
309	#[allow(clippy::cognitive_complexity)]
310	fn decode_to_message(&self, c: &BinVector) -> Result<BinVector, &str> {

lrumap 0.1.0/src/tests.rs

98	#[allow(clippy::cognitive_complexity)]
99	fn enumeration_tests<Map>()
158	#[allow(clippy::cognitive_complexity)]
159	fn iteration_tests<Map>()

luminance-gl 0.19.1/src/gl33/shader.rs

318	#[allow(clippy::cognitive_complexity)]
319	fn check_uniform_type_match(

luminance-webgl 0.6.1/src/webgl2/shader.rs

372	#[allow(clippy::cognitive_complexity)]
373	fn check_types_match(name: &str, ty: UniformType, glty: u32) -> Result<(), UniformWarning> {

mamba 0.3.6/src/parse/lex/tokenize.rs

10	#[allow(clippy::cognitive_complexity)]
11	pub fn into_tokens(c: char, it: &mut Peekable<Chars>, state: &mut State) -> LexResult {

marlu 0.8.0/src/io/uvfits.rs

2029	#[test]
2030	#[allow(clippy::cognitive_complexity)]
2031	fn aips_117() {

marlu 0.8.0/src/pos/precession.rs

270	// TODO: reduce cognitive complexity
271	#[allow(clippy::cognitive_complexity)]
272	fn test_no_precession_at_j2000() {
333	// TODO: reduce cognitive complexity
334	#[allow(clippy::cognitive_complexity)]
335	fn test_no_precession_at_j2000_with_dut1() {

matterdb 1.2.0/src/indexes/sparse_list.rs

503	#[test]
504	#[allow(clippy::cognitive_complexity)]
505	fn test_list_index_methods() {

mbrman 0.5.1/src/lib.rs

1507	#[cfg(test)]
1508	#[allow(clippy::cognitive_complexity)]
1509	mod tests {

mbrman---bitvec-1-0 0.0.1/src/lib.rs

1507	#[cfg(test)]
1508	#[allow(clippy::cognitive_complexity)]
1509	mod tests {

mdcat 1.0.0/src/render.rs

39	#[allow(clippy::cognitive_complexity)]
40	#[instrument(level = "trace", skip(writer, settings, environment, theme))]

mediawiki_parser 0.4.2/src/lib.rs

5	clippy::unit_arg,
6	clippy::cyclomatic_complexity,
7	clippy::len_zero,

meshx 0.5.2/src/io/vtk.rs

1077	/// has an unsupported type, we leave it out of the remainder.
1078	#[allow(clippy::cognitive_complexity)]
1079	fn vtk_to_mesh_attrib<M, I>(
1182	/// Populate face vertex attributes from field attributes.
1183	#[allow(clippy::cognitive_complexity)]
1184	fn vtk_field_to_mesh_attrib<M>(

metaldb 1.0.0/src/indexes/sparse_list.rs

529	#[test]
530	#[allow(clippy::cognitive_complexity)]
531	fn test_list_index_methods() {

mini-moka 0.10.0/src/common/deque.rs

340	#[test]
341	#[allow(clippy::cognitive_complexity)]
342	fn basics() {

miniserde-enum 0.1.3/src/ser.rs

200	#[allow(clippy::cognitive_complexity)]
201	fn serialize_unnamed(

mla 1.3.0/src/lib.rs

1023	/// EndOfOriginalArchiveData)
1024	#[allow(clippy::cognitive_complexity)]
1025	pub fn convert_to_archive<W: InnerWriterTrait>(

mmtk 0.16.0/src/util/int_array_freelist.rs

91	#[test]
92	#[allow(clippy::cognitive_complexity)] // extensive checks, and it doesn't matter for tests
93	fn new_free_list_grain1() {
131	#[test]
132	#[allow(clippy::cognitive_complexity)] // extensive checks, and it doesn't matter for tests
133	fn new_free_list_grain2() {
208	#[test]
209	#[allow(clippy::cognitive_complexity)] // extensive checks, and it doesn't matter for tests
210	fn alloc_split() {

mmtk 0.16.0/src/util/raw_memory_freelist.rs

280	#[test]
281	#[allow(clippy::cognitive_complexity)] // extensive checks, and it doesn't matter for tests
282	fn new_free_list_grain1() {
320	#[test]
321	#[allow(clippy::cognitive_complexity)] // extensive checks, and it doesn't matter for tests
322	fn new_free_list_grain2() {
398	#[test]
399	#[allow(clippy::cognitive_complexity)] // extensive checks, and it doesn't matter for tests
400	fn alloc_split() {

mod_language 0.1.22/src/lib/session.rs

88	/// Requires a reference to source chars
89	#[allow(clippy::cognitive_complexity)] // Some functions are just complicated ok?
90	pub fn excerpt (&self, f: &mut Formatter) -> FMTResult {

moka 0.9.6/src/common/deque.rs

340	#[test]
341	#[allow(clippy::cognitive_complexity)]
342	fn basics() {

mokuroku 3.1.0/src/lib.rs

1747	#[allow(clippy::cognitive_complexity)]
1748	#[test]

molecule-codegen 0.7.3/src/generator/languages/rust/enumerator.rs

13	impl GenEnumerator for ast::Union {
14	#[allow(clippy::cognitive_complexity)]
15	fn gen_enumerator(&self) -> m4::TokenStream {

molt 0.3.1/src/expr.rs

293	#[allow(clippy::collapsible_if)]
294	#[allow(clippy::cognitive_complexity)]
295	#[allow(clippy::float_cmp)]

molt 0.3.1/src/util.rs

263	#[test]
264	#[allow(clippy::cognitive_complexity)]
265	fn test_util_read_float() {

molt-ng 0.3.2/src/expr.rs

293	#[allow(clippy::collapsible_if)]
294	#[allow(clippy::cognitive_complexity)]
295	#[allow(clippy::float_cmp)]

molt-ng 0.3.2/src/util.rs

263	#[test]
264	#[allow(clippy::cognitive_complexity)]
265	fn test_util_read_float() {

monotree 0.1.4/examples/perf.rs

50	#[allow(clippy::cognitive_complexity)]
51	fn main() {

move-stackless-bytecode 0.3.2/src/stackless_bytecode_generator.rs

160	#[allow(clippy::cognitive_complexity)]
161	pub fn generate_bytecode(

multihash 0.18.0/tests/lib.rs

89	#[allow(clippy::cognitive_complexity)]
90	#[test]
199	#[allow(clippy::cognitive_complexity)]
200	#[test]

mumble-protocol 0.4.1/src/crypt.rs

414	#[test]
415	#[allow(clippy::cognitive_complexity)] // all macro-generated
416	fn ocb_test_vectors() {

mumble-protocol-2x 0.5.0/src/crypt.rs

472	#[test]
473	#[allow(clippy::cognitive_complexity)] // all macro-generated
474	fn ocb_test_vectors() {

nameless-clap 3.0.0-beta.2.2/src/build/app/mod.rs

2885	impl<'help> From<&'help Yaml> for App<'help> {
2886	#[allow(clippy::cognitive_complexity)]
2887	fn from(y: &'help Yaml) -> Self {

nameless-clap 3.0.0-beta.2.2/src/build/app/settings.rs

1164	#[allow(clippy::cognitive_complexity)]
1165	#[test]

nameless-clap 3.0.0-beta.2.2/src/build/arg/mod.rs

4864	/// ```
4865	#[allow(clippy::cognitive_complexity)]
4866	fn from(y: &'help Yaml) -> Self {

nameless-clap 3.0.0-beta.2.2/src/build/usage_parser.rs

258	#[allow(clippy::cognitive_complexity)]
259	#[test]

nameless-clap 3.0.0-beta.2.2/src/parse/parser.rs

308	// The actual parsing function
309	#[allow(clippy::cognitive_complexity)]
310	pub(crate) fn get_matches_with(

ndarray 0.15.6/tests/array.rs

743	#[test]
744	#[allow(clippy::cognitive_complexity)]
745	fn merge_axes() {
1457	#[test]
1458	#[allow(clippy::cognitive_complexity)]
1459	fn insert_axis() {

ndarray 0.15.6/tests/dimension.rs

242	#[test]
243	#[allow(clippy::cognitive_complexity)]
244	fn test_hash() {
307	#[cfg(feature = "std")]
308	#[allow(clippy::cognitive_complexity)]
309	fn test_all_ndindex() {

noice 0.7.1/src/noise_fns/generators/worley.rs

378	#[allow(clippy::cognitive_complexity)]
379	impl NoiseFn<[f64; 4]> for Worley {

noise 0.8.2/src/core/worley.rs

259	#[inline(always)]
260	#[allow(clippy::cognitive_complexity)]
261	pub fn worley_4d<F, NH>(

noise 0.8.2/src/noise_fns/generators/worley.rs

118	#[allow(clippy::cognitive_complexity)]
119	impl NoiseFn<f64, 4> for Worley {

noria 0.6.1/src/data.rs

914	#[test]
915	#[allow(clippy::cognitive_complexity)]
916	fn data_type_fungibility() {

noria 0.6.1/src/table.rs

434	impl Table {
435	#[allow(clippy::cognitive_complexity)]
436	fn input(

noria-dataflow 0.6.0/src/domain/mod.rs

753	#[allow(clippy::cognitive_complexity)]
754	fn handle(&mut self, m: Box<Packet>, executor: &mut dyn Executor, top: bool) {
1782	#[allow(clippy::cognitive_complexity)]
1783	fn handle_replay(&mut self, m: Box<Packet>, ex: &mut dyn Executor) {

noria-dataflow 0.6.0/src/ops/grouped/aggregate.rs

181	#[test]
182	#[allow(clippy::cognitive_complexity)]
183	fn it_forwards() {
304	#[test]
305	#[allow(clippy::cognitive_complexity)]
306	fn it_groups_by_multiple_columns() {

noria-dataflow 0.6.0/src/ops/grouped/concat.rs

276	#[test]
277	#[allow(clippy::cognitive_complexity)]
278	fn it_forwards() {

noria-dataflow 0.6.0/src/ops/grouped/filteraggregate.rs

302	#[test]
303	#[allow(clippy::cognitive_complexity)]
304	fn it_forwards() {
418	#[test]
419	#[allow(clippy::cognitive_complexity)]
420	fn it_groups_by_multiple_columns() {

noria-dataflow 0.6.0/src/ops/join.rs

228	#[allow(clippy::cognitive_complexity)]
229	fn on_input(

noria-dataflow 0.6.0/src/ops/topk.rs

114	#[allow(clippy::cognitive_complexity)]
115	fn on_input(

noria-mir 0.6.0/src/reuse.rs

35	#[allow(clippy::cognitive_complexity)]
36	pub fn merge_mir_for_queries(

noria-server 0.6.0/src/controller/migrate/assignment.rs

20	for &node in topo_list {
21	#[allow(clippy::cognitive_complexity)]
22	let assignment = (\|\| {

noria-server 0.6.0/src/controller/migrate/materialization/mod.rs

101	/// satisfy indexing obligations in the given set of (new) nodes.
102	#[allow(clippy::cognitive_complexity)]
103	fn extend(&mut self, graph: &Graph, new: &HashSet<NodeIndex>) {
479	/// populating new materializations.
480	#[allow(clippy::cognitive_complexity)]
481	pub(super) fn commit(

noria-server 0.6.0/src/controller/migrate/materialization/plan.rs

107	/// eventually reported back by `finalize`.
108	#[allow(clippy::cognitive_complexity)]
109	pub(super) fn add(&mut self, index_on: Vec<usize>, replies: &mut DomainReplies) {

noria-server 0.6.0/src/controller/migrate/mod.rs

284	/// new updates should be sent to introduce them into the Soup.
285	#[allow(clippy::cognitive_complexity)]
286	pub(super) fn commit(self) {

noria-server 0.6.0/src/controller/migrate/sharding.rs

9	#[allow(clippy::cognitive_complexity)]
10	pub fn shard(

noria-server 0.6.0/src/controller/sql/mir/mod.rs

1605	/// Returns list of nodes added
1606	#[allow(clippy::cognitive_complexity)]
1607	fn make_nodes_for_selection(

noria-server 0.6.0/src/controller/sql/query_graph.rs

458	#[allow(clippy::cognitive_complexity)]
459	pub fn to_query_graph(st: &SelectStatement) -> Result<QueryGraph, String> {

ntex 0.6.3/src/http/response.rs

941	#[test]
942	#[allow(clippy::cognitive_complexity)]
943	fn test_into_response() {

ntex 0.6.3/src/web/error.rs

892	#[test]
893	#[allow(clippy::cognitive_complexity)]
894	fn test_error_helpers() {

ntex 0.6.3/src/web/info.rs

29	#[allow(clippy::cognitive_complexity)]
30	fn new(req: &RequestHead, cfg: &AppConfig) -> ConnectionInfo {

nu-engine 0.75.0/src/documentation.rs

38	#[allow(clippy::cognitive_complexity)]
39	fn get_documentation(

nu_plugin_textview 0.44.0/src/textview.rs

34	#[allow(clippy::cognitive_complexity)]
35	pub fn view_text_value(value: &Value) {

openidconnect 3.0.0-alpha.1/src/claims.rs

280	{
281	#[allow(clippy::cognitive_complexity)]
282	fn serialize<SE>(&self, serializer: SE) -> Result<SE::Ok, SE::Error>

openidconnect 3.0.0-alpha.1/src/registration.rs

359	{
360	#[allow(clippy::cognitive_complexity)]
361	fn serialize<SE>(&self, serializer: SE) -> Result<SE::Ok, SE::Error>

opensrv-clickhouse 0.3.0/src/types/column/factory.rs

71	impl dyn ColumnData {
72	#[allow(clippy::cognitive_complexity)]
73	pub(crate) fn load_data<W: ColumnWrapper, T: ReadEx>(

opg_derive 0.1.0/src/attr.rs

31	impl Container {
32	#[allow(clippy::cognitive_complexity)]
33	pub fn from_ast(cx: &ParsingContext, input: &syn::DeriveInput) -> Self {

oxygengine-ignite 0.30.0/src/main.rs

114	#[allow(clippy::cognitive_complexity)]
115	#[tokio::main]

oxygengine-integration-vn-cr 0.19.2/src/lib.rs

396	// TODO: REFACTOR THIS SHIT
397	#[allow(clippy::cognitive_complexity)]
398	#[allow(clippy::many_single_char_names)]

paired 0.22.0/src/bls12_381/cofactors.rs

55	// compatibly with Budroni-Pintore GLV-based method
56	#[allow(clippy::cognitive_complexity)]
57	fn chain_h2_eff<PtT: CurveProjective>(var1: &mut PtT, var0: &PtT) {

paired 0.22.0/src/bls12_381/ec/chain.rs

16	#[allow(clippy::cognitive_complexity)]
17	/// addchain for 1000602388805416848354447456433976039139220704984751971333014534031007912622709466110671907282253916009473568139946
340	#[allow(clippy::cognitive_complexity)]
341	/// addchain for 1001205140483106588246484290269935788605945006208159541241399033561623546780709821462541004956387089373434649096260670658193992783731681621012512651314777238193313314641988297376025498093520728838658813979860931248214124593092835

pairing-plus 0.19.0/src/bls12_381/fq.rs

529	#[test]
530	#[allow(clippy::cognitive_complexity)]
531	fn test_frob_coeffs() {

pairing-plus 0.19.0/src/bls12_381/osswu_map/chain.rs

10	#[allow(clippy::cognitive_complexity)]
11	/* * addchain for 1000602388805416848354447456433976039139220704984751971333014534031007912622709466110671907282253916009473568139946 * */
333	#[allow(clippy::cognitive_complexity)]
334	/* * addchain for 1001205140483106588246484290269935788605945006208159541241399033561623546780709821462541004956387089373434649096260670658193992783731681621012512651314777238193313314641988297376025498093520728838658813979860931248214124593092835 * */

palc 3.1.6/src/build/app_settings.rs

637	mod test {
638	#[allow(clippy::cognitive_complexity)]
639	#[test]

palc 3.1.6/src/build/usage_parser.rs

250	#[allow(clippy::cognitive_complexity)]
251	#[test]

palc 3.1.6/src/parse/parser.rs

61	// The actual parsing function
62	#[allow(clippy::cognitive_complexity)]
63	pub(crate) fn get_matches_with(

pbrt 0.1.5/src/core/parser.rs

102	// number is a superset of nom::double! that includes '1' and '1.'
103	#[allow(clippy::cyclomatic_complexity)]
104	fn number(input: &[u8]) -> IResult<&[u8], Float> {

pgdatetime 0.3.0/src/interval.rs

621	/// "day-time literal"s (that look like ('4 5:6:7')
622	#[allow(clippy::cognitive_complexity)]
623	fn format_interval(

pgnumeric 0.2.1/src/var.rs

1014	/// Returns `None` if `other == 0`.
1015	#[allow(clippy::cognitive_complexity)]
1016	pub fn div_common(&self, other: &Self, rscale: i32, round: bool) -> Option<Self> {
1254	/// Returns `None` if `other == 0`.
1255	#[allow(clippy::cognitive_complexity)]
1256	pub fn div_fast_common(&self, other: &Self, rscale: i32, round: bool) -> Option<Self> {

pgp 0.9.0/src/crypto/sym.rs

438	/// resynchronization after encrypting those BS+2 octets.
439	#[allow(clippy::cognitive_complexity)] // FIXME
440	pub fn encrypt_with_iv<'a>(

pickledb 0.5.1/tests/pickledb_advanced_tests.rs

77	#[allow(clippy::cognitive_complexity)]
78	#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]

pickledb 0.5.1/tests/pickledb_error_tests.rs

60	#[allow(clippy::cognitive_complexity)]
61	#[test]

pickledb 0.5.1/tests/pickledb_list_tests.rs

13	#[allow(clippy::cognitive_complexity)]
14	#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]

pilota 0.3.0/src/thrift/compact.rs

2607	#[allow(clippy::cognitive_complexity)]
2608	#[test]
2782	#[allow(clippy::cognitive_complexity)]
2783	#[test]
2966	#[allow(clippy::cognitive_complexity)]
2967	#[test]
3150	#[allow(clippy::cognitive_complexity)]
3151	#[test]
3332	#[allow(clippy::cognitive_complexity)]
3333	#[test]

pinyin-parser 0.1.7/src/finals.rs

228	#[allow(clippy::too_many_lines)]
229	#[allow(clippy::cognitive_complexity)]
230	pub fn get_candidates_without_rhotic(&self, strict: bool) -> Vec<Candidate> {

pinyin-parser 0.1.7/src/lib.rs

232	#[allow(clippy::too_many_lines)]
233	#[allow(clippy::cognitive_complexity)]
234	fn next(&mut self) -> Option<Self::Item> {

pliantdb-core 0.1.0-dev-2/src/schema/view/map.rs

205	#[test]
206	#[allow(clippy::cognitive_complexity)] // I disagree - @ecton
207	fn primitive_key_encoding_tests() -> anyhow::Result<()> {

plotchart 0.2.12/src/chart/context.rs

479	#[allow(clippy::too_many_arguments)]
480	#[allow(clippy::cognitive_complexity)]
481	fn draw_axis_and_labels(

plotters 0.3.4/src/chart/context/cartesian2d/draw_impl.rs

132	#[allow(clippy::too_many_arguments)]
133	#[allow(clippy::cognitive_complexity)]
134	fn draw_axis_and_labels(

plotters-unstable 0.2.1/src/chart/context.rs

266	#[allow(clippy::too_many_arguments)]
267	#[allow(clippy::cognitive_complexity)]
268	fn draw_axis_and_labels(

pmd_flow 1.0.2/src/flowdata.rs

408	#[allow(clippy::map_entry)]
409	#[allow(clippy::cognitive_complexity)]
410	/// encode a binary flow file

polar-core 0.26.4/src/lexer.rs

619	#[test]
620	#[allow(clippy::cognitive_complexity)]
621	fn test_lexer() {

polar-core 0.26.4/src/vm.rs

3144	#[test]
3145	#[allow(clippy::cognitive_complexity)]
3146	fn and_expression() {
3219	#[test]
3220	#[allow(clippy::cognitive_complexity)]
3221	fn isa_on_lists() {
3355	#[test]
3356	#[allow(clippy::cognitive_complexity)]
3357	fn isa_on_dicts() {

polyio 0.13.0/src/client.rs

140	#[allow(clippy::cognitive_complexity)]
141	pub async fn issue<E>(

polyio 0.13.0/src/events/stream.rs

309	/// Subscribe to and stream events from the Polygon service.
310	#[allow(clippy::cognitive_complexity)]
311	pub async fn stream<S>(

portier_broker 0.5.2/src/config/env.rs

102	#[allow(clippy::cognitive_complexity)]
103	fn apply(parsed: EnvConfig, builder: &mut ConfigBuilder) {

portier_broker 0.5.2/src/config/toml.rs

140	#[allow(clippy::cognitive_complexity)]
141	fn parse(path: &Path) -> TomlConfig {
237	#[allow(clippy::cognitive_complexity)]
238	fn apply(parsed: TomlConfig, builder: &mut ConfigBuilder) {

pot 1.0.2/src/format.rs

1373	#[test]
1374	#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
1375	fn integer_casts() {

pot 1.0.2/src/value.rs

660	#[test]
661	#[allow(clippy::cognitive_complexity)]
662	fn value_display_tests() {

pretty_trace 0.5.23/src/lib.rs

1013	#[allow(clippy::cognitive_complexity)]
1014	fn prettify_traceback(bt: &[u8], whitelist: &[String], pack: bool) -> String {

printpdf 0.5.3/src/extgstate.rs

623	#[cfg_attr(feature = "cargo-clippy", allow(needless_return))]
624	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
625	#[cfg_attr(feature = "cargo-clippy", allow(string_lit_as_bytes))]

process_viewer 0.5.6/src/network_dialog.rs

55	impl NetworkDialog {
56	#[allow(clippy::cognitive_complexity)]
57	pub fn update(&self, network: &sysinfo::NetworkData) {

procfs 0.14.2/src/meminfo.rs

398	#[allow(clippy::cognitive_complexity)]
399	#[allow(clippy::blocks_in_if_conditions)]

procfs 0.14.2/src/process/stat.rs

248	impl Stat {
249	#[allow(clippy::cognitive_complexity)]
250	pub fn from_reader<R: Read>(mut r: R) -> ProcResult<Stat> {

procfs 0.14.2/src/process/tests.rs

44	#[allow(clippy::cognitive_complexity)]
45	#[test]

programinduction 0.8.0/src/domains/strings.rs

443	#[allow(clippy::cyclomatic_complexity)]
444	#[allow(clippy::redundant_closure_call)]

project_init 3.1.23/src/main.rs

51	#[allow(clippy::cognitive_complexity)]
52	#[allow(clippy::print_literal)]

prototty_graphical_gfx 0.29.0/src/input.rs

22	#[allow(clippy::cognitive_complexity)]
23	fn convert_keycode_keyboard_input(code: VirtualKeyCode, shift: bool) -> Option<KeyboardInput> {

prototty_web 0.29.0/src/input.rs

9	#[allow(clippy::cognitive_complexity)]
10	fn keyboard_input_from_js_event_key_press(key_code: u8, shift: bool) -> Option<KeyboardInput> {

pyoxidizer 0.24.0/src/py_packaging/standalone_distribution.rs

663	/// Obtain an instance by scanning a directory containing an extracted distribution.
664	#[allow(clippy::cognitive_complexity)]
665	pub fn from_directory(dist_dir: &Path) -> Result<Self> {

python-packed-resources 0.12.0/src/parser.rs

1348	#[allow(clippy::cognitive_complexity)]
1349	#[test]

python-packed-resources 0.12.0/src/writer.rs

863	/// Write packed resources data, version 3.
864	#[allow(clippy::cognitive_complexity)]
865	pub fn write_packed_resources_v3<'a, T: AsRef<Resource<'a, u8>>, W: Write>(

qt_ritual 0.0.0/src/detect_signals_and_slots.rs

33	/// Parses include files to detect which methods are signals or slots.
34	#[allow(clippy::cyclomatic_complexity)]
35	pub fn detect_signals_and_slots(data: &mut ProcessorData) -> Result<()> {

queen 0.26.0/src/socket/switch.rs

275	#[allow(clippy::cognitive_complexity)]
276	fn relay_message(

rabbithole-derive 0.3.1/src/lib.rs

26	#[allow(clippy::cognitive_complexity)]
27	fn inner_derive(input: TokenStream) -> syn::Result<proc_macro2::TokenStream> {

radsort 0.1.0/tests/integration_tests.rs

29	#[test]
30	#[allow(clippy::cognitive_complexity)]
31	fn sort_integer() {
71	#[test]
72	#[allow(clippy::cognitive_complexity)]
73	fn sort_cached() {

rants 0.6.0/src/lib.rs

686	#[allow(clippy::cognitive_complexity)]
687	async fn connect(wrapped_client: Client) {
1215	#[allow(clippy::cognitive_complexity)]
1216	async fn handle_server_message(wrapped_client: Arc<Mutex<Self>>, message: ServerMessage) {

rate 0.3.0/rate.rs

38	/// call destructors.
39	#[allow(clippy::cognitive_complexity)]
40	fn run_frontend() -> i32 {
193	impl Flags {
194	#[allow(clippy::cognitive_complexity)]
195	/// Create a flags instance from commandline arguments.
841	/// Returns a conflict if it can be found by unit propagation.
842	#[allow(clippy::cognitive_complexity)]
843	fn propagate(checker: &mut Checker) -> MaybeConflict {
1089	/// Return true if the lemma is a propagation redundancy (PR) inference.
1090	#[allow(clippy::cognitive_complexity)]
1091	fn pr(checker: &mut Checker) -> bool {
1462	/// The reasons for the conflict are recorded for the LRAT and GRAT outputs if applicable.
1463	#[allow(clippy::cognitive_complexity)]
1464	fn extract_dependencies(

rbuf 0.1.3/tests/test.rs

139	#[test]
140	#[allow(clippy::cognitive_complexity)]
141	fn front_back() {

reign_view 0.2.1/src/parse/element.rs

286	impl Tokenize for Element {
287	#[allow(clippy::cognitive_complexity)]
288	fn tokenize(&self, tokens: &mut TokenStream, idents: &mut ViewFields, scopes: &ViewFields) {

requiem-web 2.0.0/src/info.rs

28	#[allow(clippy::cognitive_complexity)]
29	fn new(req: &RequestHead, cfg: &AppConfig) -> ConnectionInfo {

ritual 0.0.0/src/cpp_parser.rs

356	/// method may be specified in `context_class` and `context_method`.
357	#[allow(clippy::cyclomatic_complexity)]
358	fn parse_unexposed_type(
866	/// Parses a function `entity`.
867	#[allow(clippy::cyclomatic_complexity)]
868	fn parse_function(&self, entity: Entity) -> Result<(CppFunction, DatabaseItemSource)> {

ritual 0.0.0/src/tests/cpp_method.rs

454	#[test]
455	#[allow(clippy::cyclomatic_complexity)]
456	fn c_signature_method_returning_class() {

ritual 0.0.0/src/tests/cpp_parser.rs

383	#[allow(clippy::cyclomatic_complexity)]
384	#[test]

rocksdb 0.19.0/tests/test_iterator.rs

22	#[test]
23	#[allow(clippy::cognitive_complexity)]
24	fn test_iterator() {

rocksdbx 0.19.0/tests/test_iterator.rs

22	#[test]
23	#[allow(clippy::cognitive_complexity)]
24	fn test_iterator() {

routing 0.37.1/tests/ci.rs

335	// TODO: Extract the individual tests into their own functions.
336	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
337	fn core() {

rpi-led-matrix 0.4.0/src/args.rs

8	#[must_use]
9	#[allow(clippy::cognitive_complexity)]
10	pub fn add_matrix_args(app: App<'static>) -> App<'static> {

rs-graph 0.20.1/src/branching.rs

26	#[allow(clippy::cognitive_complexity)]
27	pub fn max_weight_branching<'a, G, W>(g: &'a G, weights: &EdgeVec<'a, &'a G, W>) -> Vec<G::Edge>

rs-graph 0.20.1/src/string.rs

140	/// used in production code.
141	#[allow(clippy::cognitive_complexity)]
142	pub fn from_ascii<G>(text: &str) -> Result<Data<G>, Error>

rst_parser 0.4.0/src/tests.rs

84	#[allow(clippy::cognitive_complexity)]
85	#[test]
119	#[allow(clippy::cognitive_complexity)]
120	#[test]
151	#[allow(clippy::cognitive_complexity)]
152	#[test]
179	#[allow(clippy::cognitive_complexity)]
180	#[test]
215	#[allow(clippy::cognitive_complexity)]
216	#[test]

ruint 1.7.0/src/algorithms/gcd/gcd_old.rs

74	/// <https://gmplib.org/repo/gmp-6.1/file/tip/mpn/generic/hgcd2.c#l44>
75	#[allow(clippy::cognitive_complexity)]
76	fn div1(mut a: u64, b: u64) -> u64 {
104	// Clippy operates on the unrolled code, giving a false positive.
105	#[allow(clippy::cognitive_complexity)]
106	fn lehmer_unroll(a2: u64, a3: &mut u64, k2: u64, k3: &mut u64) {

ruint 1.7.0/src/algorithms/gcd/matrix.rs

166	#[allow(clippy::redundant_else)]
167	#[allow(clippy::cognitive_complexity)] // REFACTOR: Improve
168	pub fn from_u64_prefix(a0: u64, mut a1: u64) -> Self {

ruint 1.7.0/src/algorithms/mul_redc.rs

4

/// See Handbook of Applied Cryptography, Algorithm 14.32, p. 601.

5

#[allow(clippy::cognitive_complexity)] // REFACTOR: Improve

6

pub fn mul_redc(a: &[u64], b: &[u64], result: &mut [u64], m: &[u64], inv: u64) {

rusqlite 0.28.0/src/types/mod.rs

243	#[test]
244	#[allow(clippy::cognitive_complexity)]
245	fn test_mismatched_types() -> Result<()> {

rusqlite-ic 0.28.1/src/types/mod.rs

243	#[test]
244	#[allow(clippy::cognitive_complexity)]
245	fn test_mismatched_types() -> Result<()> {

rusqlite-le 0.24.2/src/types/mod.rs

236	#[test]
237	#[allow(clippy::cognitive_complexity)]
238	fn test_mismatched_types() -> Result<()> {

rust_keylock 0.14.0/src/lib.rs

366	// This may change in the future during a refactoring but is accepted for now.
367	#[allow(clippy::cyclomatic_complexity)]
368	async fn handle(self) -> errors::Result<(CoreLogicHandler, bool)> {

rustup-find 0.1.2/src/main.rs

90	#[cfg_attr(feature = "cargo-clippy",
91	allow(cyclomatic_complexity))] // Allows us to have macros that use the parsed arguments.
92	#[cfg_attr(feature = "cargo-clippy",

rusty_v8 0.32.1/tests/test_api.rs

2982	#[test]
2983	#[allow(clippy::cognitive_complexity)]
2984	#[allow(clippy::eq_op)]

rusty_v8_m 0.4.6/tests/test_api.rs

2017	#[test]
2018	#[allow(clippy::cognitive_complexity)]
2019	#[allow(clippy::eq_op)]

rusty_v8_protryon 3.10.4/tests/test_api.rs

2048	#[test]
2049	#[allow(clippy::cognitive_complexity)]
2050	#[allow(clippy::eq_op)]

rustyline 10.1.1/src/tty/unix.rs

356	/// Handle \E[ <seq2:digit> escape sequences
357	#[allow(clippy::cognitive_complexity)]
358	fn extended_escape(&mut self, seq2: char) -> Result<KeyEvent> {

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

356	/// Handle \E[ <seq2:digit> escape sequences
357	#[allow(clippy::cognitive_complexity)]
358	fn extended_escape(&mut self, seq2: char) -> Result<KeyEvent> {

rustympkglib 0.1.1/src/pkgdata.rs

287	/// [PKGBUILD.proto]: https://git.archlinux.org/pacman.git/tree/proto/PKGBUILD.proto
288	#[allow(clippy::cognitive_complexity)]
289	pub fn from_source(source_code: &str) -> Result<PkgData, Error> {

rutenspitz_macro 0.2.1/src/lib.rs

403	impl<'s> quote::ToTokens for OperationEnum<'s> {
404	#[allow(clippy::cognitive_complexity)]
405	fn to_tokens(&self, tokens: &mut pm2::TokenStream) {

rysk-core 0.0.3/src/system.rs

163	/// Decode and execute an instruction
164	#[allow(clippy::cognitive_complexity)]
165	pub fn execute(&mut self, mmu: &mut dyn Mmu<R>) -> Result<(), Exception> {

s2n-quic-core 0.16.0/src/buffer/receive_buffer/tests.rs

353	#[test]
354	#[allow(clippy::cognitive_complexity)] // several operations are needed to get the buffer in the desired state
355	fn write_and_read_buffer() {

s2n-quic-core 0.16.0/src/packet/number/sliding_window.rs

159	#[test]
160	#[allow(clippy::cognitive_complexity)] // several operations are needed to get the desired state
161	fn insert() {
220	#[test]
221	#[allow(clippy::cognitive_complexity)] // several comparisons are needed
222	fn insert_at_edge() {

s2n-quic-transport 0.16.0/src/stream/contract.rs

80	impl Request {
81	#[allow(clippy::cognitive_complexity)]
82	pub fn validate_response(
334	impl Request {
335	#[allow(clippy::cognitive_complexity)]
336	pub fn validate_response(

safe_vault 0.20.2/src/client_handler.rs

233	#[allow(clippy::cognitive_complexity)]
234	fn handle_client_request(

safecoin-ledger 1.6.16/src/blockstore/blockstore_purge.rs

583	#[test]
584	#[allow(clippy::cognitive_complexity)]
585	fn test_purge_transaction_status() {
852	#[test]
853	#[allow(clippy::cognitive_complexity)]
854	fn test_purge_transaction_status_exact() {

safecoin-ledger 1.6.16/src/blockstore.rs

4800	#[test]
4801	#[allow(clippy::cognitive_complexity)]
4802	pub fn test_forward_chaining_is_connected() {
6258	#[test]
6259	#[allow(clippy::cognitive_complexity)]
6260	fn test_transaction_status_index() {

safecoin-runtime 1.14.3/src/bank.rs

9085	#[ignore]
9086	#[allow(clippy::cognitive_complexity)]
9087	fn test_rent_complex() {
9398	#[test]
9399	#[allow(clippy::cognitive_complexity)]
9400	fn test_rent_eager_across_epoch_without_gap_under_multi_epoch_cycle() {

saltwater 0.11.0/src/ir/expr.rs

28	// it can't be any smaller without supporting fewer features
29	#[allow(clippy::cognitive_complexity)]
30	pub(super) fn compile_expr(&mut self, expr: Expr, builder: &mut FunctionBuilder) -> IrResult {

salvo-http3 0.0.0/src/qpack/prefix_string/decode.rs

368	#[test]
369	#[allow(clippy::cognitive_complexity)]
370	fn test_decode_single_value() {

salvo-http3 0.0.0/src/qpack/prefix_string/encode.rs

450	#[test]
451	#[allow(clippy::cognitive_complexity)]
452	fn test_encode_single_value() {

salvo-quinn 0.0.1/src/qpack/prefix_string/decode.rs

380	#[test]
381	#[allow(clippy::cognitive_complexity)]
382	fn test_decode_single_value() {

salvo-quinn 0.0.1/src/qpack/prefix_string/encode.rs

451	#[test]
452	#[allow(clippy::cognitive_complexity)]
453	fn test_encode_single_value() {

sawtooth-sdk 0.5.2/src/processor/mod.rs

178	/// transaction handler.
179	#[allow(clippy::cognitive_complexity)]
180	pub fn start(&mut self) {

sccache 0.3.3/src/cache/cache.rs

330

/// Get a suitable `Storage` implementation from configuration.

331

#[allow(clippy::cognitive_complexity)] // TODO simplify!

332

pub fn storage_from_config(config: &Config, pool: &tokio::runtime::Handle) -> Arc<dyn Storage> {

sccache 0.3.3/src/compiler/args.rs

716	#[test]
717	#[allow(clippy::cognitive_complexity)]
718	fn test_arginfo_cmp() {

sccache 0.3.3/src/compiler/rust.rs

1797	impl pkg::InputsPackager for RustInputsPackager {
1798	#[allow(clippy::cognitive_complexity)] // TODO simplify this method.
1799	fn write_inputs(self: Box<Self>, wtr: &mut dyn io::Write) -> Result<dist::PathTransformer> {
2411	#[test]
2412	#[allow(clippy::cognitive_complexity)]
2413	fn test_parse_arguments_simple() {

scrappy 0.0.2/src/info.rs

28	#[allow(clippy::cognitive_complexity)]
29	fn new(req: &RequestHead, cfg: &AppConfig) -> ConnectionInfo {

sean_test_eth2_ssz_types 0.2.0/src/bitfield.rs

842	#[cfg(test)]
843	#[allow(clippy::cognitive_complexity)]
844	mod bitlist {

semverver 0.1.51/src/traverse.rs

125	/// in the same fashion.
126	#[allow(clippy::cognitive_complexity)]
127	fn diff_structure<'tcx>(

sentry-contrib-native 0.3.1/src/value.rs

912	#[test]
913	#[allow(clippy::cognitive_complexity)]
914	fn value_new() {
1009	#[test]
1010	#[allow(clippy::cognitive_complexity)]
1011	fn value_methods() {

serde_closure_derive 0.3.3/src/lib.rs

181	#[allow(
182	clippy::cognitive_complexity,
183	clippy::unnecessary_wraps,

serde_xmlrpc 0.1.2/src/util/value.rs

52	#[allow(clippy::cognitive_complexity)]
53	fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>

shawl 1.1.1/src/main.rs

452	#[allow(clippy::cognitive_complexity)]
453	pub fn run_service(start_arguments: Vec<std::ffi::OsString>) -> windows_service::Result<()> {

simd-json 0.7.0/src/stage2.rs

106	#[allow(
107	clippy::cognitive_complexity,
108	clippy::too_many_lines,

skillratings 0.24.0/src/trueskill.rs

1151	#[test]
1152	#[allow(clippy::cognitive_complexity)]
1153	/// This test is taken from:

skillratings 0.24.0/src/weng_lin.rs

929	#[test]
930	#[allow(clippy::cognitive_complexity)]
931	fn test_weng_two_teams() {
998	#[test]
999	#[allow(clippy::cognitive_complexity)]
1000	fn test_weng_multi_team_two() {

sled 0.34.7/src/tree.rs

1600	// challenging to understand.
1601	#[allow(clippy::cognitive_complexity)]
1602	pub(crate) fn view_for_key<'g, K>(

sm-ext-derive 0.3.0/src/lib.rs

145	impl MetadataInput {
146	#[allow(clippy::cognitive_complexity)]
147	pub fn new(ast: &syn::DeriveInput) -> MetadataInput {

smtpc 0.1.0/src/encoding/base64.rs

229	impl<W> Write for Base64Writer<W> where W: Write {
230	#[allow(clippy::cognitive_complexity)]
231	fn write(&mut self, buf: &[u8]) -> Result<usize, Error> {

smtpc 0.1.0/src/encoding/multipart.rs

75	{
76	#[allow(clippy::cognitive_complexity)]
77	fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {

sn_cli 0.68.7/tests/cli_files.rs

1040	#[test]
1041	#[allow(clippy::cognitive_complexity)]
1042	fn files_tree_should_display_entire_directory_tree_of_container() -> Result<()> {

snow 0.9.1/src/params/patterns.rs

291	#[allow(clippy::cognitive_complexity)]
292	fn try_from(handshake: &'a HandshakeChoice) -> Result<Self, Self::Error> {

snowpatch 0.2.0/src/main.rs

284	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
285	fn main() {

softposit 0.4.0/src/p16e1/math/mul_add.rs

30	//Default is always op==0
31	#[allow(clippy::cognitive_complexity)]
32	const fn mul_add(mut ui_a: u16, mut ui_b: u16, mut ui_c: u16, op: MulAddType) -> P16E1 {

softposit 0.4.0/src/p32e2/math/mul_add.rs

28	#[allow(clippy::cognitive_complexity)]
29	const fn mul_add(mut ui_a: u32, mut ui_b: u32, mut ui_c: u32, op: MulAddType) -> P32E2 {

softposit 0.4.0/src/p8e0/math/mul_add.rs

30	//Default is always op==0
31	#[allow(clippy::cognitive_complexity)]
32	const fn mul_add(mut ui_a: u8, mut ui_b: u8, mut ui_c: u8, op: MulAddType) -> P8E0 {

softposit 0.4.0/src/pxe1/convert.rs

121	#[allow(clippy::cognitive_complexity)]
122	pub fn from_f64(mut float: f64) -> Self {

softposit 0.4.0/src/pxe1/math.rs

27	#[allow(clippy::cognitive_complexity)]
28	const fn mul_add_ui(mut ui_a: u32, mut ui_b: u32, mut ui_c: u32, op: MulAddType) -> Self {

softposit 0.4.0/src/pxe2/convert.rs

121	#[allow(clippy::cognitive_complexity)]
122	pub fn from_f64(mut float: f64) -> Self {

softposit 0.4.0/src/pxe2/math.rs

27	#[allow(clippy::cognitive_complexity)]
28	const fn mul_add_ui(mut ui_a: u32, mut ui_b: u32, mut ui_c: u32, op: MulAddType) -> Self {

solana-accounts-tool 0.0.1/src/main.rs

10	#[allow(clippy::cognitive_complexity)]
11	fn main() {

solana-cli 1.14.13/src/cli.rs

1820	#[test]
1821	#[allow(clippy::cognitive_complexity)]
1822	fn test_cli_parse_command() {
2032	#[test]
2033	#[allow(clippy::cognitive_complexity)]
2034	fn test_cli_process_command() {

solana-cli 1.14.13/src/program.rs

2339	#[test]
2340	#[allow(clippy::cognitive_complexity)]
2341	fn test_cli_parse_deploy() {
2554	#[test]
2555	#[allow(clippy::cognitive_complexity)]
2556	fn test_cli_parse_write_buffer() {
2707	#[test]
2708	#[allow(clippy::cognitive_complexity)]
2709	fn test_cli_parse_set_upgrade_authority() {
2815	#[test]
2816	#[allow(clippy::cognitive_complexity)]
2817	fn test_cli_parse_set_buffer_authority() {
2872	#[test]
2873	#[allow(clippy::cognitive_complexity)]
2874	fn test_cli_parse_show() {

solana-cli 1.14.13/src/stake.rs

2689	#[test]
2690	#[allow(clippy::cognitive_complexity)]
2691	fn test_parse_command() {

solana-core 1.14.13/tests/fork-selection.rs

365	#[test]
366	#[allow(clippy::cognitive_complexity)]
367	fn test_push_vote() {

solana-genesis 1.14.13/src/main.rs

103	#[allow(clippy::cognitive_complexity)]
104	fn main() -> Result<(), Box<dyn error::Error>> {

solana-ledger 1.14.13/src/blockstore/blockstore_purge.rs

617	#[test]
618	#[allow(clippy::cognitive_complexity)]
619	fn test_purge_transaction_status() {
904	#[test]
905	#[allow(clippy::cognitive_complexity)]
906	fn test_purge_transaction_status_exact() {

solana-ledger 1.14.13/src/blockstore.rs

5447	#[test]
5448	#[allow(clippy::cognitive_complexity)]
5449	pub fn test_forward_chaining_is_connected() {
6950	#[test]
6951	#[allow(clippy::cognitive_complexity)]
6952	fn test_transaction_status_index() {

solana-ledger-tool 1.14.13/src/main.rs

459	#[allow(clippy::cognitive_complexity)]
460	fn graph_forks(bank_forks: &BankForks, config: &GraphConfig) -> String {
1077	#[allow(clippy::cognitive_complexity)]
1078	fn main() {

solana_libra_types 0.0.1-sol5/src/proof/position/position_test.rs

416	#[test]
417	#[allow(clippy::cognitive_complexity)]
418	fn test_position_extended() {

solana_libra_vm_runtime 0.0.1-sol5/src/txn_executor.rs

177	/// instruction to be executed.
178	#[allow(clippy::cognitive_complexity)]
179	pub fn execute_block(

solana-local-cluster 1.14.13/tests/common.rs

257	/// run with a fixed, predetermined leader schedule
258	#[allow(clippy::cognitive_complexity)]
259	pub fn run_cluster_partition<C>(

solana-ramp-tps 1.6.28/src/main.rs

53	#[allow(clippy::cognitive_complexity)]
54	fn main() {

solana-runtime 1.14.13/src/bank.rs

8849	#[ignore]
8850	#[allow(clippy::cognitive_complexity)]
8851	fn test_rent_complex() {
9162	#[test]
9163	#[allow(clippy::cognitive_complexity)]
9164	fn test_rent_eager_across_epoch_without_gap_under_multi_epoch_cycle() {

solana-stake-o-matic 1.6.28/src/main.rs

1091	#[allow(clippy::cognitive_complexity)] // Yeah I know...
1092	fn main() -> Result<(), Box<dyn error::Error>> {

solang 0.2.1/tests/substrate.rs

130	impl Externals for MockSubstrate {
131	#[allow(clippy::cognitive_complexity)]
132	fn invoke_index(

solsa 0.1.7/src/main.rs

76	// in time `cyclomatic_complexity` should go back to warn
77	#[cfg_attr(feature = "cargo-clippy", allow(single_match, cyclomatic_complexity))]
78	fn main() {

sophia_term 0.7.2/src/index_map.rs

71	#[allow(clippy::cognitive_complexity)]
72	/// Takes an empty TermIndexMap, and checks that it behaves as expected.

sourcemap 6.2.1/src/sourceview.rs

332	#[test]
333	#[allow(clippy::cognitive_complexity)]
334	fn test_minified_source_view() {

sp-multihash 0.3.0/tests/lib.rs

117	#[allow(clippy::cognitive_complexity)]
118	#[test]
214	#[allow(clippy::cognitive_complexity)]
215	#[test]

spdx-rs 0.5.2/src/parsers/mod.rs

77	#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
78	fn spdx_from_atoms(atoms: &[Atom]) -> Result<SPDX, SpdxError> {
277	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
278	fn process_atom_for_packages(

spectrum-analyzer 1.2.6/src/spectrum.rs

557	#[test]
558	#[allow(clippy::cognitive_complexity)]
559	fn test_spectrum_basic() {

spidap 0.1.0/src/main.rs

12	#[allow(clippy::cognitive_complexity)]
13	fn main() -> anyhow::Result<()> {

splinter 0.6.14/src/peer/mod.rs

1244	// to avoid needing a lock in the PeerManager.
1245	#[allow(clippy::too_many_arguments, clippy::cognitive_complexity)]
1246	fn handle_connected(

splr 0.17.0/src/solver/conflict.rs

18	/// - otherwise: it's the LBD of the learnt clause.
19	#[allow(clippy::cognitive_complexity)]
20	pub fn handle_conflict(

splr 0.17.0/src/state.rs

426	/// `mes` should be shorter than or equal to 9, or 8 + a delimiter.
427	#[allow(clippy::cognitive_complexity)]
428	fn progress<A, C>(&mut self, asg: &A, cdb: &C)
614	impl State {
615	#[allow(clippy::cognitive_complexity)]
616	fn record_stats<A, C>(&mut self, asg: &A, cdb: &C)

spotify-tui 0.25.0/src/network.rs

143	#[allow(clippy::cognitive_complexity)]
144	pub async fn handle_network_event(&mut self, io_event: IoEvent) {

sql-ast 0.7.5/src/ast/mod.rs

537	// split up without extracting structs for each `Statement` variant.
538	#[allow(clippy::cognitive_complexity)]
539	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

sqlparser 0.30.0/src/ast/mod.rs

1639	// split up without extracting structs for each `Statement` variant.
1640	#[allow(clippy::cognitive_complexity)]
1641	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

srcinfo 1.1.0/src/parse.rs

125	#[allow(clippy::cognitive_complexity)]
126	fn merge_current_package(&mut self) {

ssz_types 1.0.0-beta.0/src/bitfield.rs

859	#[cfg(test)]
860	#[allow(clippy::cognitive_complexity)]
861	mod bitlist {

stage 0.2.0/src/actors/reactor.rs

34	// TODO: Address this lint
35	#[allow(clippy::cognitive_complexity)]
36	fn iter(&mut self) -> Loop {

stretch2 0.4.3/src/algo.rs

127	#[allow(clippy::cognitive_complexity)]
128	fn compute_internal(

structural 0.4.3/src/field/array_impls.rs

355	// Every statement after the array initialization is unrelated to every other statement.
356	#[allow(clippy::cognitive_complexity)]
357	fn structural_aliases() {

structural_derive 0.4.3/src/structural_alias_impl_mod.rs

447	// At some point it would be a good idea to split this into multiple functions
448	#[allow(clippy::cognitive_complexity)]
449	pub(crate) fn for_delegation<'a, A, I>(

structural_derive 0.4.3/src/structural_derive.rs

167	#[allow(clippy::cognitive_complexity)]
168	fn deriving_structural<'a>(

swc_common 0.29.29/src/errors/emitter.rs

337	#[allow(clippy::cognitive_complexity)]
338	fn render_source_line(
931	#[allow(clippy::cognitive_complexity, clippy::comparison_chain)]
932	fn emit_message_default(

swc_ecma_codegen 0.129.8/src/lib.rs

2125	#[allow(clippy::cognitive_complexity)]
2126	fn emit_list5<N: Node>(

swc_js_sourcemap 5.0.2/src/sourceview.rs

325	#[test]
326	#[allow(clippy::cognitive_complexity)]
327	fn test_minified_source_view() {

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

56	#[allow(clippy::cognitive_complexity)]
57	pub fn synth(

sysexits 0.4.1/src/exit_code.rs

560	#[cfg(feature = "std")]
561	#[allow(clippy::cognitive_complexity)]
562	#[test]
745	#[cfg(any(unix, windows))]
746	#[allow(clippy::cognitive_complexity)]
747	#[test]

tamasfe-clap 3.0.0-beta.2/src/build/app/mod.rs

2754	impl<'help> From<&'help Yaml> for App<'help> {
2755	#[allow(clippy::cognitive_complexity)]
2756	fn from(mut yaml: &'help Yaml) -> Self {

tamasfe-clap 3.0.0-beta.2/src/build/app/settings.rs

1071	#[allow(clippy::cognitive_complexity)]
1072	#[test]

tamasfe-clap 3.0.0-beta.2/src/build/arg/mod.rs

4425	/// [`Arg`]: ./struct.Arg.html
4426	#[allow(clippy::cognitive_complexity)]
4427	fn from(y: &'help Yaml) -> Self {

tamasfe-clap 3.0.0-beta.2/src/build/usage_parser.rs

254	#[allow(clippy::cognitive_complexity)]
255	#[test]

tamasfe-clap 3.0.0-beta.2/src/parse/parser.rs

335	// The actual parsing function
336	#[allow(clippy::cognitive_complexity)]
337	pub(crate) fn get_matches_with(

taplo 1.0.0-alpha.6/src/dom.rs

233	// This has become a mess, it screams for a refactor
234	#[allow(clippy::cognitive_complexity)]
235	impl Cast for RootNode {

taplo 1.0.0-alpha.6/src/formatter.rs

154	// TODO(refactor)
155	#[allow(clippy::cognitive_complexity)]
156	fn format_root(node: SyntaxNode, builder: &mut GreenNodeBuilder, options: &Options) {

tari_wallet 0.8.1/src/transaction_service/storage/memory_db.rs

78	}
79	#[allow(clippy::cognitive_complexity)]
80	impl TransactionBackend for TransactionMemoryDatabase {

tbot 0.6.7/src/event_loop.rs

1169	#[allow(clippy::cognitive_complexity)]
1170	#[allow(clippy::too_many_lines)] // can't split the huge match
1396	#[allow(clippy::too_many_lines, clippy::cognitive_complexity)] // can't split the huge match
1397	fn handle_message_edit_update(

tbot 0.6.7/src/types/message.rs

157	#[allow(clippy::cognitive_complexity)] // can't do much
158	#[allow(clippy::too_many_lines)]

tectonic_xdv 0.2.1/src/lib.rs

437	/// be able to parse the next directive.
438	#[allow(clippy::cognitive_complexity)]
439	pub fn parse(&mut self, chunk: &[u8]) -> Result<(usize, bool), T::Error> {

teleterm 0.2.0/src/session_list.rs

157	#[cfg(test)]
158	#[allow(clippy::cognitive_complexity)]
159	#[allow(clippy::redundant_clone)]

tendermint-config 0.28.0/tests/mod.rs

17	/// Parse an example `config.toml` file to a `TendermintConfig` struct
18	#[allow(clippy::cognitive_complexity)]
19	#[test]

tf-rs 0.0.5/src/ops/gradients_impl.rs

73	#[doc(hidden)]
74	#[allow(clippy::cognitive_complexity)]
75	pub fn gradients<Tys, Txs, S>(

tflite 0.9.6/src/interpreter/mod.rs

327	#[allow(clippy::cognitive_complexity)]
328	pub fn set_tensor_parameters_read_write(

tflite 0.9.6/src/model/builtin_options.rs

55	impl PartialEq for BuiltinOptionsUnion {
56	#[allow(clippy::cognitive_complexity)]
57	fn eq(&self, other: &Self) -> bool {

thrift 0.17.0/src/protocol/compact.rs

1553	#[allow(clippy::cognitive_complexity)]
1554	#[test]
1716	#[allow(clippy::cognitive_complexity)]
1717	#[test]
1890	#[allow(clippy::cognitive_complexity)]
1891	#[test]
2064	#[allow(clippy::cognitive_complexity)]
2065	#[test]
2236	#[allow(clippy::cognitive_complexity)]
2237	#[test]

tikv-jemalloc-sys 0.5.2+5.3.0-patched/build.rs

39	// TODO: split main functions and remove following allow.
40	#[allow(clippy::cognitive_complexity)]
41	fn main() {

timediff 0.2.3/src/locale/de_de.rs

89	#[test]
90	#[allow(clippy::cognitive_complexity)]
91	fn test_units() {

timediff 0.2.3/src/locale/en_us.rs

102	#[test]
103	#[allow(clippy::cognitive_complexity)]
104	fn test_units() {

timediff 0.2.3/src/locale/ru_ru.rs

154	#[test]
155	#[allow(clippy::cognitive_complexity)]
156	fn test_units() {

timediff 0.2.3/src/locale/tr_tr.rs

102	#[test]
103	#[allow(clippy::cognitive_complexity)]
104	fn test_units() {

timediff 0.2.3/src/locale/zh_cn.rs

102	#[test]
103	#[allow(clippy::cognitive_complexity)]
104	fn test_units() {

tin-summer 1.21.14/src/main.rs

14	#[allow(unknown_lints)]
15	#[allow(clippy::cognitive_complexity)]
16	#[allow(clippy::unreadable_literal)]

tiny-multihash 0.5.0/tests/lib.rs

97	#[allow(clippy::cognitive_complexity)]
98	#[test]
185	#[allow(clippy::cognitive_complexity)]
186	#[test]

titanic 0.1.0/src/lexer.rs

91	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
92	fn next(&mut self) -> Option<Self::Item> {

titanic 0.1.0/src/parser.rs

139	/// The comma before utc has to have already been consumed.
140	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
141	fn parse_gga(

tm1637-gpio-driver 2.0.6/src/lib.rs

387	/// for lowercase charts by their uppercase counterpart and vice versa.
388	#[allow(clippy::cognitive_complexity)]
389	#[allow(clippy::if_same_then_else)]

tokio-executor 0.2.0-alpha.6/src/threadpool/pool/mod.rs

397

    /// is available so that they can try to find more work to process.

398

    #[allow(clippy::cognitive_complexity)] // https://github.com/rust-lang/rust-clippy/issues/3900

399

    pub(crate) fn signal_work(&self, pool: &Arc<Pool>) {

tokio-executor 0.2.0-alpha.6/src/threadpool/task/mod.rs

98

    // tracing macro expansion adds enough branches to make clippy angry here.

99

    #[allow(clippy::cognitive_complexity)] // https://github.com/rust-lang/rust-clippy/issues/3900

100

    pub(crate) fn run(me: &Arc<Task>, pool: &Arc<Pool>) -> Run {

tokio-executor 0.2.0-alpha.6/src/threadpool/worker/mod.rs

566	// tracing macro expansion adds enough branches to make clippy angry here.
567	#[allow(clippy::cognitive_complexity)] // https://github.com/rust-lang/rust-clippy/issues/3900
568	fn sleep(&self) -> bool {

tokkit 0.17.0/src/token_manager/internals/request_scheduler.rs

283	#[test]
284	#[allow(clippy::cognitive_complexity)]
285	fn scheduler_workflow() {

toml-query 0.10.0/src/set.rs

265	#[test]
266	#[allow(clippy::cognitive_complexity)]
267	fn test_set_with_seperator_into_nested_table() {

tor-chanmgr 0.8.0/src/event.rs

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

tor-guardmgr 0.8.0/src/sample.rs

1231	#[test]
1232	#[allow(clippy::cognitive_complexity)]
1233	fn sampling_and_usage() {

tor-netdir 0.7.0/src/params.rs

381	#[allow(clippy::unwrap_used)]
382	#[allow(clippy::cognitive_complexity)]
383	mod test {

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

490

    pub(super) async fn run_once(&mut self) -> std::result::Result<(), ReactorError> {

491

        #[allow(clippy::cognitive_complexity)]

492

        let fut = futures::future::poll_fn(|cx| -> Poll<std::result::Result<_, ReactorError>> {

tox_core 0.1.1/src/state_format/old.rs

412	impl ToBytes for FriendState {
413	#[allow(clippy::cognitive_complexity)]
414	fn to_bytes<'a>(&self, buf: (&'a mut [u8], usize)) -> Result<(&'a mut [u8], usize), GenError> {

tracers-codegen 0.1.0/src/argtypes.rs

75	/// in this case it's safe to ignore the clippy lint.
76	#[allow(clippy::cognitive_complexity)]
77	pub(crate) fn from_syn_type(ty: &syn::Type) -> Option<ArgTypeInfo> {

trippy 0.6.0/src/tracing/tracer.rs

558	#[allow(
559	clippy::cognitive_complexity,
560	clippy::too_many_lines,

trust-dns-client 0.22.0/src/rr/zone.rs

160	impl UsageTrie {
161	#[allow(clippy::cognitive_complexity)]
162	fn default() -> Self {

trust-dns-client 0.22.0/src/serialize/txt/zone_lex.rs

598	#[test]
599	#[allow(clippy::cognitive_complexity)]
600	fn soa() {

trust-dns-proto 0.22.0/src/tcp/tcp_stream.rs

250	#[allow(clippy::cognitive_complexity)]
251	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {

trust-dns-server 0.22.0/tests/txt_tests.rs

13	#[test]
14	#[allow(clippy::cognitive_complexity)]
15	fn test_zone() {
410	#[test]
411	#[allow(clippy::cognitive_complexity)]
412	fn test_bad_cname_at_soa() {

tulip-derivative 2.2.1/src/attr.rs

261	/// Parse the `derivative` attributes on a type.
262	#[allow(clippy::cognitive_complexity)] // mostly macros
263	pub fn from_ast(
446	/// Parse the `derivative` attributes on a type.
447	#[allow(clippy::cognitive_complexity)] // mostly macros
448	pub fn from_ast(

twilight-cache-inmemory 0.15.0-rc.1/src/lib.rs

837	// clippy: using `.deref()` is cleaner
838	#[allow(clippy::cognitive_complexity, clippy::explicit_deref_methods)]
839	fn update(&self, c: &InMemoryCache) {

tydi 0.0.7/src/physical.rs

749	#[test]
750	#[allow(clippy::cognitive_complexity)]
751	fn complexity() -> Result<()> {
803	#[test]
804	#[allow(clippy::cognitive_complexity)]
805	fn physical_stream() -> Result<()> {

typescript-definitions-derive 0.1.10/src/tots.rs

14	impl<'a> FieldContext<'a> {
15	#[allow(clippy::cyclomatic_complexity)]
16	fn generic_to_ts(&self, ts: &TSType) -> QuoteT {

typescript-definitions-derive-ufo-patch 0.1.11/src/tots.rs

14	impl<'a> FieldContext<'a> {
15	#[allow(clippy::cyclomatic_complexity)]
16	fn generic_to_ts(&self, ts: &TSType) -> QuoteT {

typical 0.9.2/src/tokenizer.rs

18	// Tokenize the contents of a schema file.
19	#[allow(clippy::cognitive_complexity)]
20	#[allow(clippy::too_many_lines)]

unic-segment 0.9.0/src/word.rs

403	#[inline]
404	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
405	fn next_back(&mut self) -> Option<&'a str> {

unimap 0.2.0/src/args.rs

13	#[allow(clippy::cognitive_complexity)]
14	pub fn get_args() -> Args {

unrest_tmp_syn 0.1.0/src/visit.rs

420	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
421	pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr) {

uu_cut 0.0.17/src/cut.rs

191	#[allow(clippy::cognitive_complexity)]
192	fn cut_fields_delimiter<R: Read>(

uu_du 0.0.17/src/du.rs

506	#[uucore::main]
507	#[allow(clippy::cognitive_complexity)]
508	pub fn uumain(args: impl uucore::Args) -> UResult<()> {

uu_fmt 0.0.17/src/fmt.rs

64	#[uucore::main]
65	#[allow(clippy::cognitive_complexity)]
66	pub fn uumain(args: impl uucore::Args) -> UResult<()> {

uu_hashsum 0.0.17/src/hashsum.rs

56	#[allow(clippy::cognitive_complexity)]
57	fn detect_algo(
491	#[allow(clippy::cognitive_complexity)]
492	fn hashsum<'a, I>(mut options: Options, files: I) -> UResult<()>

uu_install 0.0.17/src/install.rs

641	///
642	#[allow(clippy::cognitive_complexity)]
643	fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {

uu_ls 0.0.17/src/ls.rs

429	impl Config {
430	#[allow(clippy::cognitive_complexity)]
431	pub fn from(options: &clap::ArgMatches) -> UResult<Self> {

uu_stat 0.0.17/src/stat.rs

205	#[allow(clippy::cognitive_complexity)]
206	fn print_it(output: &OutputType, flags: Flags, width: usize, precision: Option<usize>) {

v-clickhouse-rs 0.2.0-alpha.7/src/types/column/factory.rs

52	impl dyn ColumnData {
53	#[allow(clippy::cognitive_complexity)]
54	pub(crate) fn load_data<W: ColumnWrapper, T: ReadEx>(

v_eval 0.6.0/src/lib.rs

621	#[allow(clippy::cognitive_complexity)]
622	#[test]

v_eval 0.6.0/src/method/f64_t.rs

106	impl Eval for Fun {
107	#[allow(clippy::cognitive_complexity)]
108	#[inline]

v8 0.62.0/tests/test_api.rs

4479	#[test]
4480	#[allow(clippy::cognitive_complexity)]
4481	#[allow(clippy::eq_op)]

vcard 0.4.11/src/lib.rs

617	impl Display for VCard {
618	#[allow(clippy::cognitive_complexity)]
619	fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {

vcf 0.6.1/src/record/test.rs

107	#[allow(clippy::unreadable_literal)]
108	#[allow(clippy::cognitive_complexity)]
109	fn test_parse_record1() -> Result<(), VCFError> {
438	#[allow(clippy::unreadable_literal)]
439	#[allow(clippy::cognitive_complexity)]
440	fn test_parse_record7() -> Result<(), VCFError> {

virtiofsd 1.5.0/src/server.rs

81	#[allow(clippy::cognitive_complexity)]
82	pub fn handle_message<T: FsCacheReqHandler>(

vkgen 2.2.1/src/gen.rs

323	/// generates rust source code from the given `vec` and writes it to `writer`
324	#[allow(clippy::cognitive_complexity)]
325	pub fn gen(

vkgen 2.2.1/src/parse.rs

316	impl<'de> Deserialize<'de> for Registry {
317	#[allow(clippy::cognitive_complexity)]
318	fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {

vmm-sys-util 0.11.1/src/linux/seek_hole.rs

137	#[test]
138	#[allow(clippy::cognitive_complexity)]
139	fn seek_hole() {

vpncloud 2.3.0/src/config.rs

90	impl Config {
91	#[allow(clippy::cognitive_complexity)]
92	pub fn merge_file(&mut self, mut file: ConfigFile) {

vpncloud 2.3.0/src/main.rs

175	#[allow(clippy::cognitive_complexity)]
176	fn run<P: Protocol, S: Socket>(config: Config, socket: S) {

vsdbsled 0.34.7-patched/src/tree.rs

1600	// challenging to understand.
1601	#[allow(clippy::cognitive_complexity)]
1602	pub(crate) fn view_for_key<'g, K>(

vsmtp-mail-parser 2.0.1-rc.4/src/implementation/mail_mime_parser.rs

47	impl MailMimeParser {
48	#[allow(clippy::cognitive_complexity)]
49	#[tracing::instrument(name = "parsing email", skip_all)]
308	#[allow(clippy::cognitive_complexity)]
309	fn parse_multipart(

vsmtp-rule-engine 2.0.1-rc.4/src/api/dkim.rs

635	/// * `get_header_untouched` failed.
636	#[allow(clippy::cognitive_complexity)]
637	fn verify_first_signature_or_error(

vsmtp-rule-engine 2.0.1-rc.4/src/api/logging.rs

208	#[rhai_fn(global, name = "log")]
209	#[allow(clippy::cognitive_complexity)]
210	pub fn log(level: &str, message: &str) {

vsmtp-rule-engine 2.0.1-rc.4/src/rule_engine.rs

265	/// at this point, any ill formed input will produce an error.
266	#[allow(clippy::cognitive_complexity)]
267	fn get_delegation_directive_from_header(

vxdraw 0.6.0/src/data.rs

397	impl Drop for VxDraw {
398	#[allow(clippy::cognitive_complexity)]
399	fn drop(&mut self) {

vxdraw 0.6.0/src/lib.rs

1076	/// Internal drawing routine
1077	#[allow(clippy::cognitive_complexity)]
1078	fn draw_frame_internal<T>(

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

9072	#[ignore]
9073	#[allow(clippy::cognitive_complexity)]
9074	fn test_rent_complex() {
9385	#[test]
9386	#[allow(clippy::cognitive_complexity)]
9387	fn test_rent_eager_across_epoch_without_gap_under_multi_epoch_cycle() {

wain-exec 0.3.0/src/machine.rs

444

impl<'f, 'm, 's, I: Importer> Execute<'f, 'm, 's, I> for ast::Instruction {

445

    #[allow(clippy::cognitive_complexity)]

446

    fn execute(&self, machine: &mut Machine<'m, 's, I>, frame: &CallFrame<'f>) -> ExecResult {

warpgrapher 0.11.2/src/engine/schema.rs

2775	/// Passes if the right schema elements are generated
2776	#[allow(clippy::cognitive_complexity)]
2777	#[test]
2893	/// Passes if the right schema elements are generated
2894	#[allow(clippy::cognitive_complexity)]
2895	#[test]
2979	/// Passes if the right schema elements are generated
2980	#[allow(clippy::cognitive_complexity)]
2981	#[test]
3057	/// Passes if the right schema elements are generated
3058	#[allow(clippy::cognitive_complexity)]
3059	#[test]
3239	/// Passes if the right schema elements are generated
3240	#[allow(clippy::cognitive_complexity)]
3241	#[test]

warpgrapher 0.11.2/tests/comparison_tests.rs

59	#[wg_test]
60	#[allow(clippy::cognitive_complexity, dead_code)]
61	async fn test_read_node_comparison<RequestCtx: RequestContext>(mut client: Client<RequestCtx>) {
285	#[wg_test]
286	#[allow(clippy::cognitive_complexity, dead_code)]
287	async fn test_create_node_comparison<RequestCtx: RequestContext>(mut client: Client<RequestCtx>) {
332	#[wg_test]
333	#[allow(clippy::cognitive_complexity, dead_code)]
334	async fn test_update_node_comparison<RequestCtx: RequestContext>(mut client: Client<RequestCtx>) {
385	#[wg_test]
386	#[allow(clippy::cognitive_complexity, dead_code)]
387	async fn test_delete_node_comparison<RequestCtx: RequestContext>(mut client: Client<RequestCtx>) {
398	#[wg_test]
399	#[allow(clippy::cognitive_complexity, dead_code)]
400	async fn test_read_rel_comparison<RequestCtx: RequestContext>(mut client: Client<RequestCtx>) {

wasmer-interface-types 0.17.0/src/decoders/wat.rs

160	impl<'a> Parse<'a> for Instruction {
161	#[allow(clippy::cognitive_complexity)]
162	fn parse(parser: Parser<'a>) -> Result<Self> {

wasmer-interface-types-fl 0.24.1/src/decoders/wat.rs

98	impl<'a> Parse<'a> for Instruction {
99	#[allow(clippy::cognitive_complexity)]
100	fn parse(parser: Parser<'a>) -> Result<Self> {

wasp-core 0.0.0/src/compiler.rs

239	#[allow(clippy::cyclomatic_complexity)]
240	fn process_expression(&mut self, i: usize, e: &Expression) {

webidl 0.9.0/src/lexer/mod.rs

225	#[allow(unknown_lints)]
226	#[allow(clippy::cognitive_complexity)]
227	fn get_next_token(&mut self) -> Option<<Self as Iterator>::Item> {

websocat 1.11.0/src/specparse.rs

63	type Err = Box<dyn (::std::error::Error)>;
64	#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
65	fn from_str(s: &str) -> Result<SpecifierStack> {

weresocool_ast 1.0.43/src/operations/normalize.rs

13	impl Normalize<Term> for Op {
14	#[allow(clippy::cognitive_complexity)]
15	fn apply_to_normal_form(

wing-sqlparser 0.13.1-alpha.0/src/ast/mod.rs

881	// split up without extracting structs for each `Statement` variant.
882	#[allow(clippy::cognitive_complexity)]
883	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

wire4 0.0.2/src/vm.rs

101	#[allow(clippy::cognitive_complexity)]
102	pub fn tick(&mut self) -> Result<Option<VMRequest>, VMError> {

wishbone-tool 0.7.9/crates/core/gdb.rs

305	#[allow(clippy::cognitive_complexity)]
306	fn packet_to_command(&self, raw_pkt: &[u8]) -> Result<GdbCommand, GdbServerError> {
557	#[allow(clippy::cognitive_complexity)]
558	pub fn process(

wlambda 0.8.1/src/compiler.rs

2154	#[allow(clippy::cognitive_complexity)]
2155	pub(crate) fn compile(ast: &VVal, ce: &mut Rc<RefCell<CompileEnv>>)

wlambda 0.8.1/src/ops.rs

655	impl DestructureInfo {
656	#[allow(clippy::cognitive_complexity)]
657	pub fn destructure(&self, env: &mut Env, val: VVal) {

wlambda 0.8.1/src/vm.rs

248	#[allow(clippy::many_single_char_names)]
249	#[allow(clippy::cognitive_complexity)]
250	pub fn vm(prog: &Prog, env: &mut Env) -> Result<VVal, StackAction> {

wlambda 0.8.1/src/vval.rs

2125	#[allow(clippy::cognitive_complexity)]
2126	#[allow(clippy::comparison_chain)]

wsrpc 0.2.1/src/lib.rs

129	#[allow(clippy::cognitive_complexity)]
130	fn client_connected<Ctx: Clone + Send + 'static>(
229	// Wtf, clippy?
230	#[allow(clippy::cognitive_complexity)]
231	fn cancel_response_stream(snd_cancel: oneshot::Sender<()>) {

x11rb-protocol 0.11.1/src/protocol/mod.rs

1303	// Parse a X11 request into a concrete type
1304	#[allow(clippy::cognitive_complexity, clippy::single_match)]
1305	pub fn parse(
8816	/// Parse a generic X11 event into a concrete event type.
8817	#[allow(clippy::cognitive_complexity, clippy::match_single_binding)]
8818	pub fn parse(

xain-fl 0.8.0/src/aggregator/service.rs

198	#[allow(clippy::cognitive_complexity)]
199	fn poll_aggregation(&mut self, cx: &mut Context) {

xi-core-lib 0.3.0/src/backspace.rs

23	#[allow(clippy::cognitive_complexity)]
24	pub fn offset_for_delete_backwards(

xrl 0.0.9/src/frontend.rs

109	#[allow(clippy::cognitive_complexity)]
110	fn handle_notification(&mut self, method: &str, params: Value) -> Self::NotificationFuture {

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

356	/// Handle \E[ <seq2:digit> escape sequences
357	#[allow(clippy::cognitive_complexity)]
358	fn extended_escape(&mut self, seq2: char) -> Result<KeyEvent> {

yew-macro 0.20.0/src/html_tree/html_element.rs

100	impl ToTokens for HtmlElement {
101	#[allow(clippy::cognitive_complexity)]
102	fn to_tokens(&self, tokens: &mut TokenStream) {

ynab-export 0.0.4/src/main.rs

27	#[allow(clippy::cognitive_complexity)]
28	fn main() {

zeerust 0.2.1/src/cpu/opcodes/test.rs

156	#[test]
157	#[allow(clippy::cognitive_complexity)]
158	fn ld_rr() {
378	#[test]
379	#[allow(clippy::cognitive_complexity)]
380	fn get() {
454	#[test]
455	#[allow(clippy::cognitive_complexity)]
456	fn reset() {
530	#[test]
531	#[allow(clippy::cognitive_complexity)]
532	fn set() {

zerocopy 0.7.0-alpha.2/src/lib.rs

3009	#[test]
3010	#[allow(clippy::cognitive_complexity)]
3011	fn test_new_error() {

zkp-stark 0.2.1/src/prover.rs

343	// TODO: Simplify
344	#[allow(clippy::cognitive_complexity)]
345	// TODO: Split up
971	#[allow(non_snake_case)]
972	#[allow(clippy::cognitive_complexity)]
973	#[allow(clippy::too_many_lines)]

zkp-u256 0.2.1/src/arch/generic/lehmer_gcd.rs

77	/// <https://gmplib.org/repo/gmp-6.1/file/tip/mpn/generic/hgcd2.c#l44>
78	#[allow(clippy::cognitive_complexity)]
79	fn div1(mut a: u64, b: u64) -> u64 {
107	// Clippy operates on the unrolled code, giving a false positive.
108	#[allow(clippy::cognitive_complexity)]
109	fn lehmer_unroll(a2: u64, a3: &mut u64, k2: u64, k3: &mut u64) {

alt_serde_derive 1.0.119/src/lib.rs

20	#![allow(
21	clippy::cognitive_complexity,
22	clippy::enum_variant_names,

amadeus 0.4.3/tests/parquet.rs

2	#![allow(
3	clippy::cognitive_complexity,
4	clippy::type_complexity,

amadeus 0.4.3/tests/parquet_dist.rs

1	#![type_length_limit = "2097152"]
2	#![allow(clippy::cognitive_complexity, clippy::type_complexity)]

armv4t_emu 0.1.0/src/lib.rs

29	#![allow(
30	clippy::cognitive_complexity, // instruction decode methods are large
31	clippy::many_single_char_names, // ...it's a CPU, what do you expect?

ash 0.37.2+1.3.238/src/vk.rs

2	clippy::too_many_arguments,
3	clippy::cognitive_complexity,
4	clippy::wrong_self_convention

async-graphql 5.0.5/src/lib.rs

174	#![allow(clippy::redundant_pub_crate)]
175	#![allow(clippy::cognitive_complexity)]
176	#![allow(clippy::useless_let_if_seq)]

async-graphql-derive 5.0.5/src/lib.rs

1	#![allow(clippy::cognitive_complexity)]
2	#![allow(clippy::vec_init_then_push)]

async-std 1.12.0/tests/buf_writer.rs

10	fn test_buffered_writer() {
11	#![allow(clippy::cognitive_complexity)]
12	task::block_on(async {

async-std 1.12.0/tests/channel.rs

56	fn len_empty_full() {
57	#![allow(clippy::cognitive_complexity)]
58	task::block_on(async {

async-tar 0.4.2/tests/header/mod.rs

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

atat_derive 0.18.0/src/lib.rs

33	#![allow(clippy::multiple_crate_versions)]
34	#![allow(clippy::cognitive_complexity)]
35	#![allow(clippy::module_name_repetitions)]

badder_lang 0.1.1/tests/control.rs

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

bitfield 0.14.0/tests/lib.rs

1	#![recursion_limit = "128"]
2	#![allow(clippy::cognitive_complexity)]

Boa 0.13.1/src/lib.rs

35	clippy::missing_inline_in_public_items,
36	clippy::cognitive_complexity,
37	clippy::must_use_candidate,

boa_cli 0.16.0/src/main.rs

53	clippy::missing_inline_in_public_items,
54	clippy::cognitive_complexity,
55	clippy::must_use_candidate,

boa_engine 0.16.0/src/lib.rs

64	clippy::missing_inline_in_public_items,
65	clippy::cognitive_complexity,
66	clippy::must_use_candidate,

boa_interner 0.16.0/src/lib.rs

64	clippy::missing_inline_in_public_items,
65	clippy::cognitive_complexity,
66	clippy::must_use_candidate,

boa_unicode 0.16.0/src/lib.rs

61	clippy::missing_inline_in_public_items,
62	clippy::cognitive_complexity,
63	clippy::must_use_candidate,

broker-tokio 0.2.16/src/lib.rs

2	#![allow(
3	clippy::cognitive_complexity,
4	clippy::large_enum_variant,

bson 2.5.0/src/lib.rs

266	#![allow(clippy::cognitive_complexity, clippy::derive_partial_eq_without_eq)]
267	#![doc(html_root_url = "https://docs.rs/bson/2.5.0")]

bson2 2.0.3/src/lib.rs

266	#![allow(clippy::cognitive_complexity)]
267	#![doc(html_root_url = "https://docs.rs/bson/2.0.1")]

bve 0.0.1/src/lib.rs

18	#![allow(clippy::cast_possible_truncation)] // Annoying
19	#![allow(clippy::cognitive_complexity)] // This is dumb
20	#![allow(clippy::too_many_lines)] // This is also dumb

bve-derive 0.0.1/src/lib.rs

18	#![allow(clippy::cast_sign_loss)] // Annoying
19	#![allow(clippy::cognitive_complexity)] // This is dumb
20	#![allow(clippy::single_match_else)] // Future expansion

bve-native 0.0.1/src/lib.rs

58	#![allow(clippy::cast_possible_truncation)] // Annoying
59	#![allow(clippy::cognitive_complexity)] // This is dumb
60	#![allow(clippy::too_many_lines)] // This is also dumb

cargo-semverver 0.34.0/src/cargo/lib.rs

5

#![allow(clippy::boxed_local)] // bug rust-lang-nursery/rust-clippy#1123

6

#![allow(clippy::cyclomatic_complexity)] // large project

7

#![allow(clippy::derive_hash_xor_eq)] // there's an intentional incoherence

cfgrammar 0.13.1/src/lib/mod.rs

1	#![allow(clippy::cognitive_complexity)]
2	#![allow(clippy::many_single_char_names)]

controlgroup 0.3.0/src/v1/memory.rs

707	// TODO: Remove when https://github.com/rust-lang/rust-clippy/issues/3900 is fixed
708	#![allow(clippy::cognitive_complexity)]

coprosize 1.0.4/src/list.rs

7	#![warn(clippy::nursery, clippy::pedantic)]
8	#![allow(clippy::cognitive_complexity, clippy::missing_panics_doc, clippy::too_many_lines)]

core_arch 0.1.5/src/lib.rs

47	clippy::shadow_reuse,
48	clippy::cognitive_complexity,
49	clippy::similar_names,

coresimd 0.1.2/src/lib.rs

56	shadow_reuse,
57	cyclomatic_complexity,
58	similar_names,

cosmian_crypto_base 2.1.2/src/sodium_bindings.rs

9	clippy::unseparated_literal_suffix,
10	clippy::cognitive_complexity,
11	clippy::upper_case_acronyms

cretonne-codegen 0.13.2/src/lib.rs

22	// Hard to avoid in generated code:
23	cyclomatic_complexity,
24	too_many_arguments,

cxx 1.0.88/src/lib.rs

376	#![allow(
377	clippy::cognitive_complexity,
378	clippy::declare_interior_mutable_const,

cxxbridge-cmd 1.0.88/src/main.rs

2	clippy::cast_sign_loss,
3	clippy::cognitive_complexity,
4	clippy::default_trait_access,

decompress 0.3.0/examples/unpack.rs

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

decompress 0.3.0/examples/unzip.rs

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

derivative 2.2.0/src/lib.rs

7	#![allow(clippy::option_as_ref_deref)] // needs rustc 1.40
8	#![allow(clippy::cyclomatic_complexity)] // old name of cognitive_complexity
9	#![allow(clippy::cognitive_complexity)] // in code generated by macros
10	#![allow(clippy::redundant_closure)]

derivative 2.2.0/tests/derive-ord-packed.rs

1	#![allow(renamed_and_removed_lints)] // clippy::cyclomatic_complexity → clippy::cognitive_complexity
2	#![allow(clippy::cyclomatic_complexity)]
3	#![allow(clippy::cognitive_complexity)]
4	#![allow(clippy::trivially_copy_pass_by_ref)]

derivative 2.2.0/tests/derive-ord.rs

1	#![allow(renamed_and_removed_lints)] // clippy::cyclomatic_complexity → clippy::cognitive_complexity
2	#![allow(clippy::cyclomatic_complexity)]
3	#![allow(clippy::cognitive_complexity)]
4	#![allow(clippy::trivially_copy_pass_by_ref)]

dhcpm 0.2.1/src/main.rs

8	#![deny(broken_intra_doc_links)]
9	#![allow(clippy::cognitive_complexity)]

dhcproto 0.8.0/src/lib.rs

9	)]
10	#![allow(clippy::cognitive_complexity)]
11	#![deny(rustdoc::broken_intra_doc_links)]

dia-args 0.59.4/src/bin/dia-args/main.rs

31	#![allow(clippy::bool_comparison)]
32	#![allow(clippy::cognitive_complexity)]
33	#![allow(clippy::match_bool)]

dia-args 0.59.4/src/lib.rs

105	#![allow(clippy::bool_comparison)]
106	#![allow(clippy::cognitive_complexity)]
107	#![allow(clippy::match_bool)]

dns-stamp-parser 3.0.0/src/lib.rs

11	)]
12	#![allow(clippy::cognitive_complexity)]
13	#![deny(broken_intra_doc_links)]

electrs2 0.9.9/src/config.rs

19	#![allow(unused)]
20	#![allow(clippy::cognitive_complexity)]
21	#![allow(clippy::enum_variant_names)]

encrypted-dns 0.9.12/src/main.rs

2	#![allow(clippy::type_complexity)]
3	#![allow(clippy::cognitive_complexity)]
4	#![allow(clippy::upper_case_acronyms)]

eternal 0.3.2/src/lib.rs

1	#![allow(clippy::cognitive_complexity, warnings)]
2	#![warn(

evebox 0.13.0/src/lib.rs

26	#![allow(clippy::module_inception)]
27	#![allow(clippy::cognitive_complexity)]
28	#![allow(clippy::new_without_default)]

flurry 0.4.0/src/lib.rs

241	#![warn(rust_2018_idioms)]
242	#![allow(clippy::cognitive_complexity)]

genie-scx 4.0.0/src/format.rs

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

gfx_glyph 0.17.0/src/lib.rs

3	clippy::too_many_arguments,
4	clippy::cognitive_complexity,
5	clippy::redundant_closure

git_function_history 0.7.0/src/lib.rs

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

gkquad 0.0.4/src/lib.rs

20	clippy::float_cmp,
21	clippy::cognitive_complexity,
22	clippy::uninit_assumed_init,

gui 0.6.0/tests/test_ui.rs

20	#![allow(
21	clippy::cognitive_complexity,
22	clippy::needless_pass_by_value,

ibuilder 0.1.8/tests/interaction.rs

1	#![allow(clippy::cognitive_complexity)]
2	use ibuilder::*;

informalsystems-prost-build 0.8.1/src/ident.rs

46	#![allow(clippy::cognitive_complexity)]

isla-lib 0.2.0/src/primop.rs

41	#![allow(clippy::comparison_chain)]
42	#![allow(clippy::cognitive_complexity)]

iso 0.0.8/src/lib.rs

10	#![allow(clippy::cognitive_complexity)]
11	#![warn(clippy::cargo_common_metadata)]

iso-macro 0.0.5/src/lib.rs

11	#![allow(clippy::cognitive_complexity)]
12	#![warn(clippy::cargo_common_metadata)]

junitxml2subunit 1.1.0/src/main.rs

18	#![allow(clippy::cargo)]
19	#![allow(clippy::cognitive_complexity)]

kiro-editor 0.4.3/src/lib.rs

8	#![allow(clippy::useless_let_if_seq)]
9	#![allow(clippy::cognitive_complexity)]

libcec-sys 4.0.0/src/lib_abi4.rs

9	clippy::unreadable_literal,
10	clippy::cognitive_complexity
11	)]

libcec-sys 4.0.0/src/lib_abi5.rs

9	clippy::unreadable_literal,
10	clippy::cognitive_complexity
11	)]

libcec-sys 4.0.0/src/lib_abi6.rs

9	clippy::unreadable_literal,
10	clippy::cognitive_complexity
11	)]

libfuse-sys 0.4.0/src/lib.rs

4	#![allow(clippy::useless_transmute)]
5	#![allow(clippy::cognitive_complexity)]
6	#![allow(clippy::missing_safety_doc)]

lngcnv 1.8.3/src/lang.rs

8	#![allow(clippy::needless_borrow)] // &original_text must be borrowed in fn list()
9	#![allow(clippy::cognitive_complexity, clippy::missing_panics_doc, clippy::too_many_lines)]

lodepng 3.7.2/src/rustimpl.rs

12	#![cfg_attr(feature = "cargo-clippy", allow(clippy::too_many_arguments))]
13	#![cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]

lrpar 0.13.1/src/lib/mod.rs

1	#![allow(clippy::cognitive_complexity)]
2	#![allow(clippy::many_single_char_names)]

lrtable 0.13.1/src/lib/mod.rs

1	#![allow(clippy::cognitive_complexity)]
2	#![allow(clippy::too_many_arguments)]

malachite-base 0.3.2/src/lib.rs

94	#![allow(
95	clippy::cognitive_complexity,
96	clippy::float_cmp,

malachite-base 0.3.2/tests/lib.rs

26	clippy::bool_assert_comparison, // Often clearer than using !
27	clippy::cognitive_complexity,
28	clippy::excessive_precision,

malachite-nz 0.3.2/src/lib.rs

110	clippy::assertions_on_constants,
111	clippy::cognitive_complexity,
112	clippy::many_single_char_names,

malachite-nz 0.3.2/tests/lib.rs

4	clippy::assertions_on_constants,
5	clippy::cognitive_complexity,
6	clippy::excessive_precision,

malachite-q 0.3.2/src/lib.rs

62	clippy::assertions_on_constants,
63	clippy::cognitive_complexity,
64	clippy::many_single_char_names,

malachite-q 0.3.2/tests/lib.rs

4	clippy::assertions_on_constants,
5	clippy::cognitive_complexity,
6	clippy::excessive_precision,

minijinja 0.30.2/src/lib.rs

174	//! </details>
175	#![allow(clippy::cognitive_complexity)]
176	#![allow(clippy::get_first)]

mm0_util 0.1.4/src/lib.rs

36	#![allow(
37	clippy::cognitive_complexity,
38	clippy::comparison_chain,

mm0b_parser 0.1.4/src/lib.rs

36	#![allow(
37	clippy::cognitive_complexity,
38	clippy::comparison_chain,

mpi 0.6.0/examples/cartesian.rs

1	#![deny(warnings)]
2	#![allow(clippy::cognitive_complexity)]
3	extern crate mpi;

mpi-fork-fnsp 0.6.0/examples/cartesian.rs

1	#![deny(warnings)]
2	#![allow(clippy::cognitive_complexity)]
3	extern crate mpi_fork_fnsp as mpi;

mprocs-vt100 0.1.1/src/lib.rs

40	#![warn(clippy::get_unwrap)]
41	#![allow(clippy::cognitive_complexity)]
42	#![allow(clippy::missing_const_for_fn)]

mpstthree 0.1.16/src/lib.rs

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

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

11	non_snake_case,
12	clippy::cognitive_complexity,
13	clippy::empty_enum,

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

11	non_snake_case,
12	clippy::cognitive_complexity,
13	clippy::empty_enum,

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

11	non_snake_case,
12	clippy::cognitive_complexity,
13	clippy::too_many_lines,

ntex-prost-build 0.11.5/src/ident.rs

46	#![allow(clippy::cognitive_complexity)]

nucleob 1.1.1/src/stat/amino_acids.rs

7

#![warn(clippy::nursery, clippy::pedantic)]

8

#![allow(clippy::cast_precision_loss, clippy::cognitive_complexity, clippy::missing_panics_doc, clippy::similar_names, clippy::too_many_lines, clippy::uninlined_format_args)]

nucleob 1.1.1/src/stat/nucleobases.rs

7

#![warn(clippy::nursery, clippy::pedantic)]

8

#![allow(clippy::cast_precision_loss, clippy::cognitive_complexity, clippy::missing_panics_doc, clippy::similar_names, clippy::too_many_lines, clippy::uninlined_format_args)]

openidconnect 3.0.0-alpha.1/tests/rp_certification_dynamic.rs

1	#![allow(clippy::cognitive_complexity)]
2	extern crate env_logger;

openidconnect 3.0.0-alpha.1/tests/rp_common/mod.rs

1	#![allow(clippy::cognitive_complexity, clippy::expect_fun_call)]
2	extern crate color_backtrace;

openshift-openapi 0.3.1/src/lib.rs

3	#![allow(
4	clippy::cognitive_complexity,
5	clippy::default_trait_access,

orthanc-plugin-bindings 0.1.1/src/bindgen.rs

6	#![allow(clippy::unreadable_literal)]
7	#![allow(clippy::cognitive_complexity)]
8	#![allow(clippy::useless_transmute)]

over 0.6.5/src/tests.rs

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

over 0.6.5/tests/errors.rs

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

over 0.6.5/tests/integration.rs

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

oxipng 8.0.0/src/lib.rs

13	#![warn(clippy::range_plus_one)]
14	#![allow(clippy::cognitive_complexity)]
15	#![allow(clippy::upper_case_acronyms)]

oxipng 8.0.0/src/main.rs

13	#![warn(clippy::range_plus_one)]
14	#![allow(clippy::cognitive_complexity)]

path-dsl 0.6.1/src/lib.rs

267	#![allow(clippy::cognitive_complexity)]
268	#![allow(clippy::float_cmp)]

piper 0.1.3/tests/chan.rs

45	fn len_empty_full() {
46	#![allow(clippy::cognitive_complexity)]
47	task::block_on(async {

pleco_engine 0.1.6/src/lib.rs

16	#![allow(clippy::mut_from_ref)]
17	#![allow(clippy::cognitive_complexity)]

project_init 3.1.23/src/lib.rs

4	#![allow(clippy::too_many_arguments)]
5	#![allow(clippy::cognitive_complexity)]

prost-build 0.11.6/src/ident.rs

46	#![allow(clippy::cognitive_complexity)]

prost-msg-build 0.1.6/src/ident.rs

46	#![allow(clippy::cognitive_complexity)]

pty-process 0.2.0/src/lib.rs

52	#![warn(clippy::get_unwrap)]
53	#![allow(clippy::cognitive_complexity)]
54	#![allow(clippy::missing_const_for_fn)]

quinn-proto 0.9.2/src/lib.rs

17	// Fixes welcome:
18	#![allow(clippy::cognitive_complexity)]
19	#![allow(clippy::too_many_arguments)]

racc 0.0.3/src/lib.rs

230	#![allow(clippy::needless_lifetimes)]
231	#![allow(clippy::cognitive_complexity)]

ranged_integers 0.7.0/src/tests.rs

1	#![allow(clippy::missing_const_for_fn)]
2	#![allow(clippy::cognitive_complexity)]

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

12	#![allow(clippy::cast_ptr_alignment)]
13	#![allow(clippy::cognitive_complexity)]
14	#![allow(clippy::needless_range_loop)]

rav1e 0.6.3/src/bin/rav1e.rs

12	#![allow(clippy::cast_ptr_alignment)]
13	#![allow(clippy::cognitive_complexity)]
14	#![allow(clippy::needless_range_loop)]

rav1e 0.6.3/src/lib.rs

39	#![allow(clippy::cast_ptr_alignment)]
40	#![allow(clippy::cognitive_complexity)]
41	#![allow(clippy::needless_range_loop)]

rbson 2.0.5/src/lib.rs

266	#![allow(clippy::cognitive_complexity)]
267	#![doc(html_root_url = "https://docs.rs/bson/2.0.1")]

rbw 1.4.3/src/bin/rbw/main.rs

5	#![warn(clippy::get_unwrap)]
6	#![allow(clippy::cognitive_complexity)]
7	#![allow(clippy::missing_const_for_fn)]

rbw 1.4.3/src/bin/rbw-agent/main.rs

5	#![warn(clippy::get_unwrap)]
6	#![allow(clippy::cognitive_complexity)]
7	#![allow(clippy::missing_const_for_fn)]

rbw 1.4.3/src/lib.rs

5	#![warn(clippy::get_unwrap)]
6	#![allow(clippy::cognitive_complexity)]
7	#![allow(clippy::missing_const_for_fn)]

retry_fn 0.2.0/src/lib.rs

39	)]
40	#![allow(clippy::cognitive_complexity)]
41	#![deny(broken_intra_doc_links)]

rincon_client 0.1.1/tests/cursor_methods.rs

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

rincon_client 0.1.1/tests/index_methods.rs

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

rink-core 0.6.2/src/lib.rs

32	// False positives, or make code harder to understand.
33	#![allow(clippy::cognitive_complexity)]
34	#![allow(clippy::match_like_matches_macro)]

ritual_common 0.4.0/src/lib.rs

6	#![forbid(unsafe_code)]
7	#![allow(clippy::cognitive_complexity)]

root-io 0.3.0/src/lib.rs

15	//! parser chances have it that it exists but it is not marked as `pub`.
16	#![allow(clippy::cognitive_complexity)]
17	#![recursion_limit = "256"]

rusttype 0.9.3/src/lib.rs

90	#![allow(
91	clippy::cognitive_complexity,
92	clippy::doc_markdown,

rvsim 0.2.2/src/cpu/mod.rs

1	#![allow(clippy::cast_lossless, clippy::cognitive_complexity, clippy::new_without_default)]

rx-editor 0.3.0/src/lib.rs

7	clippy::new_without_default,
8	clippy::cognitive_complexity,
9	clippy::type_complexity,

ryu-ecmascript 0.1.1/src/lib.rs

37	cast_lossless,
38	cyclomatic_complexity,
39	many_single_char_names,

safe_core 0.43.1/src/client/mock/tests.rs

9	// FIXME: consider splitting test functions into multiple smaller ones
10	#![allow(clippy::cognitive_complexity)]
11	#![allow(unused_imports)] // Remove this after fixing all the tests

saltwater 0.11.0/src/lib.rs

1	#![allow(clippy::cognitive_complexity)]
2	#![warn(absolute_paths_not_starting_with_crate)]

serde_derive 1.0.152/src/lib.rs

21	clippy::branches_sharing_code,
22	clippy::cognitive_complexity,
23	// clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575

serde_derive_internals 0.26.0/lib.rs

5	#![allow(
6	clippy::cognitive_complexity,
7	// clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797

serde_derive_state 0.4.10/src/lib.rs

20	#![allow(
21	clippy::cognitive_complexity,
22	clippy::enum_variant_names,

serde_pipe 0.1.3/src/lib.rs

61	#![allow(
62	clippy::cognitive_complexity,
63	clippy::let_unit_value,

simd-json 0.7.0/src/value/borrowed.rs

438	mod test {
439	#![allow(clippy::cognitive_complexity)]
440	use super::*;

simd-json 0.7.0/src/value/owned.rs

377	mod test {
378	#![allow(clippy::cognitive_complexity)]
379	use super::*;

simd-json 0.7.0/src/value/tape.rs

26	mod test {
27	#![allow(clippy::cognitive_complexity)]
28	use super::StaticNode as Value;

simple-soft-float 0.1.0/src/lib.rs

553	) -> TernaryNaNPropagationResults {
554	#![allow(clippy::cognitive_complexity)]
555	use TernaryNaNPropagationMode::*;
4246	mod tests {
4247	#![allow(clippy::cognitive_complexity)]
4248	use super::*;

sleef 0.3.0/src/lib.rs

8	#![allow(clippy::float_cmp)]
9	#![allow(clippy::cognitive_complexity)]
10	#![allow(clippy::wrong_self_convention)]

smallbigint 1.1.0/src/lib.rs

1606	mod test {
1607	#![allow(clippy::redundant_clone, clippy::cognitive_complexity, clippy::op_ref)]

snare 0.4.5/src/jobrunner.rs

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

structural 0.4.3/src/tests.rs

7	// Long tests are all composed of independent statements.
8	#![allow(clippy::cognitive_complexity)]

syn-impersonated 0.1.18/src/lib.rs

249	clippy::block_in_if_condition_stmt,
250	clippy::cognitive_complexity,
251	clippy::doc_markdown,

syn-next 1.0.0-rc4/src/lib.rs

249	clippy::block_in_if_condition_stmt,
250	clippy::cognitive_complexity,
251	clippy::doc_markdown,

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

232	block_in_if_condition_stmt,
233	cognitive_complexity,
234	cyclomatic_complexity,
235	const_static_lifetime,

tallystick 0.4.3/src/lib.rs

10	#![warn(missing_docs)]
11	#![allow(clippy::redundant_field_names, clippy::cognitive_complexity)]
12	#![cfg_attr(feature = "nightly", allow(incomplete_features))]

tanton_engine 1.0.0/src/lib.rs

15	#![allow(clippy::mut_from_ref)]
16	#![allow(clippy::cognitive_complexity)]

textmode 0.3.0/src/lib.rs

70	#![warn(clippy::get_unwrap)]
71	#![allow(clippy::cognitive_complexity)]
72	#![allow(clippy::missing_const_for_fn)]

threshold_crypto 0.4.0/src/mock/ms8.rs

431	// Some test functions contain long lists of assertions. Clippy thinks they are too complex.
432	#![allow(clippy::cognitive_complexity)]

time 0.3.17/src/tests.rs

18	clippy::clone_on_copy,
19	clippy::cognitive_complexity,
20	clippy::std_instead_of_core

tokio 1.25.0/src/lib.rs

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

tokio 1.25.0/tests/sync_broadcast.rs

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

tokio 1.25.0/tests/sync_watch.rs

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

tokio-async-std 1.5.3/tests/buf_writer.rs

6	fn test_buffered_writer() {
7	#![allow(clippy::cognitive_complexity)]
8	task::block_on(async {

tokio-async-std 1.5.3/tests/channel.rs

47	fn len_empty_full() {
48	#![allow(clippy::cognitive_complexity)]
49	task::block_on(async {

tokio-stream 0.1.11/src/lib.rs

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

tokio-tar 0.3.0/tests/header/mod.rs

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

tokio_wasi 1.23.0/src/lib.rs

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

tokio_wasi 1.23.0/tests/sync_broadcast.rs

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

tokio_wasi 1.23.0/tests/sync_watch.rs

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

topgrade 10.3.1/src/main.rs

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

topgrade-rs 10.0.1/src/main.rs

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

tor-bytes 0.6.0/src/reader.rs

339	#![allow(clippy::unwrap_used)]
340	#![allow(clippy::cognitive_complexity)]
341	use super::*;

tor-dirmgr 0.9.0/src/state.rs

1238	#![allow(clippy::unwrap_used)]
1239	#![allow(clippy::cognitive_complexity)]
1240	use super::*;

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

154	fn basic_usage() {
155	#![allow(clippy::cognitive_complexity)]
156	let rsa1 = RsaIdentity::from(hex!("42656c6f7665642c207768617420617265206e61"));

tor-netdir 0.7.0/src/lib.rs

1215	#![allow(clippy::unwrap_used)]
1216	#![allow(clippy::cognitive_complexity)]
1217	use super::*;

tor-netdoc 0.6.0/src/parse/macros.rs

104	pub(crate) mod test {
105	#![allow(clippy::cognitive_complexity)]

tor-netdoc 0.6.0/src/parse/tokenize.rs

683	#![allow(clippy::unwrap_used)]
684	#![allow(clippy::cognitive_complexity)]
685	use super::*;

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

627	mod test {
628	#![allow(clippy::cognitive_complexity)]
629	use super::*;

ttyrec 0.3.3/src/lib.rs

18	#![warn(clippy::get_unwrap)]
19	#![allow(clippy::cognitive_complexity)]
20	#![allow(clippy::missing_const_for_fn)]

ttyrec-bin 0.1.3/src/bin/ttyplay/main.rs

5	#![warn(clippy::get_unwrap)]
6	#![allow(clippy::cognitive_complexity)]
7	#![allow(clippy::missing_const_for_fn)]

ttyrec-bin 0.1.3/src/bin/ttyrec/main.rs

5	#![warn(clippy::get_unwrap)]
6	#![allow(clippy::cognitive_complexity)]
7	#![allow(clippy::missing_const_for_fn)]

tulip-derivative 2.2.1/src/lib.rs

6	#![allow(clippy::option_as_ref_deref)] // needs rustc 1.40
7	#![allow(clippy::cyclomatic_complexity)] // old name of cognitive_complexity
8	#![allow(clippy::cognitive_complexity)] // in code generated by macros
9	#![allow(clippy::redundant_closure)]

tulip-derivative 2.2.1/tests/derive-ord-packed.rs

1	#![allow(renamed_and_removed_lints)] // clippy::cyclomatic_complexity → clippy::cognitive_complexity
2	#![allow(clippy::cyclomatic_complexity)]
3	#![allow(clippy::cognitive_complexity)]
4	#![allow(clippy::trivially_copy_pass_by_ref)]

tulip-derivative 2.2.1/tests/derive-ord.rs

1	#![allow(renamed_and_removed_lints)] // clippy::cyclomatic_complexity → clippy::cognitive_complexity
2	#![allow(clippy::cyclomatic_complexity)]
3	#![allow(clippy::cognitive_complexity)]
4	#![allow(clippy::trivially_copy_pass_by_ref)]

twilio-async 0.5.0/src/lib.rs

3	#![allow(
4	clippy::cognitive_complexity,
5	clippy::large_enum_variant,

umpire 0.4.0/src/bin/umpire.rs

5	#![allow(clippy::cognitive_complexity)]
6	#![allow(clippy::let_and_return)]

umpire 0.4.0/src/lib.rs

1	#![allow(clippy::cognitive_complexity)]
2	#![allow(clippy::let_and_return)]

umpl 1.1.0/src/lib.rs

9	clippy::cast_sign_loss,
10	clippy::cognitive_complexity,
11	clippy::float_cmp,

v_frame 0.3.3/src/lib.rs

12	#![allow(clippy::cast_ptr_alignment)]
13	#![allow(clippy::cognitive_complexity)]
14	#![allow(clippy::needless_range_loop)]

vemigrate-cli 0.3.1/src/main.rs

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

vkcargo 0.45.1/src/cargo/lib.rs

5	#![allow(clippy::blacklisted_name)] // frequently used in tests
6	#![allow(clippy::cognitive_complexity)] // large project
7	#![allow(clippy::derive_hash_xor_eq)] // there's an intentional incoherence

vt100 0.15.1/src/lib.rs

40	#![warn(clippy::get_unwrap)]
41	#![allow(clippy::cognitive_complexity)]
42	#![allow(clippy::missing_const_for_fn)]

vtkio 0.6.3/src/parser.rs

2	// caused by macros.
3	#![allow(clippy::cognitive_complexity)]

wain-syntax-text 0.2.0/src/lib.rs

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

wasmer-wasi 3.2.0-alpha.1/src/state/mod.rs

16	#![allow(clippy::cognitive_complexity, clippy::too_many_arguments)]

wasmer-wasi 3.2.0-alpha.1/src/syscalls/mod.rs

1	#![allow(unused, clippy::too_many_arguments, clippy::cognitive_complexity)]

wasmer-wasi-asml-fork 2.0.0/src/state/mod.rs

16	#![allow(clippy::cognitive_complexity, clippy::too_many_arguments)]

wasmer-wasi-asml-fork 2.0.0/src/syscalls/mod.rs

1	#![allow(unused, clippy::too_many_arguments, clippy::cognitive_complexity)]

wasmer-wasi-near 1.0.1/src/state/mod.rs

16	#![allow(clippy::cognitive_complexity, clippy::too_many_arguments)]

wasmer-wasi-near 1.0.1/src/syscalls/mod.rs

1	#![allow(unused, clippy::too_many_arguments, clippy::cognitive_complexity)]

watt 0.4.2/runtime/src/lib.rs

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

watt-non-static-runtime 0.4.0/runtime/src/lib.rs

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

weld 0.4.0/src/lib.rs

117	#![cfg_attr(not(test), allow(dead_code))]
118	#![allow(clippy::cognitive_complexity)]
119	#![allow(clippy::too_many_arguments)]

win_etw_macros 0.1.3/src/lib.rs

185	#![allow(clippy::too_many_arguments)]
186	#![allow(clippy::cognitive_complexity)]
187	#![allow(clippy::single_match)]

yarte_hir 0.15.6/src/visit_each.rs

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

yarte_html 0.15.2/src/tokenizer/mod.rs

9	//! The HTML5 tokenizer.
10	#![allow(clippy::never_loop, clippy::cognitive_complexity, clippy::single_match)]
11	#![allow(clippy::unnested_or_patterns)]

yarte_html 0.15.2/src/tree_builder/mod.rs

22	#![allow(
23	clippy::cognitive_complexity,
24	clippy::redundant_static_lifetimes,

yarte_parser 0.15.2/src/lib.rs

1	#![allow(clippy::many_single_char_names, clippy::cognitive_complexity)]
2	use std::ops::{Deref, DerefMut};

youtube-dl-repl 1.0.1/src/repl.rs

7	#![warn(clippy::nursery, clippy::pedantic)]
8	#![allow(clippy::cognitive_complexity, clippy::missing_panics_doc, clippy::similar_names, clippy::too_many_lines)]

zone-detect 1.0.0/src/gen.rs

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