actionable 0.2.0/src/tests.rs

330	#[tokio::test]
331	#[allow(clippy::too_many_lines)]
332	async fn example() {

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

95	#[allow(clippy::too_many_lines)]
96	fn clap_app() -> clap::Command {

aftermath 1.1.3/src/differentiation.rs

65	#[allow(clippy::too_many_lines)]
66	fn differentiate_inner<'arena>(

aftermath 1.1.3/src/reduce.rs

29	impl Reduce for crate::Context {
30	#[allow(clippy::too_many_lines)]
31	fn reduce(&self, expr: &'_ mut crate::Expr<'_>) -> Result<(), crate::CalcError> {

agui_core 0.3.0/src/ui/mod.rs

184	/// changes that occured during the process, in order.
185	#[allow(clippy::too_many_lines)]
186	pub fn update(&mut self, events: &mut Vec<WidgetEvent>) {

alloc-compose 0.5.0/src/affix.rs

434	#[allow(clippy::too_many_lines)]
435	fn test_alloc<Prefix, Suffix>(

alloc-compose 0.5.0/src/stats.rs

665	#[allow(clippy::too_many_lines)]
666	fn run_suite(callbacks: &impl CallbackRef) {

allow-me 0.1.1/src/core/builder.rs

588	#[test]
589	#[allow(clippy::too_many_lines)]
590	fn grouping_rules_with_variables_test() {

alog 0.7.2/src/main.rs

5	#[allow(clippy::too_many_lines)]
6	fn main() {

ansirs 0.1.7/src/color/color.rs

110	/// Converts an ANSI-256 color number to an rgb [`Color`].
111	#[allow(clippy::match_same_arms, clippy::too_many_lines)]
112	#[must_use]

ansirs 0.1.7/src/color/colors.rs

305	#[allow(clippy::too_many_lines)]
306	impl Colors {
1212	#[allow(clippy::too_many_lines)]
1213	#[cfg(test)]

arangoq 0.3.4/src/arango_test.rs

121	#[allow(clippy::too_many_lines)]
122	#[allow(clippy::similar_names)]

asuran 0.1.6/src/repository/backend/common/generic_flatfile.rs

124	/// - If an already initalized repository does not contain any footers
125	#[allow(clippy::too_many_lines)]
126	pub fn new_raw(

asuran 0.1.6/src/repository/backend/sftp/manifest.rs

36	/// the given settings at the given server
37	#[allow(clippy::too_many_lines)]
38	#[allow(clippy::filter_map)]

asyncgit 0.22.1/src/sync/diff.rs

254	//TODO: refactor into helper type with the inline closures as dedicated functions
255	#[allow(clippy::too_many_lines)]
256	fn raw_diff_to_file_diff<'a>(

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

499	#[allow(clippy::too_many_lines)]
500	#[must_use]

av1-grain 0.2.2/src/parse.rs

212	#[allow(clippy::too_many_lines)]
213	fn p_params(input: &str) -> IResult<&str, PParams> {

bevy_particle_systems 0.7.1/src/systems.rs

33	clippy::type_complexity,
34	clippy::too_many_lines
35	)]

bevy_prototype_lyon 0.7.2/src/render/mod.rs

56	// `Mesh2dPipeline`
57	#[allow(clippy::too_many_lines)]
58	impl SpecializedRenderPipeline for ShapePipeline {

bevy_prototype_lyon 0.7.2/src/shapes.rs

292	impl Geometry for SvgPathShape {
293	#[allow(clippy::too_many_lines)]
294	fn add_geometry(&self, b: &mut Builder) {

bmart 0.2.4/src/process.rs

206	#[allow(clippy::too_many_lines)]
207	#[allow(clippy::missing_panics_doc)]

bndl 0.1.3/src/aws.rs

30	/// TODO: error docs
31	#[allow(clippy::too_many_lines)] // TODO
32	pub async fn upload(
163	/// TODO: error docs
164	#[allow(clippy::too_many_lines)] // TODO
165	pub async fn download(s3_client: &S3, bucket: String, key: String) -> Result<impl AsyncBufRead + '_, io::Error> {

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

bonsaidb-local 0.4.1/src/views/integrity_scanner.rs

45	#[cfg_attr(feature = "tracing", tracing::instrument)]
46	#[allow(clippy::too_many_lines)]
47	fn execute(&mut self) -> Result<Self::Output, Self::Error> {

bonsaidb-local 0.4.1/src/views/mapper.rs

49	#[cfg_attr(feature = "tracing", tracing::instrument)]
50	#[allow(clippy::too_many_lines)]
51	fn execute(&mut self) -> Result<Self::Output, Error> {

bpaf 0.7.7/src/complete_gen.rs

408	impl Complete {
409	#[allow(clippy::too_many_lines)]
410	fn complete(

bpaf_derive 0.3.3/src/field/named_field.rs

108	#[allow(clippy::too_many_lines)]
109	pub fn make(ty: Type, name: Option<Ident>, attrs: Vec<Attribute>) -> Result<Self> {

bpaf_derive 0.3.3/src/top.rs

319	impl Parse for Top {
320	#[allow(clippy::too_many_lines)]
321	fn parse(input: parse::ParseStream) -> Result<Self> {

bracket-color 0.8.7/src/palette.rs

67	#[allow(clippy::module_name_repetitions)]
68	#[allow(clippy::too_many_lines)]
69	pub fn add_named_colors_to_palette() {

brainfuck-exe 0.1.7/src/lib.rs

397	///
398	#[allow(clippy::too_many_lines)]
399	pub fn execute(&mut self) -> Result<Vec<u32>> {

brood 0.5.0/src/archetype/impl_serde.rs

362	#[allow(clippy::too_many_lines)] // This is fine for a Deserialize impl.
363	fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
701	{
702	#[allow(clippy::too_many_lines)]
703	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

busrt 0.3.6/src/broker.rs

1402	}
1403	#[allow(clippy::too_many_lines)]
1404	async fn handle_peer<R, W>(params: PeerHandlerParams<R, W>) -> Result<(), Error>
1532	// TODO send ack only after the client received message (QoS2)
1533	#[allow(clippy::too_many_lines)]
1534	async fn handle_reader<R>(

busrt 0.3.6/src/cli.rs

541	#[allow(clippy::too_many_lines)]
542	#[tokio::main(worker_threads = 1)]

busrt 0.3.6/src/rpc.rs

319	#[allow(clippy::too_many_lines)]
320	async fn processor<C, H>(

busrt 0.3.6/src/server.rs

168	#[allow(clippy::too_many_lines)]
169	fn main() {

cameleon-device 0.1.8/src/pixel_format.rs

817	#[allow(clippy::too_many_lines)]
818	fn try_from(value: u32) -> Result<Self, Self::Error> {
1091	impl From<PixelFormat> for u32 {
1092	#[allow(clippy::too_many_lines)]
1093	fn from(val: PixelFormat) -> u32 {

cameleon-genapi 0.1.8/src/parser/mod.rs

90	impl Parse for Vec<NodeData> {
91	#[allow(clippy::too_many_lines)]
92	fn parse(

cameleon-genapi 0.1.8/src/parser/register_description.rs

72	#[test]
73	#[allow(clippy::too_many_lines)]
74	fn test_register_description() {

cargo-cache 0.8.3/src/cli.rs

201	/// generates the clap config which is used to control the crate
202	#[allow(clippy::too_many_lines)]
203	pub(crate) fn gen_clap() -> ArgMatches {

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

135	#[allow(clippy::too_many_lines)]
136	#[doc(hidden)]

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

133	#[allow(clippy::too_many_lines)]
134	fn main() -> anyhow::Result<()> {

cargo-trim 0.10.1/src/command/git.rs

66	impl Git {
67	#[allow(clippy::too_many_lines)]
68	pub(super) fn run(

cargo-trim 0.10.1/src/command/mod.rs

169	impl Command {
170	#[allow(clippy::too_many_lines)]
171	pub(crate) fn run(&self) -> Result<()> {

cargo-trim 0.10.1/src/command/registry.rs

67	impl Registry {
68	#[allow(clippy::too_many_lines)]
69	pub(super) fn run(

cetkaik_compact_representation 1.5.0/src/tests.rs

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

cetkaik_naive_representation 1.3.0/src/absolute.rs

532	#[must_use]
533	#[allow(clippy::too_many_lines)]
534	pub fn yhuap_initial_board() -> Board {

cetkaik_naive_representation 1.3.0/src/relative.rs

254	#[must_use]
255	#[allow(clippy::too_many_lines)]
256	pub const fn yhuap_initial_board_where_black_king_points_upward() -> Board {

changepoint 0.12.2/src/gp/mod.rs

228	#[allow(clippy::too_many_lines)]
229	fn step(&mut self, value: &f64) -> &[f64] {

charcoal 1.1.0/src/traversal/algorithms/recursive_removal.rs

105	clippy::shadow_unrelated, // It's not "unrelated" smh
106	clippy::too_many_lines, // I know how to count, thank you very much
107	)]

checksec 0.0.9/src/main.rs

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

chess-huffman 0.1.0/src/codes.rs

6	// https://github.com/lichess-org/compression/blob/master/src/main/java/game/Huffman.java#L64
7	#[allow(clippy::too_many_lines)]
8	pub fn code_from_lichess_weights() -> (Book<u8>, Tree<u8>) {

ckc-rs 0.1.13/src/hand_rank.rs

46	#[must_use]
47	#[allow(clippy::too_many_lines)]
48	pub fn determine_class(hrv: &HandRankValue) -> HandRankClass {

cli-batteries 0.4.1/src/trace/otlp_format.rs

38	{
39	#[allow(clippy::too_many_lines)]
40	fn format_event(

clia-time 0.3.10/src/format_description/modifier.rs

386	/// Parse the modifiers of a given component.
387	#[allow(clippy::too_many_lines)]
388	pub(crate) fn parse(

cloth_bumpmap 0.1.6/src/lib.rs

7	#[test]
8	#[allow(clippy::too_many_lines)]
9	fn it_works() {

const_sort_rs 0.3.3/src/lib.rs

82	clippy::unnecessary_mut_passed,
83	clippy::too_many_lines,
84	clippy::doc_markdown,

const-type-layout-derive 0.1.0/src/lib.rs

106	#[allow(clippy::too_many_lines)]
107	fn parse_attributes(
740	#[allow(clippy::too_many_lines)]
741	fn uninit_for_type(

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

85	#[allow(clippy::too_many_lines)]
86	pub fn write(&mut self, event: &DeployOutputEvent) {

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

108	#[allow(clippy::too_many_lines)]
109	pub fn run<

constellation-rs 0.2.0-alpha.2/src/lib.rs

489	#[allow(clippy::too_many_lines)]
490	#[serde_closure::desugar]
903	#[allow(clippy::too_many_lines)]
904	fn monitor_process(
1170	/// The `resources` argument describes memory and CPU requirements for the initial process.
1171	#[allow(clippy::too_many_lines)]
1172	pub fn init(resources: Resources) {

constellation-rs 0.2.0-alpha.2/tests/tester/main.rs

220	#[allow(clippy::too_many_lines)]
221	fn main() {

cortex-m-rtic-macros 1.1.5/src/codegen/module.rs

6	#[allow(clippy::too_many_lines)]
7	pub fn codegen(

cortex-m-rtic-macros 1.1.5/src/codegen/timer_queue.rs

7	/// Generates timer queues and timer queue handlers
8	#[allow(clippy::too_many_lines)]
9	pub fn codegen(app: &App, analysis: &Analysis, _extra: &Extra) -> Vec<TokenStream2> {

cortex-m-rtic-macros 1.1.5/src/codegen.rs

23	#[allow(clippy::too_many_lines)]
24	pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {

cpclib-disc 0.6.0/src/bin/dsk_manager.rs

30	// Still everything to do
31	#[allow(clippy::too_many_lines)]
32	fn main() -> Result<(), DskManagerError> {

cpz 1.1.3/benches/copy_methods.rs

233	#[allow(clippy::too_many_lines)]
234	fn add_benches(group: &mut BenchmarkGroup<WallTime>, num_bytes: u64, direct_io: bool) {

cucumber 0.19.1/src/runner/basic.rs

1092	/// [`Scenario`]: gherkin::Scenario
1093	#[allow(clippy::too_many_lines)]
1094	async fn run_scenario(

d3_delaunay_rs 0.1.1/src/voronoi.rs

105	#[allow(clippy::similar_names)]
106	#[allow(clippy::too_many_lines)]
107	fn init(&mut self) {

d3_geo_rs 0.1.5/src/clip/circle/line.rs

262	#[allow(clippy::too_many_lines)]
263	fn point(&mut self, p: &Coord<T>, _m: Option<u8>) {

d3_geo_rs 0.1.5/src/clip/rejoin/mod.rs

34	/// to no more than the boundary of the cutting polygon.
35	#[allow(clippy::too_many_lines)]
36	pub fn rejoin<CI, EP, INTERPOLATOR, SINK, T>(

dabus 0.5.0/src/bus/mod.rs

158

    /// the type-erased function that actually runs an event

159

    #[allow(clippy::too_many_lines)]// deal

160

    async fn raw_fire(&mut self, def: TypeId, args: DynVar, mut trace: CallTrace) -> (Option<DynVar>, CallTrace) {

dactyl 0.4.7/src/traits/btou.rs

234	#[allow(clippy::cognitive_complexity)] // Manual indexing wins.
235	#[allow(clippy::too_many_lines)] // Agreed! These numbers are fucking huge!
236	#[must_use]

daml-lf 0.2.2/src/convert/archive_converter.rs

131	/// Convert from `DamlDataWrapper` to `DamlData`.
132	#[allow(clippy::too_many_lines)]
133	impl<'a> TryFrom<DamlDataWrapper<'a>> for DamlData<'a> {

daml-lf 0.2.2/src/convert/expr_converter.rs

93	impl<'a> From<&DamlBuiltinFunctionPayload> for DamlBuiltinFunction {
94	#[allow(clippy::too_many_lines)]
95	fn from(builtin: &DamlBuiltinFunctionPayload) -> Self {

daml-lf 0.2.2/src/convert/expr_payload.rs

1092	#[allow(clippy::too_many_lines)]
1093	fn try_from(builtin_function: &i32) -> DamlLfConvertResult<Self> {

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

1076	#[target_feature(enable = "avx2")]
1077	#[allow(clippy::too_many_lines)]
1078	unsafe fn bgr_to_rgb_avx2(

deca 0.0.10/tests/integration_tests.rs

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

den 0.3.0/src/lib.rs

815	/// `data`.
816	#[allow(clippy::too_many_lines)] // well, this is the main implementation
817	pub fn diff(&self, data: &[u8]) -> Difference {
1226	/// Returns [`MinifyError::Zero`] if `block_size == 0`.
1227	#[allow(clippy::too_many_lines)]
1228	pub fn minify_with_builder(

dev_bestia_html_templating 0.1.41/src/trait_utils_mod.rs

258	// and sub-nodes(Element, Text, Comment).
259	#[allow(clippy::too_many_lines, clippy::type_complexity)]
260	fn fill_element_node<T: HtmlTemplatingDataTrait>(

dexios 8.8.1/src/cli.rs

7	// it returns the ArgMatches so that a match statement can send everything to the correct place
8	#[allow(clippy::too_many_lines)]
9	pub fn get_matches() -> clap::ArgMatches {

dexios-core 1.2.0/src/header.rs

251	///
252	#[allow(clippy::too_many_lines)]
253	pub fn deserialize(reader: &mut (impl Read + Seek)) -> Result<(Self, Vec<u8>)> {

dfraw_json_parser 0.12.0/src/parser/inits/announcements.rs

62	#[allow(clippy::too_many_lines)]
63	pub fn parse<P: AsRef<Path>>(announcements_txt_path: &P) -> Vec<DFAnnouncement> {

dfraw_json_parser 0.12.0/src/parser/raws/creature/parse.rs

19	impl super::DFCreature {
20	#[allow(clippy::too_many_lines)]
21	pub fn parse_raw_file<P: AsRef<Path>>(

dfraw_json_parser 0.12.0/src/parser/raws/graphics/parse.rs

11	impl super::DFGraphic {
12	#[allow(clippy::too_many_lines)]
13	pub fn parse<P: AsRef<Path>>(

dfraw_json_parser 0.12.0/src/parser/raws/graphics/sprite_graphic.rs

76	}
77	#[allow(clippy::too_many_lines)]
78	pub fn parse_creature(token: &str) -> Option<Self> {

dfraw_json_parser 0.12.0/src/parser/raws/info_txt/parse.rs

11	impl super::DFInfoFile {
12	#[allow(clippy::too_many_lines)]
13	pub fn parse<P: AsRef<Path>>(info_file_path: &P) -> info_txt::DFInfoFile {

dfraw_json_parser 0.12.0/src/parser/raws/inorganic/parse.rs

13	impl super::DFInorganic {
14	#[allow(clippy::too_many_lines)]
15	pub fn parse<P: AsRef<Path>>(

dfraw_json_parser 0.12.0/src/parser/raws/material.rs

85	}
86	#[allow(clippy::too_many_lines)]
87	fn complete_initialization_from_template(&mut self, template: &str) {

dfraw_json_parser 0.12.0/src/parser/raws/plant/parse.rs

11	impl super::DFPlant {
12	#[allow(clippy::too_many_lines)]
13	pub fn parse_raw_file<P: AsRef<Path>>(

dfraw_json_parser 0.12.0/src/parser/raws/tile_page/parse.rs

11	impl super::DFTilePage {
12	#[allow(clippy::too_many_lines)]
13	pub fn parse<P: AsRef<Path>>(

dioxus-core 0.3.1/src/diff.rs

508	// Upon exit from this function, it will be restored to that same self.
509	#[allow(clippy::too_many_lines)]
510	fn diff_keyed_middle(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {

diskit 0.1.1/src/virtual_diskit/implementation.rs

498	// I don't see any way to shorten it yet. TODO: Fix!
499	#[allow(clippy::too_many_lines)]
500	fn walkdir_next_helper(

diskit 0.1.1/src/virtual_diskit/tests.rs

53	// complexity to it, therefore this is a false positive here.
54	#[allow(clippy::too_many_lines)]
55	#[test]

dissect 0.5.0/src/lib.rs

287	/// fails if the pattern is invalid
288	#[allow(clippy::too_many_lines)]
289	pub fn compile(mut pattern: &str) -> Result<Self, Error> {
432	#[allow(clippy::too_many_lines)]
433	pub fn run(&self, mut data: &str) -> Option<Object<'static>> {

divina_config 0.1.0/src/lib.rs

199	/// if there are any errors
200	#[allow(clippy::too_many_lines)]
201	pub fn configure(&mut self, file: &str) {

dns-server 0.1.0/tests/test.rs

75	#[allow(clippy::unusual_byte_groupings)]
76	#[allow(clippy::too_many_lines)]
77	fn hard_coded() {

doryen-extra 0.2.1/src/color.rs

652	/// Takes a `Name` and `Level` value and returns the corresponding color constant.
653	#[allow(clippy::too_many_lines)]
654	pub fn by_name_and_level(name: Name, level: Level) -> Self {

doryen-extra 0.2.1/src/noise/algorithms/perlin.rs

187	#[allow(clippy::too_many_lines)]
188	fn perlin_4d(

doryen-extra 0.2.1/src/noise/algorithms/simplex.rs

216	#[allow(clippy::too_many_lines)]
217	#[allow(clippy::many_single_char_names)]
335	#[allow(clippy::too_many_lines)]
336	#[allow(clippy::many_single_char_names)]

dotnetdll 0.0.1/src/convert/read.rs

331	#[allow(clippy::too_many_lines)]
332	pub fn instruction<'r, 'data>(

dotnetdll 0.0.1/src/convert/write.rs

357	#[allow(clippy::too_many_lines)]
358	pub fn instruction(

dotnetdll 0.0.1/src/dll.rs

147	#[allow(clippy::nonminimal_bool, clippy::too_many_lines, unused_mut)]
148	pub fn resolve(&self, opts: ResolveOptions) -> Result<Resolution<'a>> {
2050	#[allow(clippy::too_many_lines)]
2051	pub fn write(res: &Resolution, is_32_bit: bool, is_executable: bool) -> Result<Vec<u8>> {

drone 0.14.0/src/heap/trace.rs

127	#[allow(clippy::too_many_lines)]
128	fn parser<R: Read>(

drone 0.14.0/src/log/swo.rs

13	/// Creates a new ITM parser.
14	#[allow(clippy::shadow_unrelated, clippy::too_many_lines)]
15	pub fn parser(

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

100	#[allow(clippy::too_many_lines)]
101	pub fn proc_macro_derive(input: TokenStream) -> TokenStream {

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

82	#[allow(clippy::too_many_lines)]
83	pub fn proc_macro(input: TokenStream) -> TokenStream {

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 0.11.1/src/sv/switch.rs

154	impl SvService for SwitchBackService {
155	#[allow(clippy::too_many_lines)]
156	unsafe extern "C" fn handler(&mut self) {

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-cortexm 0.14.1/src/sv/switch.rs

49	impl SvService for SwitchContextService {
50	#[allow(clippy::too_many_lines)]
51	unsafe extern "C" fn handler(&mut self) {
137	impl SvService for SwitchBackService {
138	#[allow(clippy::too_many_lines)]
139	unsafe extern "C" fn handler(&mut self) {

drone-cortexm-macros 0.14.1/src/thr_nvic.rs

312	#[allow(clippy::too_many_lines, clippy::cast_possible_truncation)]
313	fn def_vtable(

ecvrf-rs 1.0.0/src/traits.rs

157	impl<'de> Deserialize<'de> for Proof {
158	#[allow(clippy::too_many_lines)]
159	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

ed-system-search 1.1.47/src/domain.rs

189	#[allow(clippy::too_many_lines)]
190	pub fn exclude_rare_commodity<'a>() -> SystemFilter<'a> {

elbus 0.2.21/src/broker.rs

1358	}
1359	#[allow(clippy::too_many_lines)]
1360	async fn handle_peer<R, W>(params: PeerHandlerParams<R, W>) -> Result<(), Error>
1488	// TODO send ack only after the client received message (QoS2)
1489	#[allow(clippy::too_many_lines)]
1490	async fn handle_reader<R>(

elbus 0.2.21/src/cli.rs

541	#[allow(clippy::too_many_lines)]
542	#[tokio::main(worker_threads = 1)]

elbus 0.2.21/src/rpc.rs

319	#[allow(clippy::too_many_lines)]
320	async fn processor<C, H>(

elbus 0.2.21/src/server.rs

163	#[allow(clippy::too_many_lines)]
164	fn main() {

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

148	#[test]
149	#[allow(clippy::too_many_lines)]
150	fn counting_merge_test() {

elem 0.1.3/src/tray.rs

192	/// Run the tray icon and event loop
193	#[allow(clippy::too_many_lines)]
194	pub fn run(&mut self) {

elipdotter 0.3.1/src/query.rs

296	/// documents.
297	#[allow(clippy::too_many_lines)]
298	pub fn occurrences<'a>(

empress 1.6.0/src/server/mod.rs

70	#[allow(clippy::too_many_lines)]
71	fn register_interface(b: &mut IfaceBuilder<Arc<Server>>) {

entab 0.3.1/src/parsers/flow.rs

134	#[allow(clippy::too_many_lines)]
135	fn get(&mut self, _buf: &'b [u8], map: &'s Self::State) -> Result<(), EtError> {

entropycli 1.0.8/src/commands/beacon/dev.rs

34	#[allow(clippy::too_many_lines)]
35	pub async fn dev_cmd(options: DevCommandOptions) {

entropycli 1.0.8/src/commands/beacon/init.rs

27	}
28	#[allow(clippy::too_many_lines)]
29	pub async fn init_cmd(options: InitCommandOptions) {

entropycli 1.0.8/src/commands/worker/start.rs

35	#[allow(clippy::too_many_lines)]
36	pub async fn start_cmd(options: StartCommandOptions) {

entropycli 1.0.8/src/utils/deploy.rs

18	#[allow(clippy::too_many_lines)]
19	pub async fn deploy_beacon(

essence 0.3.3/src/db/channel.rs

233	/// returned.
234	#[allow(clippy::too_many_lines)]
235	async fn fetch_channel(&self, channel_id: u64) -> crate::Result<Option<Channel>> {
450	/// * If an error occurs with creating the channel.
451	#[allow(clippy::too_many_lines)]
452	async fn create_guild_channel(

essence 0.3.3/src/db/guild.rs

255	/// * If an error occurs with fetching the guilds.
256	#[allow(clippy::too_many_lines)]
257	async fn fetch_all_guilds_for_user(

eva-ics 3.99.0/src/core.rs

487	/// Will panic if state mutex is poisoned
488	#[allow(clippy::too_many_lines)]
489	pub async fn action(
763	// long time!
764	#[allow(clippy::too_many_lines)]
765	pub async fn process_remote_inventory(

eva-ics 3.99.0/src/eapi.rs

146	}
147	#[allow(clippy::too_many_lines)]
148	async fn handle_call(&self, event: RpcEvent) -> RpcResult {

eva-rjrpc 0.1.16/src/http.rs

220	/// Will return `Err` if failed to build the http response
221	#[allow(clippy::too_many_lines)]
222	pub async fn process<'de, F, Fut>(

exonum 1.0.0/src/runtime/dispatcher/tests.rs

287	#[test]
288	#[allow(clippy::too_many_lines)] // Adequate for a test
289	fn test_dispatcher_simple() {
1087	#[test]
1088	#[allow(clippy::too_many_lines)] // Adequate for a test
1089	fn stopped_service_workflow() {

exonum-node 1.0.0/src/sandbox/mod.rs

1181	/// Constructs an uninitialized instance of a `Sandbox`.
1182	#[allow(clippy::too_many_lines)]
1183	fn sandbox_with_services_uninitialized(

exonum-node 1.0.0/src/sandbox/tests/recovery.rs

241	#[test]
242	#[allow(clippy::too_many_lines)] // fine for tests
243	fn test_recover_consensus_messages_in_other_round() {

exonum-node 1.0.0/src/sandbox/tests/transactions.rs

344	#[test]
345	#[allow(clippy::too_many_lines)] // fine for tests
346	fn respond_to_request_tx_propose_prevotes_precommits() {

exonum-testkit 1.0.0/src/checkpoint_db.rs

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

expect-exit 0.5.2/src/bin/test_expect_exit.rs

418	/// Build up the array of test cases.
419	#[allow(clippy::too_many_lines)]
420	fn get_test_cases() -> &'static [TestCase<'static>] {

fend-core 1.1.4/src/ast.rs

335	#[allow(clippy::too_many_lines)]
336	pub(crate) fn evaluate<I: Interrupt>(

fend-core 1.1.4/src/error.rs

100	impl fmt::Display for FendError {
101	#[allow(clippy::too_many_lines)]
102	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

fend-core 1.1.4/src/lexer.rs

229	#[allow(clippy::too_many_lines)]
230	fn parse_basic_number<'a, I: Interrupt>(

fend-core 1.1.4/src/units/builtin.rs

703	#[allow(clippy::too_many_lines)]
704	pub(crate) fn query_unit<'a>(

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

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

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

116	#[allow(clippy::too_many_lines)] // excuse the heck outta me, clippy
117	impl Mutator for LibAflMutator {

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

359	#[allow(clippy::cognitive_complexity)]
360	#[allow(clippy::too_many_lines)]
361	fn test_bitand_action_and_action() {
917	#[test]
918	#[allow(clippy::too_many_lines)]
919	fn test_bitor_action_and_action() {

fif 0.6.0/src/main.rs

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

file-expert 1.1.0/src/linguist_heuristics.rs

227	#[allow(clippy::too_many_lines)]
228	#[allow(clippy::match_same_arms)]

findminhs 2.1.0/src/reductions.rs

286	#[allow(clippy::too_many_lines)]
287	pub fn reduce(

fiona 0.1.0/src/lib.rs

135	#[allow(clippy::too_many_lines)]
136	pub fn run(&mut self) {

fiona 0.1.0/src/libc.rs

35	#[allow(clippy::too_many_lines)]
36	#[must_use]

focaccia 1.3.1/src/exhaustive/full.rs

14	#[allow(clippy::match_same_arms)]
15	#[allow(clippy::too_many_lines)]
16	fn lookup_naive(c: char, buf: &mut [u8; 4]) -> &str {

focaccia 1.3.1/src/exhaustive/turkic.rs

14	#[allow(clippy::match_same_arms)]
15	#[allow(clippy::too_many_lines)]
16	fn lookup_naive(c: char, buf: &mut [u8; 4]) -> &str {

focaccia 1.3.1/src/folding/mapping/lookup.rs

16	#[allow(clippy::match_same_arms)]
17	#[allow(clippy::too_many_lines)]
18	pub const fn lookup(c: char, mode: Mode) -> Mapping {

formula 0.1.0/src/lib.rs

145	#[allow(clippy::too_many_lines)]
146	fn parse_pair(pair: Pair<Rule>) -> Result<Expr> {

formula 0.1.0/src/parsers/basic.rs

72	#[test]
73	#[allow(clippy::too_many_lines)]
74	fn test_parse_basic_types() {

formula 0.1.0/src/parsers/date_and_time.rs

299	#[test]
300	#[allow(clippy::too_many_lines)]
301	fn test_parse_date_and_time_types() {

formula 0.1.0/src/parsers/logical.rs

136	#[test]
137	#[allow(clippy::too_many_lines)]
138	fn test_parse_bool_types() {

formula 0.1.0/src/parsers/math.rs

330	#[test]
331	#[allow(clippy::too_many_lines)]
332	fn test_parse_math_types() {

formula 0.1.0/src/parsers/operator.rs

210	#[test]
211	#[allow(clippy::too_many_lines)]
212	fn test_parse_web_types() {

formula 0.1.0/src/parsers/text.rs

548	#[test]
549	#[allow(clippy::too_many_lines)]
550	fn test_parse_text_types() {

formula 0.1.0/src/parsers/web.rs

64	#[test]
65	#[allow(clippy::too_many_lines)]
66	fn test_parse_web_types() {

fqgrep 1.0.2/src/main.rs

323	#[allow(clippy::too_many_lines)]
324	fn fqgrep_from_opts(opts: &Opts) -> Result<usize> {

ftzz 1.2.0/src/core/scheduler.rs

40	#[allow(clippy::too_many_lines)]
41	pub async fn run(

funspace 0.4.0/src/chebyshev/linalg/pdma2.rs

16	/// u4: sub-diagonal (+4)
17	#[allow(clippy::many_single_char_names, dead_code, clippy::too_many_lines)]
18	#[inline]

fuzzcheck 0.12.1/src/sensors_and_pools/simplest_to_activate_counter_pool.rs

180	#[allow(clippy::too_many_lines)]
181	#[no_coverage]

gedcomx 0.1.3/src/conclusion/fact.rs

511	impl fmt::Display for FactType {
512	#[allow(clippy::too_many_lines)]
513	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
622	impl From<EnumAsString> for FactType {
623	#[allow(clippy::too_many_lines)]
624	fn from(f: EnumAsString) -> Self {
741	impl Arbitrary for FactType {
742	#[allow(clippy::too_many_lines)]
743	fn arbitrary(g: &mut Gen) -> Self {

gen_value 0.6.0/benches/experimental.rs

47	#[allow(clippy::too_many_lines)]
48	fn iter_sequentially<T: Copy + Default + AddAssign>(c: &mut Criterion) {
182	#[allow(clippy::too_many_lines)]
183	fn iter_sequentially_half_elements_removed<T: Copy + Default + AddAssign>(c: &mut Criterion) {
391	#[allow(clippy::too_many_lines)]
392	fn random_get_all<T: Copy + Default + AddAssign>(c: &mut Criterion) {

geo-aid 0.2.0/src/cli.rs

270	impl<'r> Display for Diagnostic<'r> {
271	#[allow(clippy::too_many_lines)]
272	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

geo-aid 0.2.0/src/generator/critic.rs

106	#[allow(clippy::too_many_lines)]
107	fn evaluate_expression(

geo-aid 0.2.0/src/script.rs

201	#[must_use]
202	#[allow(clippy::too_many_lines)]
203	pub fn diagnostic(self) -> DiagnosticData {

germ 0.3.7/src/ast/container.rs

133	#[allow(clippy::too_many_lines)]
134	fn evaluate(

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

gistit 0.2.3/src/arg.rs

4	/// The gistit application
5	#[allow(clippy::too_many_lines)]
6	#[must_use]

gistit 0.2.3/src/node.rs

153	#[allow(clippy::too_many_lines)]
154	async fn dispatch(&self, config: Self::InnerData) -> Result<()> {

gistit 0.2.3/src/send.rs

158	#[allow(clippy::too_many_lines)]
159	async fn dispatch(&self, config: Self::InnerData) -> Result<()> {

gistit-cli 0.1.1/src/arg.rs

4	/// The gistit application
5	#[allow(clippy::too_many_lines)]
6	#[must_use]

gistit-cli 0.1.1/src/node.rs

153	#[allow(clippy::too_many_lines)]
154	async fn dispatch(&self, config: Self::InnerData) -> Result<()> {

gistit-cli 0.1.1/src/send.rs

158	#[allow(clippy::too_many_lines)]
159	async fn dispatch(&self, config: Self::InnerData) -> Result<()> {

gitui 0.22.1/src/app.rs

109	///
110	#[allow(clippy::too_many_lines)]
111	pub fn new(
780	#[allow(clippy::too_many_lines)]
781	fn process_internal_event(
932	#[allow(clippy::too_many_lines)]
933	fn process_confirmed_action(

gitui 0.22.1/src/components/commit_details/details.rs

155	#[allow(unstable_name_collisions, clippy::too_many_lines)]
156	fn get_text_info(&self) -> Vec<Spans> {

gitui 0.22.1/src/tabs/revlog.rs

249	//TODO: cleanup
250	#[allow(clippy::too_many_lines)]
251	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(

gloss-word 0.2.3/src/main.rs

17	#[allow(clippy::too_many_lines)]
18	fn main() -> Result<(), anyhow::Error> {

glv 3.0.5/src/actors/github.rs

45	impl GitHubThread {
46	#[allow(clippy::too_many_lines)]
47	pub(crate) fn new() -> Self {

grafbase 0.15.0/tests/scalars.rs

76	// There's no point in splitting test cases
77	#[allow(clippy::too_many_lines)]
78	#[test]

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

67	#[allow(clippy::too_many_lines)]
68	#[allow(clippy::cognitive_complexity)]

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

136	#[allow(clippy::cognitive_complexity)]
137	#[allow(clippy::too_many_lines)]
138	fn uncompressed_header<'a>(
945	#[allow(clippy::too_many_lines)]
946	fn tile_info(

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

137	#[allow(clippy::too_many_lines)]
138	pub fn film_grain_params(

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

17	impl<const WRITE: bool> BitstreamParser<WRITE> {
18	#[allow(clippy::too_many_lines)]
19	#[allow(clippy::cognitive_complexity)]

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

143	impl<const WRITE: bool> BitstreamParser<WRITE> {
144	#[allow(clippy::too_many_lines)]
145	pub fn parse_sequence_header<'a>(
443	#[allow(clippy::too_many_lines)]
444	fn color_config(

hcl-rs 0.12.3/src/expr/de.rs

33	impl<'de> de::Deserialize<'de> for Expression {
34	#[allow(clippy::too_many_lines)]
35	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

hdbconnect 0.24.0/src/conn/params/connect_params.rs

181	#[allow(clippy::too_many_lines)]
182	pub(crate) fn rustls_clientconfig(&self) -> std::io::Result<ClientConfig> {

hebo 0.3.3/src/listener/init.rs

138	/// Returns error if:
139	#[allow(clippy::too_many_lines)]
140	#[allow(clippy::too_many_arguments)]

hebo 0.3.3/src/metrics.rs

87	#[allow(clippy::too_many_lines)]
88	async fn handle_dispatcher_cmd(&mut self, cmd: DispatcherToMetricsCmd) {

hebo 0.3.3/src/server/init.rs

24	impl ServerContext {
25	#[allow(clippy::too_many_lines)]
26	pub(crate) async fn init_modules(&mut self, runtime: &Runtime) -> Result<(), Error> {

hebo_codec 0.2.3/src/header.rs

133	/// Returns error value `InvalidPacketFlags` if flag bits is not expected.
134	#[allow(clippy::too_many_lines)]
135	#[allow(clippy::cognitive_complexity)]

hebo_codec 0.2.3/src/v5/property.rs

745	impl DecodePacket for Property {
746	#[allow(clippy::too_many_lines)]
747	fn decode(ba: &mut ByteArray) -> Result<Self, DecodeError> {

hedera 0.9.0/src/schedule/schedule_create_transaction.rs

197	// not really anything I can do about this
198	#[allow(clippy::too_many_lines)]
199	fn to_transaction_data_protobuf(

hedera 0.9.0/src/transaction/any.rs

150	// not really anything I can do about this
151	#[allow(clippy::too_many_lines)]
152	fn to_transaction_data_protobuf(

heron_debug 5.0.2/src/dim2.rs

138	#[allow(clippy::too_many_lines)]
139	fn base_builder(body: &CollisionShape, shape: &dyn Shape) -> GeometryBuilder {

hexx 0.1.1/src/mesh.rs

60	#[must_use]
61	#[allow(clippy::too_many_lines)]
62	pub fn partial_hexagonal_column(layout: &HexLayout, hex: Hex, column_height: f32) -> Self {
305	#[must_use]
306	#[allow(clippy::too_many_lines)]
307	pub fn hexagonal_column(layout: &HexLayout, hex: Hex, column_height: f32) -> Self {

histdb-rs 2.0.1/src/run/import.rs

198	#[allow(clippy::too_many_lines)]
199	pub fn histfile(import_file: impl AsRef<Path>, data_dir: PathBuf) -> Result<(), Error> {

hoard 0.5.1/src/checkers/history/operation/v2.rs

705	#[test]
706	#[allow(clippy::too_many_lines)]
707	fn test_from_named() {

hoard 0.5.1/src/combinator.rs

352	#[allow(clippy::too_many_lines)]
353	static CASES: Lazy<Vec<TestItem>> = Lazy::new(\|\| {

hoard 0.5.1/src/hoard/iter/diff_files.rs

235	#[allow(clippy::too_many_lines)]
236	#[tracing::instrument(skip_all)]

hoard 0.5.1/src/hoard/pile_config.rs

394	#[allow(clippy::too_many_lines)]
395	#[test]

hoard-rs 1.3.0/src/gui/commands_gui.rs

123	#[allow(clippy::too_many_lines)]
124	pub fn run(trove: &mut CommandTrove, config: &HoardConfig) -> Result<Option<HoardCommand>> {

hoard-rs 1.3.0/src/gui/list_search/controls.rs

5	#[allow(clippy::too_many_lines)]
6	pub fn key_handler(

hoard-rs 1.3.0/src/gui/list_search/render.rs

16	#[allow(clippy::too_many_lines)]
17	pub fn draw(
181	#[allow(clippy::too_many_lines)]
182	fn render_commands<'a>(

hpn 0.6.3/src/hpn.rs

140	/// Applies an atom to the current stack.
141	#[allow(clippy::too_many_lines)]
142	fn apply(&mut self, atom: &Atom) {

hstdb 2.1.0/src/run/import.rs

198	#[allow(clippy::too_many_lines)]
199	pub fn histfile(import_file: impl AsRef<Path>, data_dir: PathBuf) -> Result<(), Error> {

html5minify 0.3.3/src/lib.rs

312	/// Whitespace rules are ignored if `collapse_whitespace` is enabled.
313	#[allow(clippy::too_many_lines)]
314	fn omit_tags(

hyper-static 0.1.6/src/serve.rs

142	#[allow(clippy::too_many_lines)]
143	pub async fn static_file<'a>(

iced_aw 0.3.0/src/graphics/icons/bootstrap.rs

2412	#[must_use]
2413	#[allow(clippy::too_many_lines)]
2414	pub const fn icon_to_char(icon: Icon) -> char {

iced_aw 0.3.0/src/native/number_input.rs

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

iced_aw 0.3.0/src/native/overlay/color_picker.rs

223	/// The event handling for the RGBA color area.
224	#[allow(clippy::too_many_lines)]
225	fn on_event_rgba_color(
1156	/// Draws the HSV color area.
1157	#[allow(clippy::too_many_lines)]
1158	fn hsv_color<'a, Message, B, Theme>(
1338	/// Draws the RGBA color area.
1339	#[allow(clippy::too_many_lines)]
1340	fn rgba_color<B, Theme>(

iced_aw 0.3.0/src/native/overlay/date_picker.rs

369	{
370	#[allow(clippy::too_many_lines)]
371	fn layout(

iced_aw 0.3.0/src/native/overlay/time_picker.rs

117	/// The event handling for the clock.
118	#[allow(clippy::too_many_lines)]
119	fn on_event_clock(
284	/// The event handling for the digital clock.
285	#[allow(clippy::too_many_lines)]
286	fn on_event_digital_clock(
1052	/// Draws the analog clock.
1053	#[allow(clippy::too_many_lines)]
1054	fn draw_clock<'a, Message, B, Theme>(

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

242	#[allow(clippy::too_many_lines)]
243	fn write_stmt(
513	#[allow(clippy::too_many_lines)]
514	fn write_expr_as(

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

392	#[allow(clippy::too_many_lines)]
393	fn decode_ins<'a>(code: &mut &'a [u8]) -> Option<Ins<'a>> {

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

127	#[allow(clippy::too_many_lines)]
128	fn build_for_list(script: &Scripto, block: &mut StmtBlock, i: usize) -> bool {

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

31	#[allow(clippy::too_many_lines)]
32	fn decompile_block<'a>(
157	#[allow(clippy::too_many_lines)]
158	fn decompile_stmts<'a>(

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

40	#[allow(clippy::too_many_lines)]
41	pub fn default_visit_stmt(script: &mut Scripto, stmt: &mut Stmt, visit: &mut dyn Visitor) {

itmsink 0.1.4/src/itm.rs

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

jiao 0.2.1/src/painting/color.rs

593	#[must_use]
594	#[allow(clippy::too_many_lines)]
595	// TODO(Shaohua): Simplify this method

jsonschema 0.16.1/src/error.rs

758	impl fmt::Display for ValidationError<'_> {
759	#[allow(clippy::too_many_lines)] // The function is long but it does formatting only
760	#[inline]

kaolinite 0.6.1/src/utils.rs

90	/// Determine the filetype from the extension
91	#[allow(clippy::too_many_lines)]
92	#[must_use]

kludgine-core 0.4.0/src/frame_renderer.rs

232	#[allow(clippy::too_many_lines)] // TODO refactor
233	fn render_frame(&mut self, engine_frame: &mut Frame) -> crate::Result<()> {

kludgine-core 0.4.0/src/sprite.rs

146	/// `{tag}_{frame}.{extension}`
147	#[allow(clippy::too_many_lines)]
148	// TODO refactor. Now that I know more about serde, this probably can be parsed

ksql 0.8.0/src/parser.rs

135	#[allow(clippy::too_many_lines)]
136	fn parse_expression(&mut self) -> anyhow::Result<Option<BoxedExpression>> {
159	#[allow(clippy::too_many_lines)]
160	fn parse_value(&mut self, token: Token) -> anyhow::Result<BoxedExpression> {
273	#[allow(clippy::too_many_lines, clippy::needless_pass_by_value)]
274	fn next_operator_token(&mut self, operation_token: Token) -> anyhow::Result<Token> {
286	#[allow(clippy::too_many_lines)]
287	fn parse_operation(

kukoo 0.1.0/src/map_inner.rs

256	/// `WriteResult::Retry`, and the caller need to retry.
257	#[allow(clippy::needless_pass_by_value, clippy::too_many_lines)]
258	pub fn insert(
668	/// this method returns false, otherwise returns true.
669	#[allow(clippy::too_many_lines)]
670	fn help_relocate(

kvarn-chute 0.3.2/src/lib.rs

239	#[allow(clippy::too_many_lines)]
240	fn _process<P: AsRef<Path>>(

lair 0.6.0/src/lapack/getrf.rs

123

#[allow(clippy::cast_possible_wrap)] // The number of elements in the matrix does not exceed `isize::MAX`.

124

#[allow(clippy::too_many_lines)]

125

unsafe fn getrf_col_major<A>(mut a: ArrayViewMut2<A>, pivots: &mut [usize]) -> Option<usize>

lair 0.6.0/src/lapack/lasq.rs

10	#[allow(dead_code)]
11	#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
12	fn lasq4<A, const PP: usize>(

lefthk-core 0.1.8/src/xkeysym_lookup.rs

45	// We allow this because this function is simply a mapping wrapper.
46	#[allow(clippy::too_many_lines)]
47	#[must_use]

leftwm 0.4.1/src/config/default.rs

10	// considerably.
11	#[allow(clippy::too_many_lines)]
12	fn default() -> Self {

leftwm-core 0.4.1/src/handlers/command_handler/scratchpad_handler.rs

914	#[test]
915	#[allow(clippy::too_many_lines)]
916	fn cycle_scratchpad_window_test() {

legacygui 0.1.0/src/main.rs

138	// pedantic lint.
139	#[allow(clippy::too_many_lines)]
140	fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame)

legacylisten 0.2.0/src/api.rs

357	// This can't sensibly shortend or refactored.
358	#[allow(clippy::too_many_lines)]
359	pub(crate) fn handle(&self, config: &mut Config) -> BigAction

legacylisten 0.2.0/src/l10n/messages.rs

126	// lint.
127	#[allow(clippy::too_many_lines)]
128	fn to_str(&self) -> &'static str

libafl 0.9.0/src/bolts/llmp.rs

2098	#[cfg(feature = "std")]
2099	#[allow(clippy::let_and_return, clippy::too_many_lines)]
2100	fn b2b_thread_on(

libafl 0.9.0/src/events/llmp.rs

850	#[cfg(feature = "std")]
851	#[allow(clippy::type_complexity, clippy::too_many_lines)]
852	impl<MT, S, SP> RestartingMgr<MT, S, SP>

libafl 0.9.0/src/events/simple.rs

419	#[cfg(feature = "std")]
420	#[allow(clippy::type_complexity, clippy::too_many_lines)]
421	impl<MT, S, SP> SimpleRestartingEventManager<MT, S, SP>

libafl 0.9.0/src/executors/inprocess.rs

751	/// It will store the current State to shmem, then exit.
752	#[allow(clippy::too_many_lines)]
753	pub(crate) unsafe fn inproc_crash_handler<E, EM, OF, Z>(
1137	#[allow(clippy::too_many_lines)]
1138	pub(crate) unsafe fn inproc_crash_handler<E, EM, OF, Z>(

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

194	#[allow(clippy::too_many_lines, clippy::cast_precision_loss)]
195	fn draw_time_chart<B>(
321	#[allow(clippy::too_many_lines)]
322	fn draw_text<B>(&mut self, f: &mut Frame<B>, app: &Arc<RwLock<TuiContext>>, area: Rect)

libafl 0.9.0/src/mutators/token_mutations.rs

426	{
427	#[allow(clippy::too_many_lines)]
428	fn mutate(

libafl 0.9.0/src/observers/concolic/serialization_format.rs

277	/// May error when the underlying `Write` errors or when there is a serialization error.
278	#[allow(clippy::too_many_lines)]
279	pub fn write_message(&mut self, mut message: SymExpr) -> Result<SymExprRef> {

libafl 0.9.0/src/schedulers/testcase_score.rs

63	clippy::cast_precision_loss,
64	clippy::too_many_lines,
65	clippy::cast_sign_loss,

libafl_cc 0.9.0/build.rs

162	#[allow(clippy::too_many_lines)]
163	fn main() {

libafl_cc 0.9.0/src/clang.rs

89	impl CompilerWrapper for ClangWrapper {
90	#[allow(clippy::too_many_lines)]
91	fn parse_args<S>(&mut self, args: &[S]) -> Result<&'_ mut Self, Error>

libafl_frida 0.9.0/src/alloc.rs

106	#[must_use]
107	#[allow(clippy::too_many_lines)]
108	pub fn new(options: FuzzerOptions) -> Self {

libafl_frida 0.9.0/src/asan/asan_rt.rs

518	#[allow(clippy::items_after_statements)]
519	#[allow(clippy::too_many_lines)]
520	fn hook_functions(&mut self, gum: &Gum) {
918	#[allow(clippy::cast_sign_loss)]
919	#[allow(clippy::too_many_lines)]
920	extern "C" fn handle_trap(&mut self) {
1074	#[allow(clippy::cast_sign_loss)] // for displacement
1075	#[allow(clippy::too_many_lines)]
1076	extern "C" fn handle_trap(&mut self) {
1422	#[allow(clippy::unused_self, clippy::identity_op)]
1423	#[allow(clippy::too_many_lines)]
1424	fn generate_shadow_check_function(&mut self) {
1563	// identity_op appears to be a false positive in ubfx
1564	#[allow(clippy::unused_self, clippy::identity_op, clippy::too_many_lines)]
1565	fn generate_shadow_check_function(&mut self) {

libafl_frida 0.9.0/src/asan/errors.rs

135	/// Report an error
136	#[allow(clippy::too_many_lines)]
137	pub(crate) fn report_error(&mut self, error: AsanError) {

libafl_frida 0.9.0/src/cmplog_rt.rs

267	#[cfg(all(feature = "cmplog", target_arch = "aarch64"))]
268	#[allow(clippy::too_many_lines)]
269	#[inline]

libafl_frida 0.9.0/src/helper.rs

166	/// Constructor function to create a new [`FridaInstrumentationHelper`], given a `module_name`.
167	#[allow(clippy::too_many_lines)]
168	#[must_use]

libafl_frida 0.9.0/src/lib.rs

126	#[must_use]
127	#[allow(clippy::too_many_lines)]
128	pub fn parse_env_options() -> Self {

libafl_qemu 0.9.0/src/lib.rs

112	#[pyo3(name = "libafl_qemu")]
113	#[allow(clippy::items_after_statements, clippy::too_many_lines)]
114	pub fn python_module(py: Python, m: &PyModule) -> PyResult<()> {

libafl_qemu_build 0.9.0/src/build.rs

19	#[allow(clippy::too_many_lines)]
20	#[must_use]

libafl_sugar 0.9.0/src/forkserver.rs

84	/// Runs the fuzzer.
85	#[allow(clippy::too_many_lines, clippy::similar_names)]
86	pub fn run(&mut self) {

libafl_sugar 0.9.0/src/inmemory.rs

113	/// Run the fuzzer
114	#[allow(clippy::too_many_lines, clippy::similar_names)]
115	pub fn run(&mut self) {

libafl_sugar 0.9.0/src/qemu.rs

118	/// Run the fuzzer
119	#[allow(clippy::too_many_lines, clippy::similar_names)]
120	pub fn run(&mut self, emulator: &Emulator) {

libafl_targets 0.9.0/build.rs

5	#[allow(clippy::too_many_lines)]
6	fn main() {

libasuran 0.0.3/src/repository/pipeline.rs

26	/// Gets a pass on too_many lines for now
27	#[allow(clippy::too_many_lines)]
28	pub fn new(pool: impl Spawn) -> Pipeline {

libcnb-cargo 0.11.4/src/main.rs

31	#[allow(clippy::too_many_lines)]
32	fn handle_libcnb_package(args: PackageArgs) {

libcnb-data 0.11.4/src/buildpack/mod.rs

201	#[test]
202	#[allow(clippy::too_many_lines)]
203	fn deserialize_singlebuildpack() {

licensebat-dart 0.0.18/src/collector/mod.rs

121

/// Resolves the license by scrapping the Dart pub website and then the license in github if available.

122

#[allow(clippy::too_many_lines, clippy::single_match_else)]

123

async fn resolve_hosted_dependency<R: Retriever>(

lilv 0.2.1/examples/lv2info.rs

100	#[allow(clippy::too_many_lines)]
101	fn print_plugin(world: &World, p: &Plugin, nodes: &Nodes) {

lockfree-cuckoohash 0.1.0/src/map_inner.rs

239	/// `WriteResult::Retry`, and the caller need to retry.
240	#[allow(clippy::needless_pass_by_value, clippy::too_many_lines)]
241	pub fn insert(
628	/// this method returns false, otherwise returns true.
629	#[allow(clippy::too_many_lines)]
630	fn help_relocate(

locus 0.0.0/src/modules/multi_blog.rs

27	#[allow(clippy::too_many_lines)]
28	pub fn module(router: &mut windmark::Router) {

many-macros 0.1.0/src/lib.rs

129	#[allow(clippy::too_many_lines)]
130	fn many_module_impl(attr: &TokenStream, item: TokenStream) -> Result<TokenStream, syn::Error> {

markdown 1.0.0-alpha.6/src/construct/attention.rs

286	/// Match two sequences.
287	#[allow(clippy::too_many_lines)]
288	fn match_sequences(

markdown 1.0.0-alpha.6/src/state.rs

470	#[allow(clippy::too_many_lines)]
471	/// Call the corresponding state for a state name.

meiosis 0.1.0/src/algorithm/fitness.rs

753	/// MISSING DOCS
754	#[allow(clippy::too_many_lines)]
755	pub fn select(
899	// all slicing done in here is only done so if a length check makes a panic impossible
900	#[allow(clippy::indexing_slicing, clippy::too_many_lines)]
901	pub fn recombine(

melody_compiler 0.18.1/src/ast/symbols.rs

104	#[allow(clippy::too_many_lines)]
105	fn unicode_category(ident: &str, negative: bool) -> Result<MelodyAstNode> {

mijit 0.2.0/src/beetle/mod.rs

53	impl<T: Target> Beetle<T> {
54	#[allow(clippy::too_many_lines)]
55	pub fn new(target: T) -> Self {

minus 5.1.0/src/core/ev_handler.rs

22	#[cfg_attr(not(feature = "search"), allow(clippy::unnecessary_wraps))]
23	#[allow(clippy::too_many_lines)]
24	pub fn handle_event(

minus 5.1.0/src/core/init.rs

172	/// screen.
173	#[allow(clippy::too_many_lines)]
174	fn start_reactor(

minus 5.1.0/src/input/mod.rs

96	impl InputClassifier for DefaultInputClassifier {
97	#[allow(clippy::too_many_lines)]
98	fn classify_input(&self, ev: Event, ps: &PagerState) -> Option<InputEvent> {

minus 5.1.0/src/input/tests.rs

14	#[test]
15	#[allow(clippy::too_many_lines)]
16	fn test_kb_nav() {
306	#[test]
307	#[allow(clippy::too_many_lines)]
308	#[cfg(feature = "search")]

modbot 0.5.3/src/tasks/events.rs

31	#[allow(clippy::too_many_lines)]
32	pub fn task(ctx: Context) -> impl Future<Output = ()> {

mpeg-audio-header 0.0.6/src/lib.rs

155	/// ```
156	#[allow(clippy::too_many_lines)]
157	pub fn read_from_source(

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

221	/// Get errno description.
222	#[allow(clippy::too_many_lines)]
223	#[must_use]

nc 0.8.13/src/platform/freebsd-x86/errno.rs

202	/// Get errno description.
203	#[allow(clippy::too_many_lines)]
204	#[must_use]

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

202	/// Get errno description.
203	#[allow(clippy::too_many_lines)]
204	#[must_use]

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

271	#[must_use]
272	#[allow(clippy::too_many_lines)]
273	pub const fn strerror(errno: Errno) -> &'static str {

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

271	#[must_use]
272	#[allow(clippy::too_many_lines)]
273	pub const fn strerror(errno: Errno) -> &'static str {

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

271	#[must_use]
272	#[allow(clippy::too_many_lines)]
273	pub const fn strerror(errno: Errno) -> &'static str {

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

271	#[must_use]
272	#[allow(clippy::too_many_lines)]
273	pub const fn strerror(errno: Errno) -> &'static str {

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

271	#[must_use]
272	#[allow(clippy::too_many_lines)]
273	pub const fn strerror(errno: Errno) -> &'static str {

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

271	#[must_use]
272	#[allow(clippy::too_many_lines)]
273	pub const fn strerror(errno: Errno) -> &'static str {

nc 0.8.13/src/platform/linux-s390x/errno.rs

271	#[must_use]
272	#[allow(clippy::too_many_lines)]
273	pub const fn strerror(errno: Errno) -> &'static str {

nebari 0.5.4/src/tree/btree_entry.rs

239	#[allow(clippy::too_many_lines)] // TODO refactor, too many lines
240	fn modify_leaf<IndexedType, Context, Indexer, Loader>(

netcdf 0.7.0/src/attribute.rs

84	/// Unsupported type or netcdf error
85	#[allow(clippy::too_many_lines)]
86	pub fn value(&self) -> error::Result<AttrValue> {
533	#[allow(clippy::needless_pass_by_value)] // All values will be small
534	#[allow(clippy::too_many_lines)]
535	pub(crate) fn put(

nnv-rs 0.6.1/src/starsets/censored_prob_starset.rs

281	/// gaussian probability and dividing by (1 - invalid cdf proportion)
282	#[allow(clippy::too_many_lines)]
283	fn sample_safe_star<R: Rng>(

no-way 0.4.1/src/jwk.rs

1343	#[test]
1344	#[allow(clippy::too_many_lines)]
1345	fn jwk_set_private_key_serde_test() {

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

183	#[allow(clippy::too_many_lines)]
184	#[allow(clippy::cast_sign_loss)]
619	#[allow(clippy::too_many_lines)]
620	#[allow(clippy::let_and_return)]

nokhwa 0.10.3/src/js_camera.rs

900	/// Builds the [`JSCameraConstraints`]
901	#[allow(clippy::too_many_lines)]
902	#[must_use]
2114	#[allow(clippy::too_many_lines)]
2115	fn draw_to_canvas(&mut self) -> Result<(), NokhwaError> {
2294	#[allow(clippy::must_use_candidate)]
2295	#[allow(clippy::too_many_lines)]
2296	pub fn frame_canvas_copy(

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

134	/// This function will error if the camera is currently busy or if `V4L2` can't read device information.
135	#[allow(clippy::too_many_lines)]
136	pub fn new(index: &CameraIndex, cam_fmt: RequestedFormat) -> Result<Self, NokhwaError> {
848	/// This function will error if the camera is currently busy or if `V4L2` can't read device information.
849	#[allow(clippy::too_many_lines)]
850	pub fn new(index: &CameraIndex, cam_fmt: RequestedFormat) -> Result<Self, NokhwaError> {

nokhwa-core 0.1.0/src/types.rs

83	#[must_use]
84	#[allow(clippy::too_many_lines)]
85	pub fn fulfill(&self, all_formats: &[CameraFormat]) -> Option<CameraFormat> {

nonogrid 0.7.3/src/solver/backtracking.rs

433	#[allow(clippy::too_many_lines)]
434	fn search_mutable(

nso 0.1.2/examples/main.rs

17	#[tokio::main]
18	#[allow(clippy::too_many_lines)]
19	async fn main() {

opa 0.9.0/src/build/mod.rs

122	/// The `opa` binary must be found in any of the system paths.
123	#[allow(clippy::missing_panics_doc, clippy::too_many_lines)]
124	pub fn compile(self) -> Result<(), anyhow::Error> {

open-vaf 0.4.2/src/parser/behavior.rs

31	#[allow(clippy::too_many_lines)]
32	pub fn parse_statement(&mut self, attributes: Attributes) -> Result<StatementId> {

open-vaf 0.4.2/src/parser/error.rs

155	impl Error {
156	#[allow(clippy::too_many_lines)]
157	pub fn print(self, source_map: &SourceMap, translate_lines: bool) {
1000	impl Warning {
1001	#[allow(clippy::too_many_lines)]
1002	pub fn print(&self, source_map: &SourceMap, translate_lines: bool) {

open-vaf 0.4.2/src/parser/expression.rs

169	#[allow(clippy::too_many_lines)]
170	pub(super) fn parse_atom(&mut self) -> Result<Node<Expression>> {

open-vaf 0.4.2/src/parser/module.rs

28	#[allow(clippy::too_many_lines)]
29	/// Parses a Module and all its items
220	#[allow(clippy::too_many_lines)]
221	fn parse_function(&mut self, attributes: Attributes) -> Result {

open-vaf 0.4.2/src/parser/nature.rs

24	impl<'lt, 'source_map> Parser<'lt, 'source_map> {
25	#[allow(clippy::too_many_lines)]
26	pub fn parse_nature(&mut self, attributes: Attributes) -> Result {

osrs-cache 0.2.2/src/definition/osrs/npc_def.rs

70	#[allow(clippy::too_many_lines)]
71	fn decode_buffer(id: u16, reader: &mut BufReader<&[u8]>) -> io::Result<NpcDefinition> {

osrs-cache 0.2.2/src/definition/osrs.rs

1	mod inv_def;
2	#[allow(clippy::too_many_lines)]
3	mod item_def;
6	mod npc_def;
7	#[allow(clippy::too_many_lines)]
8	mod obj_def;

osrs-cache 0.2.2/src/util.rs

4	mod huffman;
5	#[allow(clippy::many_single_char_names, clippy::too_many_lines)]
6	mod isaac_rand;

oxker 0.2.1/src/input_handler/mod.rs

141	/// Handle any keyboard button events
142	#[allow(clippy::too_many_lines)]
143	async fn button_press(&mut self, key_code: KeyCode) {

oxker 0.2.1/src/ui/draw_blocks.rs

331	/// TODO Should seperate into loading icon/headers/help functions
332	#[allow(clippy::too_many_lines)]
333	pub fn heading_bar<B: Backend>(

palaver 0.3.0-alpha.3/src/process.rs

216	#[cfg(unix)]
217	#[allow(clippy::too_many_lines)]
218	pub fn fork(orphan: bool) -> nix::Result<ForkResult> {

parallel-sh 0.1.11/src/main.rs

158	#[allow(clippy::too_many_lines)]
159	fn main() {

parsley 0.10.0/src/ctx/base/mod.rs

158	#[allow(clippy::too_many_lines)]
159	#[allow(clippy::similar_names)]

pekzep_numeral 0.2.0/src/tests.rs

1	#[allow(clippy::too_many_lines)]
2	#[test]

pime 0.0.17/src/lib.rs

500	#[allow(clippy::trivially_copy_pass_by_ref)]
501	#[allow(clippy::too_many_lines)]
502	fn new_engine(py: &'p pyo3::Python, venv_path: Option<&str>) -> Result<Self, Error> {

pinyin-parser 0.1.7/src/finals.rs

227	#[must_use]
228	#[allow(clippy::too_many_lines)]
229	#[allow(clippy::cognitive_complexity)]

pinyin-parser 0.1.7/src/lib.rs

232	#[allow(clippy::too_many_lines)]
233	#[allow(clippy::cognitive_complexity)]

pinyin-parser 0.1.7/src/pinyin_token.rs

213	#[allow(clippy::too_many_lines)]
214	pub fn to_token(s: &str, strict: bool) -> PinyinToken {

pixel_engine 0.8.0/src/engine/logic.rs

62

    /// This takes an already existing implementation of a [Game](crate::Game) `G`

63

    #[allow(clippy::too_many_lines, clippy::missing_panics_doc)]

64

    pub fn run<G: crate::Game + 'static>(mut self, mut game: G) -> ! {

pixel_engine_console 0.1.0/src/lib.rs

366	clippy::cast_precision_loss,
367	clippy::too_many_lines,
368	clippy::cast_sign_loss,

plow_cli 0.4.8/src/manifest.rs

72	#[allow(clippy::too_many_lines)]
73	pub fn new(field_contents: &'manifest str) -> Result<Self> {

plow_cli 0.4.8/src/resolve.rs

19	#[allow(clippy::unwrap_used)]
20	#[allow(clippy::too_many_lines)]
21	pub fn resolve(

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

85	/// Creates a new field that is conforming to the FLD33 field format.
86	#[allow(clippy::too_many_lines)]
87	pub fn new(name: &str) -> std::string::String {

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

17	#[allow(clippy::too_many_lines)]
18	pub fn prepare(config: &PlowConfig) -> Result<(), CliError> {

plow_cli 0.4.8/src/subcommand/protege.rs

58	#[allow(clippy::too_many_lines)]
59	pub fn run_command_flow(

plow_cli 0.4.8/src/sync.rs

55	#[allow(clippy::too_many_lines)]
56	pub fn sync(config: &PlowConfig) -> Result<InMemoryRegistry, CliError> {

plow_graphify 0.2.2/src/lib.rs

82	#[allow(clippy::missing_panics_doc)]
83	#[allow(clippy::too_many_lines)]
84	pub fn document_to_graph(document: &TurtleDocument) -> Result<GraphRef, RDFParseError> {

plow_linter 0.2.8/src/lint/helpers.rs

256	/// ```
257	#[allow(clippy::too_many_lines)]
258	pub fn validate_semantic_version_requirement_literal(

pmtiles2 0.1.6/src/pmtiles.rs

482	#[test]
483	#[allow(clippy::too_many_lines)]
484	fn test_from_reader3() -> Result<()> {

pot 1.0.2/src/format.rs

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

pslink 0.4.1-beta.2/src/bin/pslink/cli.rs

23	/// generate the commandline options available
24	#[allow(clippy::too_many_lines)]
25	fn generate_cli() -> App<'static, 'static> {

pslink 0.4.1-beta.2/src/bin/pslink/main.rs

88	clippy::future_not_send,
89	clippy::too_many_lines,
90	unknown_lints,

pslink-app 0.4.1-beta.2/src/pages/list_links.rs

403	/// Process all the events related to editing links.
404	#[allow(clippy::too_many_lines)]
405	pub fn process_edit_messages(msg: EditMsg, model: &mut Model, orders: &mut impl Orders<Msg>) {

psrt 0.1.30/src/cli.rs

229	#[allow(clippy::too_many_lines)]
230	async fn benchmark(
344	#[tokio::main(worker_threads = 1)]
345	#[allow(clippy::too_many_lines)]
346	async fn main() {

psrt 0.1.30/src/client.rs

304	/// Will return Err on communcation errors
305	#[allow(clippy::too_many_lines)]
306	pub async fn connect(config: &Config) -> Result<Self, Error> {

psrt 0.1.30/src/server.rs

222	#[allow(clippy::too_many_lines)]
223	#[allow(clippy::mutable_key_type)]
812	#[allow(clippy::too_many_lines)]
813	async fn run_server(
1084	#[allow(clippy::too_many_lines)]
1085	fn main() {
1348	#[allow(clippy::too_many_lines)]
1349	async fn handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {

public-api 0.27.1/src/render.rs

38	impl<'c> RenderingContext<'c> {
39	#[allow(clippy::too_many_lines)]
40	pub fn token_stream(&self, public_item: &IntermediatePublicItem<'c>) -> Vec<Token> {

py-marshal 0.3.3/src/lib.rs

553	#[allow(clippy::too_many_lines)]
554	fn r_object(p: &mut RFile<impl Read>) -> Result<Option<Obj>> {

py27-marshal 0.3.4/src/read.rs

169	#[allow(clippy::too_many_lines)]
170	fn r_object(p: &mut RFile<impl Read>) -> ParseResult<Option<Obj>> {

qrtool 0.5.1/src/core.rs

25	/// Runs the program and returns the result.
26	#[allow(clippy::too_many_lines)]
27	pub fn run() -> anyhow::Result<()> {

quake-bspc 0.1.5/src/lib.rs

409	/// See the variants on the [`ConversionError`] enum for more information.
410	#[allow(clippy::too_many_lines)]
411	pub async fn convert(

radvisor 1.3.1/src/collection/mod.rs

36	/// list, if possible
37	#[allow(clippy::too_many_lines)]
38	pub fn run(

ranges 0.3.3/src/generic_range/relation.rs

846	/// if applicable, either one is less, shorter, or a singleton.
847	#[allow(clippy::too_many_lines)]
848	#[must_use]

ranges 0.3.3/src/ranges/difference.rs

27	/// ```
28	#[allow(clippy::too_many_lines, clippy::expect_used)]
29	#[must_use]

ranges 0.3.3/src/ranges/intersect.rs

27	/// ```
28	#[allow(clippy::too_many_lines)]
29	#[must_use]

ranges 0.3.3/src/ranges/symmetric_difference.rs

39	/// ```
40	#[allow(clippy::too_many_lines)]
41	#[must_use]

ranges 0.3.3/src/ranges/union.rs

36	/// ```
37	#[allow(clippy::too_many_lines)]
38	#[must_use]

rdenticon 0.1.3/src/lib.rs

287	#[allow(clippy::too_many_lines)]
288	fn render_center(

rena 1.3.1/src/main.rs

59	#[allow(clippy::too_many_lines)]
60	fn build_app() -> Command<'static> {

reserde 0.0.4/src/main.rs

106	#[allow(clippy::too_many_lines)]
107	fn main() {

rlimit 0.9.1/src/bindings.rs

780	#[allow(clippy::too_many_lines)]
781	#[test]

rmodbus 0.6.4/src/server/mod.rs

289	/// Parse frame buffer
290	#[allow(clippy::too_many_lines)]
291	pub fn parse(&mut self) -> Result<(), ErrorKind> {

rmx 0.1.6/src/arg.rs

9	#[allow(clippy::too_many_lines)]
10	pub fn rm_options() -> Command<'static> {

rrule 0.10.0/src/core/rrule.rs

632	/// So if you want a valid string, it's smarter to always use `rrule.validate(ds_start)?.to_string()`.
633	#[allow(clippy::too_many_lines)]
634	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

rrule 0.10.0/src/parser/content_line/rule_content_line.rs

83	/// Takes a map of [`RRuleProperty`] and returns an [`RRule`].
84	#[allow(clippy::too_many_lines)]
85	fn props_to_rrule(

rs-cache 0.8.5/src/definition/osrs/npc_def.rs

70	#[allow(clippy::too_many_lines)]
71	fn decode_buffer(id: u16, reader: &mut BufReader<&[u8]>) -> io::Result<NpcDefinition> {

rs-cache 0.8.5/src/definition/osrs.rs

1	#[allow(clippy::too_many_lines)]
2	mod item_def;
5	mod npc_def;
6	#[allow(clippy::too_many_lines)]
7	mod obj_def;

rs-cache 0.8.5/src/definition/rs3.rs

1	#[allow(clippy::too_many_lines)]
2	mod item_def;

rs-cache 0.8.5/src/util.rs

4	mod huffman;
5	#[allow(clippy::many_single_char_names, clippy::too_many_lines)]
6	mod isaac_rand;

rslint_regex 0.3.0/src/parser.rs

987	#[inline]
988	#[allow(clippy::too_many_lines)]
989	fn atom_escape(&mut self, start: usize, extended: bool) -> Result<Node> {

rust_filen 0.3.0/src/v1/events.rs

844	// I know this deserialization is ugly, but I cannot think of better alternative
845	#[allow(clippy::too_many_lines)]
846	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

rust_wasm_dodrio_templating 1.0.2/src/html_template_mod.rs

113	/// It makes the code less readable. It is only good for chaining and type changing.
114	#[allow(clippy::too_many_lines, clippy::type_complexity)]
115	fn fill_element_builder<'a>(

rust_wasm_websocket 0.5.5/src/websocket_mod.rs

142	#[allow(clippy::unneeded_field_pattern)]
143	#[allow(clippy::too_many_lines)] // I know is long
144	fn setup_ws_msg_recv(ws: &WebSocket, vdom: VdomWeak) {

rustdds 0.7.11/examples/shapes_demo/main.rs

51	#[allow(clippy::too_many_lines)]
52	fn main() {

rustscan 2.1.1/src/main.rs

51	#[cfg(not(tarpaulin_include))]
52	#[allow(clippy::too_many_lines)]
53	/// Faster Nmap scanning with Rust

rustus 0.5.10/src/protocol/creation/routes.rs

71	/// extension is enabled.
72	#[allow(clippy::too_many_lines)]
73	pub async fn create_file(

rutenspitz_macro 0.2.1/src/lib.rs

256	impl<'s> quote::ToTokens for MethodTest<'s> {
257	#[allow(clippy::too_many_lines)]
258	fn to_tokens(&self, tokens: &mut pm2::TokenStream) {

safe-regex 0.2.5/src/bin/compilable/main.rs

20	/// ```
21	#[allow(clippy::too_many_lines)]
22	fn main() {

safe-regex 0.2.5/src/bin/uncompilable/main.rs

35	/// `matcher` crate is moved to this crate.
36	#[allow(clippy::too_many_lines)]
37	fn main() {

safe-regex-compiler 0.2.5/src/generator.rs

243	#[allow(clippy::too_many_lines)]
244	fn build(
411	#[must_use]
412	#[allow(clippy::too_many_lines)]
413	pub fn generate(final_node: &FinalNode) -> safe_proc_macro2::TokenStream {

safe-regex-compiler 0.2.5/src/parser.rs

557	/// rules. This is necessary for operator precedence.
558	#[allow(clippy::too_many_lines)]
559	fn apply_rule_once(

safe-regex-compiler 0.2.5/tests/impl_regex.rs

148	#[test]
149	#[allow(clippy::too_many_lines)]
150	fn seq() {

scc 1.1.1/src/tests/performance.rs

261	#[allow(clippy::too_many_lines)]
262	fn hashmap_benchmark<T: 'static + ConvertFromUsize + Clone + Eq + Hash + Ord + Send + Sync>(
389	#[allow(clippy::too_many_lines)]
390	fn hashindex_benchmark<
519	#[allow(clippy::too_many_lines)]
520	fn treeindex_benchmark<T: 'static + ConvertFromUsize + Clone + Hash + Ord + Send + Sync>(
825	#[allow(clippy::too_many_lines)]
826	async fn hashmap_benchmark(workload_size: usize, num_tasks_list: Vec<usize>) {
1054	#[allow(clippy::too_many_lines)]
1055	async fn hashindex_benchmark(workload_size: usize, num_tasks_list: Vec<usize>) {

scc 1.1.1/src/tree_index/internal_node.rs

375	/// Returns an error if a retry is required.
376	#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
377	pub(super) fn split_node<D: DeriveAsyncWait>(

scc 1.1.1/src/tree_index/leaf_node.rs

359	/// Splits itself into the given leaf nodes, and returns the middle key value.
360	#[allow(clippy::too_many_lines)]
361	pub(super) fn split_leaf_node<'b>(

scientific 0.2.0/src/conversion/bytes_de.rs

9	impl Sci {
10	#[allow(clippy::too_many_lines)]
11	pub(crate) fn from_bytes(bytes: &[u8]) -> Result<Sci, ConversionError> {

scryptenc-cli 0.4.1/src/core.rs

26	/// Runs the program and returns the result.
27	#[allow(clippy::too_many_lines)]
28	pub fn run() -> anyhow::Result<()> {

seed 0.9.2/src/browser/dom/virtual_dom_bridge.rs

320	#[allow(clippy::too_many_lines)]
321	impl<Ms> From<&web_sys::Element> for El<Ms> {
323	/// and markdown strings. Includes children, recursively added.
324	#[allow(clippy::too_many_lines)]
325	fn from(ws_el: &web_sys::Element) -> Self {

sentry-contrib-native 0.3.1/tests/breadcrumb.rs

16	#[tokio::test(flavor = "multi_thread")]
17	#[allow(clippy::too_many_lines)]
18	async fn breadcrumb() -> Result<()> {

sentry-contrib-native 0.3.1/tests/lib.rs

17	#[tokio::test(flavor = "multi_thread")]
18	#[allow(clippy::too_many_lines)]
19	async fn lib() -> Result<()> {

september 0.2.1/src/gemini_to_html.rs

39	#[allow(clippy::too_many_lines)]
40	pub fn gemini_to_html(

september 0.2.1/src/response.rs

25	#[allow(clippy::unused_async, clippy::future_not_send, clippy::too_many_lines)]
26	pub async fn default(

serde_assert 0.2.0/src/token.rs

914	impl PartialEq for Token {
915	#[allow(clippy::too_many_lines)] // The large amount of lines comes from the large amount of variants.
916	fn eq(&self, other: &Self) -> bool {

serde_closure_derive 0.3.3/src/lib.rs

183	clippy::unnecessary_wraps,
184	clippy::too_many_lines
185	)]
720	#[allow(clippy::too_many_lines)]
721	fn expr(&mut self, expr: &mut Expr, is_func: bool) {

serde_traitobject 0.2.8/tests/test.rs

100	#[wasm_bindgen_test]
101	#[allow(clippy::too_many_lines)]
102	fn main() {

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

24	clippy::transmute_ptr_to_ptr,
25	clippy::too_many_lines,
26	clippy::cast_ptr_alignment,
28	clippy::if_not_else,
29	clippy::too_many_lines
30	)]

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

48	clippy::cast_ptr_alignment,
49	clippy::too_many_lines
50	)]

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

78	clippy::cast_precision_loss,
79	clippy::too_many_lines
80	)]
359	clippy::cast_possible_wrap,
360	clippy::too_many_lines
361	)]

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

38	clippy::cast_possible_truncation,
39	clippy::too_many_lines
40	)]

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

19	clippy::cast_possible_wrap,
20	clippy::too_many_lines
21	)]

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

25	clippy::cast_possible_wrap,
26	clippy::too_many_lines
27	)]

simd-json 0.7.0/src/stage2.rs

107	clippy::cognitive_complexity,
108	clippy::too_many_lines,
109	unused_unsafe,

sitemap-rs 0.2.0/src/video.rs

228	/// Will return `XMLError` if there is a problem creating XML elements.
229	#[allow(clippy::too_many_lines)]
230	pub fn to_xml(self) -> Result<XMLElement, XMLError> {

skillratings 0.24.0/src/glicko_boost.rs

872	#[test]
873	#[allow(clippy::similar_names, clippy::too_many_lines)]
874	/// This test is taken from the original paper

slaps 0.2.3/src/clap.rs

282	#[allow(clippy::too_many_lines)]
283	fn complete(

smoltcp-slip 0.3.0/src/phy.rs

259	#[allow(clippy::too_many_lines)]
260	#[test]

soroban-cli 0.4.0/src/read.rs

89	impl Cmd {
90	#[allow(clippy::too_many_lines)]
91	pub fn run(&self) -> Result<(), Error> {

soroban-cli 0.4.0/src/strval.rs

80	#[allow(clippy::too_many_lines)]
81	pub fn from_json(v: &Value, t: &ScSpecTypeDef) -> Result<ScVal, Error> {

soroban-cli 0.4.0/src/xdr.rs

25	impl Cmd {
26	#[allow(clippy::too_many_lines)]
27	pub fn run(&self) -> Result<(), Error> {

soroban-sdk-macros 0.4.3/src/derive_fn.rs

227	#[allow(clippy::too_many_lines)]
228	pub fn derive_contract_function_set<'a>(

soroban-sdk-macros 0.4.3/src/map_type.rs

10	#[allow(clippy::too_many_lines)]
11	pub fn map_type(t: &Type) -> Result<ScSpecTypeDef, Error> {

sp-variant 3.0.0/rust/data.rs

161	#[allow(clippy::panic)]
162	#[allow(clippy::too_many_lines)]
163	#[must_use]

sparkle-cache 0.14.1/src/cache.rs

119	/// Returns the error the backend might return
120	#[allow(clippy::too_many_lines)]
121	async fn update(&self, event: &Event) -> Result<(), Error<Self::Error>> {

sparkle-cache 0.14.1/src/tests.rs

74	/// messages or adding members in it
75	#[allow(rust_2021_incompatible_closure_captures, clippy::too_many_lines)]
76	pub async fn new(cache: T, token: &str) -> Result<Self, anyhow::Error> {
266	/// Does tests related to caching messages
267	#[allow(clippy::too_many_lines)]
268	pub async fn messages(&mut self) -> Result<(), anyhow::Error> {
581	/// are equal
582	#[allow(clippy::too_many_lines)]
583	async fn assert_messages_eq(&mut self) -> Result<(), anyhow::Error> {

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(
710	#[cfg(test)]
711	#[allow(clippy::too_many_lines)]
712	mod test_super {

sqlx-migrate 0.6.0/src/gen/mod.rs

144	#[allow(clippy::too_many_lines)]
145	#[must_use]

ssdcg 0.6.0/src/main.rs

28	#[allow(clippy::too_many_lines)]
29	fn build_engine(messages: Rc<RefCell<Vec<String>>>, indent: String, debug: bool) -> Engine {

ssdcg 0.6.0/src/parser.rs

163	#[allow(clippy::too_many_lines)]
164	pub fn parse(content: &str, namespace: Namespace) -> Result<SsdcFile, ParseError> {

ssimulacra2 0.3.0/src/blur.rs

178	#[allow(clippy::too_many_lines)]
179	pub fn fast_gaussian_horizontal(&self, input: &[f32], output: &mut [f32], width: usize) {

ssimulacra2 0.3.0/src/lib.rs

305	impl Msssim {
306	#[allow(clippy::too_many_lines)]
307	pub fn score(&self) -> f64 {

stanza 0.3.0/src/renderer/console.rs

200	#[allow(clippy::too_many_lines, clippy::similar_names)]
201	fn render_with_hints(&self, table: &Table, hints: &[RenderHint]) -> Self::Output {

stateroom-wasm-macro 0.2.6/src/lib.rs

21	#[allow(clippy::too_many_lines)]
22	fn stateroom_wasm_impl(item: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {

static-router-macros 0.1.5/src/mime.rs

1	#[allow(clippy::too_many_lines)] // giant match block
2	pub(crate) fn ext_to_mime(ext: &str) -> Option<&'static str> {

steamidfx 2.1.0/src/services.rs

48	#[allow(clippy::unreadable_literal)]
49	#[allow(clippy::too_many_lines)]
50	#[test]

stellar-xdr 0.0.12/src/curr/generated.rs

30171	#[must_use]
30172	#[allow(clippy::too_many_lines)]
30173	pub const fn name(&self) -> &'static str {
30489	#[must_use]
30490	#[allow(clippy::too_many_lines)]
30491	pub const fn variants() -> [TypeVariant; 305] {
30510	type Err = Error;
30511	#[allow(clippy::too_many_lines)]
30512	fn from_str(s: &str) -> Result<Self> {
31765	#[cfg(feature = "std")]
31766	#[allow(clippy::too_many_lines)]
31767	pub fn read_xdr(v: TypeVariant, r: &mut impl Read) -> Result<Self> {
32639	#[cfg(feature = "std")]
32640	#[allow(clippy::too_many_lines)]
32641	pub fn read_xdr_iter<R: Read>(

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

37467	#[must_use]
37468	#[allow(clippy::too_many_lines)]
37469	pub const fn name(&self) -> &'static str {
37870	#[must_use]
37871	#[allow(clippy::too_many_lines)]
37872	pub const fn variants() -> [TypeVariant; 390] {
37891	type Err = Error;
37892	#[allow(clippy::too_many_lines)]
37893	fn from_str(s: &str) -> Result<Self> {
39488	#[cfg(feature = "std")]
39489	#[allow(clippy::too_many_lines)]
39490	pub fn read_xdr(v: TypeVariant, r: &mut impl Read) -> Result<Self> {
40603	#[cfg(feature = "std")]
40604	#[allow(clippy::too_many_lines)]
40605	pub fn read_xdr_iter<R: Read>(

stork-search 1.6.0/src/clap.rs

3	#[allow(clippy::too_many_lines)]
4	pub fn app() -> App<'static, 'static> {

strftime-ruby 1.0.0/src/format/mod.rs

473	/// Format time using the formatting directive.
474	#[allow(clippy::too_many_lines)]
475	fn fmt(&self, f: &mut SizeLimiter<'_>, time: &impl CheckedTime) -> Result<(), Error> {

structured 0.9.0/src/stats.rs

375	#[must_use]
376	#[allow(clippy::too_many_lines)]
377	pub(crate) fn n_largest_count_enum(

substrace 0.2.0/src/driver.rs

220	#[allow(clippy::too_many_lines)]
221	pub fn main() {

substrace_lints 0.2.0/src/utils/author.rs

330	#[allow(clippy::too_many_lines)]
331	fn expr(&self, expr: &Binding<&hir::Expr<'_>>) {

substrace_utils 0.2.0/src/visitors.rs

556	// for other types.
557	#[allow(clippy::too_many_lines)]
558	pub fn for_each_unconsumed_temporary<'tcx, B>(

swoop 0.1.0/src/minimise_scalar/bounded.rs

59	#[allow(clippy::cast_precision_loss)]
60	#[allow(clippy::too_many_lines)]
61	pub async fn bounded<T: ScalarObjectiveFunction>(

swoop 0.1.0/src/minimise_scalar/brent.rs

12	/// Will return `SwoopErrors::ArgumentError` is passed tolerance `xtol` is negative
13	#[allow(clippy::too_many_lines)]
14	pub async fn brent<T: ScalarObjectiveFunction>(

sydney 0.1.10/src/ui.rs

27	#[allow(clippy::too_many_lines)]
28	pub fn ui<B: tui::backend::Backend>(

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

400	/// ```
401	#[allow(clippy::too_many_lines)]
402	pub fn parse<T: AsRef<str>>(symbol: T) -> Result<Symbol, SymbologyError> {
551	mod tests {
552	#![allow(clippy::unwrap_used, clippy::too_many_lines, clippy::similar_names)]
553	use super::*;

synoptic 1.2.0/src/languages.rs

27	/// Obtain the rust syntax highlighter
28	#[allow(clippy::missing_panics_doc, clippy::too_many_lines)]
29	#[must_use]

tagref 1.5.0/src/main.rs

108	// Program entrypoint
109	#[allow(clippy::too_many_lines)]
110	fn entry() -> Result<(), String> {

taml-cli 0.0.1/src/main.rs

55	//TODO: Atomic file replacements.
56	#[allow(clippy::too_many_lines)]
57	#[quit::main]

tartan-bitfield 1.2.0/tests/bitfield.rs

180	#[rustfmt::skip]
181	#[allow(clippy::too_many_lines)]
182	fn test_get_bits() {

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
1171	fn handle_message_update(&self, bot: Arc<Bot>, message: types::Message) {
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/chat/member.rs

127	#[allow(clippy::too_many_lines)] // nothing to split
128	fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>

tbot 0.6.7/src/types/message.rs

157	#[allow(clippy::cognitive_complexity)] // can't do much
158	#[allow(clippy::too_many_lines)]
159	fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>

tbot 0.6.7/src/types/passport/element.rs

58	#[allow(clippy::too_many_lines)]
59	fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>

tbot 0.6.7/src/util/entities.rs

100	#[must_use]
101	#[allow(clippy::too_many_lines)]
102	pub fn entities(text: &message::Text) -> Vec<Entity> {

telexide 0.1.10/src/model/message.rs

328	impl From<RawMessage> for Message {
329	#[allow(clippy::too_many_lines)]
330	fn from(raw: RawMessage) -> Message {
502	impl From<Message> for RawMessage {
503	#[allow(clippy::too_many_lines)]
504	fn from(message: Message) -> RawMessage {

telexide-fork 0.2.1/src/model/message.rs

282	impl From<RawMessage> for Message {
283	#[allow(clippy::too_many_lines)]
284	fn from(raw: RawMessage) -> Message {
424	impl From<Message> for RawMessage {
425	#[allow(clippy::too_many_lines)]
426	fn from(message: Message) -> RawMessage {

telnet 0.2.1/src/lib.rs

400	#[allow(clippy::too_many_lines)]
401	fn process(&mut self) {

term_keep 1.1.0/src/cli/parser.rs

21	#[allow(clippy::too_many_lines)]
22	fn command_result(cmd: &Command) -> Result<(), Box<dyn Error>> {

termusic 0.7.8/src/config/key.rs

340	impl Default for Keys {
341	#[allow(clippy::too_many_lines)]
342	fn default() -> Self {

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

60	impl MpvBackend {
61	#[allow(clippy::too_many_lines)]
62	pub fn new(config: &Settings, tx: Sender<PlayerMsg>) -> Self {

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

102	impl Player {
103	#[allow(clippy::too_many_lines)]
104	pub fn new(config: &Settings, tx: Sender<PlayerMsg>) -> Self {

termusic 0.7.8/src/songtag/mod.rs

260	#[allow(clippy::too_many_lines)]
261	pub fn download(&self, file: &str, tx_tageditor: &Sender<Msg>) -> Result<()> {

termusic 0.7.8/src/ui/components/config_editor/key_combo.rs

440	/// Render component when tab is open
441	#[allow(clippy::too_many_lines)]
442	fn render_open_tab(&mut self, render: &mut Frame<'_>, area: Rect) {
1221	impl Component<Msg, NoUserEvent> for KEModifierSelect {
1222	#[allow(clippy::too_many_lines)]
1223	fn on(&mut self, ev: Event<NoUserEvent>) -> Option<Msg> {

termusic 0.7.8/src/ui/components/config_editor/update.rs

28	impl Model {
29	#[allow(clippy::too_many_lines)]
30	pub fn update_config_editor(&mut self, msg: &ConfigEditorMsg) -> Option<Msg> {
270	#[allow(clippy::too_many_lines)]
271	fn update_key_focus(&mut self, msg: &KFMsg) {

termusic 0.7.8/src/ui/components/config_editor/view.rs

68	impl Model {
69	#[allow(clippy::too_many_lines)]
70	pub fn view_config_editor_general(&mut self) {
213	#[allow(clippy::too_many_lines)]
214	pub fn view_config_editor_color(&mut self) {

time-macros 0.2.6/src/format_description/modifier.rs

294	impl Modifiers {
295	#[allow(clippy::too_many_lines)]
296	pub(crate) fn parse(

toast 0.45.5/src/main.rs

168	// Parse the command-line arguments.
169	#[allow(clippy::too_many_lines)]
170	fn settings() -> Result<Settings, Failure> {
584	// Program entrypoint
585	#[allow(clippy::too_many_lines)]
586	fn entry() -> Result<(), Failure> {

toast 0.45.5/src/runner.rs

43	#[allow(clippy::too_many_arguments)]
44	#[allow(clippy::too_many_lines)]
45	pub fn run(

toast 0.45.5/src/toastfile.rs

300	// Check that all dependencies exist and form a DAG (no cycles).
301	#[allow(clippy::too_many_lines)]
302	fn check_dependencies<'a>(toastfile: &'a Toastfile) -> Result<(), Failure> {
470	// Check that a task is valid.
471	#[allow(clippy::too_many_lines)]
472	fn check_task(name: &str, task: &Task) -> Result<(), Failure> {
699	#[test]
700	#[allow(clippy::too_many_lines)]
701	fn parse_comprehensive_task() {

tokio-websockets 0.2.0/src/proto.rs

927	#[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
928	fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {

tough 0.12.5/src/editor/mod.rs

492	#[allow(clippy::too_many_lines)]
493	/// Updates the metadata for the `Targets` role named `name`

transmog-bincode 0.1.0/src/lib.rs

132	impl<'a> From<&Bincode> for BincodeOptions {
133	#[allow(clippy::too_many_lines)]
134	fn from(settings: &Bincode) -> Self {
934	#[test]
935	#[allow(clippy::too_many_lines)]
936	fn format_tests() {

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

77	#[allow(clippy::too_many_lines)]
78	pub(crate) fn up_script<'registry>(

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

274	#[test]
275	#[allow(clippy::too_many_lines)]
276	fn pp_is_exclusive() {

tremor-script 0.13.0-rc.11/src/ast/visitors/impls/const_folder.rs

56

impl<'run, 'script: 'run> ImutExprVisitor<'script> for ConstFolder<'run, 'script> {

57

    #[allow(clippy::too_many_lines, clippy::match_same_arms)]

58

    fn leave_expr(&mut self, e: &mut ImutExpr<'script>) -> Result<()> {

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

1226	clippy::option_if_let_else,
1227	clippy::too_many_lines
1228	)]

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

197	}
198	#[allow(clippy::too_many_lines)]
199	pub(crate) fn expr(&self) -> ErrorLocation {

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

317	#[allow(clippy::too_many_lines)]
318	#[test]

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

316	/// on io errors
317	#[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
318	fn highlight_errors_indent(

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

86	#[inline]
87	#[allow(clippy::too_many_lines)]
88	fn match_expr<'run, 'event>(

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

142	#[allow(clippy::too_many_lines)]
143	#[inline]
359	#[allow(clippy::too_many_lines)]
360	fn match_expr<'run, 'event>(

trippy 0.6.0/src/config.rs

297	#[allow(clippy::too_many_lines)]
298	fn try_from(data: (Args, u16)) -> Result<Self, Self::Error> {

trippy 0.6.0/src/tracing/tracer.rs

559	clippy::cognitive_complexity,
560	clippy::too_many_lines,
561	clippy::bool_assert_comparison

tui-tree-widget 0.11.0/src/lib.rs

269	#[allow(clippy::too_many_lines)]
270	fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {

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

137	/// [`Error::PrivateChannelMissingRecipient`]
138	#[allow(clippy::too_many_lines)]
139	async fn update(&self, event: &Event) -> Result<(), Error<Self::Error>> {

twilight-cache-inmemory 0.15.0-rc.1/src/event/guild.rs

14	impl InMemoryCache {
15	#[allow(clippy::too_many_lines)]
16	fn cache_guild(&self, guild: Guild) {
299	#[allow(clippy::too_many_lines)]
300	#[test]

twilight-cache-inmemory 0.15.0-rc.1/src/event/interaction.rs

90	#[allow(clippy::too_many_lines)]
91	#[test]

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

32	#[allow(clippy::too_many_lines)]
33	pub fn cache_with_message_and_reactions() -> InMemoryCache {

twilight-embed-builder 0.11.1/src/builder.rs

316	/// [`TITLE_LENGTH_LIMIT`]: Self::TITLE_LENGTH_LIMIT
317	#[allow(clippy::too_many_lines)]
318	#[must_use = "should be used as part of something like a message"]

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

927	/// [`GatewayEvent`]: twilight_model::gateway::event::GatewayEvent
928	#[allow(clippy::too_many_lines)]
929	async fn process(&mut self, event: &str) -> Result<(), ProcessError> {

twilight-http 0.15.0-rc.1/src/routing.rs

1106	/// [`GetGuild`]: Self::GetGuild
1107	#[allow(clippy::too_many_lines)]
1108	pub const fn method(&self) -> Method {
1305	/// [`Ratelimiter`]: twilight_http_ratelimiting::Ratelimiter
1306	#[allow(clippy::too_many_lines)]
1307	pub fn to_path(&self) -> Path {
1622	// <https://github.com/rust-lang/rust/issues/10761>
1623	#[allow(clippy::too_many_lines)]
1624	fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {

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

311	/// ```
312	#[allow(clippy::enum_glob_use, clippy::too_many_lines)]
313	fn from_str(s: &str) -> Result<Self, Self::Err> {

twilight-mention 0.15.0-rc.1/src/parse/error.rs

187	#[allow(clippy::too_many_lines)]
188	#[test]

twilight-model 0.15.0-rc.1/src/application/command/mod.rs

107	#[test]
108	#[allow(clippy::too_many_lines)]
109	fn command_option_full() {

twilight-model 0.15.0-rc.1/src/application/interaction/application_command/option.rs

73	impl<'de> Deserialize<'de> for CommandDataOption {
74	#[allow(clippy::too_many_lines)]
75	fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
132	#[allow(clippy::too_many_lines)]
133	fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {

twilight-model 0.15.0-rc.1/src/application/interaction/application_command/resolved.rs

114	#[test]
115	#[allow(clippy::too_many_lines)]
116	fn test_data_resolved() -> Result<(), TimestampParseError> {

twilight-model 0.15.0-rc.1/src/application/interaction/mod.rs

186	#[allow(clippy::too_many_lines)]
187	fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
434	#[test]
435	#[allow(clippy::too_many_lines)]
436	fn test_interaction_full() -> Result<(), TimestampParseError> {

twilight-model 0.15.0-rc.1/src/channel/message/component/mod.rs

214	#[allow(clippy::too_many_lines)]
215	fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
685	#[allow(clippy::too_many_lines)]
686	#[test]

twilight-model 0.15.0-rc.1/src/channel/message/embed/mod.rs

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

twilight-model 0.15.0-rc.1/src/channel/message/interaction.rs

39	#[allow(clippy::too_many_lines)]
40	#[test]

twilight-util 0.15.0-rc.1/src/builder/command.rs

1412	#[test]
1413	#[allow(clippy::too_many_lines)]
1414	fn construct_command_with_builder() {

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

187	impl Display for ComponentValidationError {
188	#[allow(clippy::too_many_lines)]
189	fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {

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

169	impl Display for ValidationError {
170	#[allow(clippy::too_many_lines)]
171	fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {

twobit 0.2.1/src/convert/fasta.rs

54	/// Extract all the necessary information from the Fasta file
55	#[allow(clippy::too_many_lines)]
56	fn parse_fasta_file<R: Read>(reader: &mut R) -> Result<Self, Error> {

twobit 0.2.1/src/convert/mod.rs

99	/// Convert and write data from a `SequenceRead` into a new 2bit file.
100	#[allow(clippy::too_many_lines)]
101	pub fn to_2bit<'a>(

typestate-proc-macro 0.9.0-rc2/src/lib.rs

39	/// See the module documentation for a full featured tutorial on how to use `#[typestate]`.
40	#[allow(clippy::too_many_lines)] // TODO handle this
41	#[proc_macro_attribute]

typical 0.9.2/src/generate_rust.rs

54	// Generate Rust code from a schema and its transitive dependencies.
55	#[allow(clippy::too_many_lines)]
56	pub fn generate(
441	// Write a schema, including a trailing line break if there was anything to render.
442	#[allow(clippy::too_many_lines)]
443	fn write_schema<T: Write>(
1898	// `payload_atlas` is never read.
1899	#[allow(clippy::too_many_lines)]
1900	fn write_serialization_invocation<T: Write>(
2065	// `payload_size` is never read.
2066	#[allow(clippy::too_many_lines)]
2067	fn write_deserialization_invocation<T: Write>(

typical 0.9.2/src/generate_typescript.rs

124	// Generate TypeScript code from a schema and its transitive dependencies.
125	#[allow(clippy::too_many_lines)]
126	pub fn generate(
548	// Write a schema, including a trailing line break if there was anything to render.
549	#[allow(clippy::too_many_lines)]
550	fn write_schema<T: Write>(
1704	// - `payload` (in)
1705	#[allow(clippy::too_many_lines)]
1706	fn write_atlas_calculation<T: Write>(
1967	// `payloadAtlas` is never read.
1968	#[allow(clippy::too_many_lines)]
1969	fn write_serialization_invocation<T: Write>(
2195	// - If `type_variant` is `Custom`, then `offset` must be 0.
2196	#[allow(clippy::too_many_lines)]
2197	fn write_deserialization_invocation<T: Write>(

typical 0.9.2/src/parser.rs

233	// Parse a schema.
234	#[allow(clippy::too_many_lines)]
235	fn parse_schema(

umpl 1.1.0/src/eval.rs

451	}
452	#[allow(clippy::too_many_lines)]
453	pub fn find_variables(&mut self, body: Vec<Thing>) -> Option<Stopper> {
639	}
640	#[allow(clippy::too_many_lines)]
641	fn find_pointer_in_stuff(&mut self, stuff: &Stuff) -> LiteralOrFile {

umpl 1.1.0/src/lexer.rs

118	#[allow(clippy::too_many_lines)]
119	fn string(&mut self) {

umpl 1.1.0/src/parser/mod.rs

139	}
140	#[allow(clippy::too_many_lines)]
141	fn parse_from_token(&mut self) -> Option<Thing> {

umpl 1.1.0/src/token.rs

89	impl TokenType {
90	#[allow(clippy::too_many_lines)]
91	pub fn r#do(&self, args: &[LiteralType], line: i32) -> LiteralType {

uniaxe 0.1.1/src/lib.rs

3	#[warn(clippy::all, clippy::pedantic)]
4	#[allow(clippy::too_many_lines)]
5	pub mod lookup;

uniresid 0.1.4/src/uri.rs

1449	#[test]
1450	#[allow(clippy::too_many_lines)]
1451	fn normalize_path() {
1652	#[test]
1653	#[allow(clippy::too_many_lines)]
1654	fn reference_resolution() {
1862	#[test]
1863	#[allow(clippy::too_many_lines)]
1864	fn generate_string() {

unquote 0.0.6/src/lib.rs

65	//TODO: Make errors specific even if the token type is mismatched outright.
66	#[allow(clippy::too_many_lines)]
67	fn unquote_inner(

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

153	/// shows submodule status information.
154	#[allow(clippy::too_many_lines, clippy::useless_let_if_seq)]
155	fn status_short(repo: &Repository, statuses: &git2::Statuses) -> String {

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

59	// pointing to nothing.
60	#[allow(clippy::too_many_lines)]
61	pub(crate) fn real_update(git_config: &GitConfig) -> Result<bool> {

vsmtp-auth 2.0.1-rc.4/src/dkim/signature.rs

168	#[allow(clippy::too_many_lines)]
169	fn from_str(s: &str) -> Result<Self, Self::Err> {

vsmtp-auth 2.0.1-rc.4/src/dmarc/record.rs

154	#[allow(clippy::too_many_lines)]
155	fn from_str(s: &str) -> Result<Self, Self::Err> {

vsmtp-mail-parser 2.0.1-rc.4/src/tests/mime_parser/mime1.rs

28	#[allow(clippy::too_many_lines)]
29	#[test]

vsmtp-mail-parser 2.0.1-rc.4/src/tests/mime_parser/rfc2049/a.rs

13	#[test]
14	#[allow(clippy::too_many_lines)]
15	#[ignore]

vsmtp-protocol 2.0.1-rc.4/src/receiver.rs

352	/// * the `Vec<u8>` is the bytes read with the SMTP verb "DATA\r\n"
353	#[allow(clippy::too_many_lines)]
354	async fn smtp_handshake(&mut self) -> std::io::Result<HandshakeOutcome> {

vsmtp-server 2.0.1-rc.4/src/delivery/deliver.rs

86

/// * failed to copy the email to other queues or remove it from the delivery queue.

87

#[allow(clippy::too_many_lines)]

88

#[tracing::instrument(name = "delivery", skip_all, err, fields(uuid = %process_message.message_uuid))]

vsmtp-server 2.0.1-rc.4/src/on_mail.rs

76	#[allow(clippy::too_many_lines)]
77	async fn on_mail_priv(

vsmtp-server 2.0.1-rc.4/src/processing/mod.rs

47	#[allow(clippy::too_many_lines)]
48	#[tracing::instrument(name = "working", skip_all)]

vsmtp-server 2.0.1-rc.4/src/receiver/handler.rs

176	#[allow(clippy::too_many_lines)]
177	async fn on_rcpt_to(&mut self, ctx: &mut ReceiverContext, args: RcptToArgs) -> Reply {

vsmtp-server 2.0.1-rc.4/src/receiver/post_transaction.rs

70	#[allow(clippy::too_many_lines)]
71	pub(super) async fn on_message_inner(

vsop87 2.1.0/src/lib.rs

706	/// ```
707	#[allow(clippy::too_many_lines)]
708	pub fn earth_moon(jde: f64) -> VSOP87Elements {

vsop87 2.1.0/src/vsop87a/mod.rs

233	/// ```
234	#[allow(clippy::too_many_lines)]
235	pub fn earth_moon(jde: f64) -> RectangularCoordinates {

wasm3-provider 1.0.0/src/lib.rs

123	// TODO: refactor to avoid skipping this lint
124	#[allow(clippy::too_many_lines)]
125	fn init(&mut self, host: Arc<ModuleState>) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {

windmark 0.1.20/src/router.rs

256	#[allow(clippy::too_many_lines)]
257	async fn handle(

wolfengine 3.0.2/src/system/net/tcp.rs

228	// TODO: fix too_many_arguments
229	#[allow(clippy::too_many_lines)]
230	async fn handle_ws_connection<S>(
695	#[allow(clippy::too_many_lines)]
696	#[tokio::main]

wolfengine 3.0.2/src/system/net/tcp_fiber.rs

269	#[allow(clippy::too_many_lines)]
270	#[tokio::main]

wordle-solvers 0.9.0/src/words.rs

1	#[allow(clippy::too_many_lines)]
2	pub fn word_list(easy: bool) -> Vec<&'static str> {
1198	#[allow(clippy::too_many_lines)]
1199	fn solutions() -> Vec<&'static str> {

xaskpass 2.5.2/src/dialog/mod.rs

808	impl Dialog {
809	#[allow(clippy::too_many_lines)]
810	pub fn new(

xaskpass 2.5.2/src/event.rs

273	#[allow(clippy::too_many_lines)]
274	fn handle_event(&mut self, dialog: &mut Dialog, event: Event) -> Result<State> {

xaskpass 2.5.2/src/main.rs

185	#[allow(clippy::too_many_lines)]
186	async fn run_xcontext(

xgboost-rs 0.1.3/src/booster.rs

1308	#[test]
1309	#[allow(clippy::too_many_lines)]
1310	fn pred_from_dmat() {

xlib-display-server 0.1.0/src/xwrap.rs

139	#[must_use]
140	#[allow(clippy::too_many_lines)]
141	pub fn new() -> Self {

yedb 0.4.11/src/server.rs

92	/// Should not panic
93	#[allow(clippy::too_many_lines)]
94	pub async fn process_request(

yedb 0.4.11/src/yedb-cli.rs

820	#[allow(clippy::too_many_lines)]
821	#[tokio::main(worker_threads = 1)]

yuvxyb 0.3.0/src/yuv_rgb/transfer.rs

42	#[allow(clippy::too_many_lines)]
43	fn to_gamma(&self, input: Vec<[f32; 3]>) -> Result<Vec<[f32; 3]>> {

yuvxyb 0.3.0/src/yuv_rgb.rs

56	#[allow(clippy::too_many_lines)]
57	fn ypbpr_to_ycbcr<T: Pixel>(

zkp-stark 0.2.1/src/prover.rs

345	// TODO: Split up
346	#[allow(clippy::too_many_lines)]
347	pub fn prove(constraints: &Constraints, trace: &TraceTable) -> Result<Proof> {
972	#[allow(clippy::cognitive_complexity)]
973	#[allow(clippy::too_many_lines)]
974	fn fib_proof_test() {

zkp-stark 0.2.1/src/solidity_seralizer.rs

58	// TODO - Make this function smaller
59	#[allow(clippy::too_many_lines)]
60	pub fn proof_serialize(

zkp-stark 0.2.1/src/verifier.rs

176	// TODO: Refactor into smaller function
177	#[allow(clippy::too_many_lines)]
178	pub fn verify(constraints: &Constraints, proof: &Proof) -> Result<()> {

zkp-u256 0.2.1/src/arch/x86_64_adx/mod.rs

422	// This assembly block needs to be contiguous
423	#[allow(clippy::too_many_lines)]
424	#[inline(always)]

zoog 0.8.1/src/bin/opusgain.rs

231	#[allow(clippy::too_many_lines)]
232	fn main_impl() -> Result<(), AppError> {

zspell 0.3.3/src/affix.rs

264	#[allow(clippy::unnecessary_wraps)]
265	#[allow(clippy::too_many_lines)]
266	fn from_parsed(v: Vec<AffixNode>) -> Result<Self, Error> {

zune-jpeg 0.2.0/src/huffman.rs

70	clippy::cast_sign_loss,
71	clippy::too_many_lines
72	)]

zune-jpeg 0.2.0/src/idct/avx2.rs

58	#[allow(
59	clippy::too_many_lines,
60	clippy::cast_possible_truncation,

zune-jpeg 0.2.0/src/mcu.rs

123	/// here.
124	#[allow(clippy::similar_names,clippy::too_many_lines,clippy::cast_possible_truncation)]
125	#[inline(never)]

zune-jpeg 0.2.0/src/mcu_prog.rs

247	#[rustfmt::skip]
248	#[allow(clippy::too_many_lines)]
249	fn parse_entropy_coded_data(

aa_similarity 0.1.0/src/lib.rs

28	// #![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::cargo)]
29	#![allow(clippy::match_same_arms, clippy::too_many_lines)]

aerospike 1.2.0/src/lib.rs

36	clippy::similar_names,
37	clippy::too_many_lines,
38	clippy::unknown_clippy_lints,

afe4404 0.2.2/src/measurement_window/mod.rs

33	clippy::cast_lossless,
34	clippy::too_many_lines
35	)]
388	clippy::cast_lossless,
389	clippy::too_many_lines
390	)]

affix 0.1.2/src/lib.rs

135	clippy::needless_doctest_main,
136	clippy::too_many_lines
137	)]

aide 0.10.0/src/lib.rs

115	clippy::wildcard_imports,
116	clippy::too_many_lines,
117	clippy::single_match_else,

alt_serde 1.0.119/src/lib.rs

128	similar_names,
129	too_many_lines,
130	// preference

alt_serde_derive 1.0.119/src/lib.rs

48	clippy::struct_excessive_bools,
49	clippy::too_many_lines,
50	clippy::unseparated_literal_suffix,

alt_serde_json 1.0.61/src/lib.rs

344	clippy::single_match_else,
345	clippy::too_many_lines,
346	clippy::unreadable_literal,

amadeus-aws 0.4.3/src/lib.rs

24	clippy::if_not_else,
25	clippy::too_many_lines,
26	clippy::must_use_candidate,

amadeus-core 0.4.3/src/par_sink/fork.rs

2	#![allow(unsafe_code)]
3	#![allow(clippy::type_complexity, clippy::too_many_lines)]

amadeus-core 0.4.3/src/par_stream.rs

4	#![allow(clippy::too_many_lines, unused_qualifications)]

amadeus-derive 0.4.3/src/lib.rs

23	clippy::doc_markdown,
24	clippy::too_many_lines,
25	clippy::useless_let_if_seq

amadeus-serde 0.4.3/src/impls.rs

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

amadeus-types 0.4.3/src/lib.rs

30	clippy::inline_always,
31	clippy::too_many_lines,
32	clippy::missing_panics_doc

anyhow 1.0.68/tests/test_ensure.rs

12	clippy::redundant_pattern_matching,
13	clippy::too_many_lines,
14	clippy::unit_arg,

aragog 0.17.0/src/error/arango_error.rs

1	#![allow(clippy::too_many_lines)]
2	use thiserror::Error;

arn-language 1.2.1/src/main.rs

6	clippy::wildcard_imports,
7	clippy::too_many_lines,
8	// I have a lot of TODOs, so this is reduntant

async-graphql 5.0.5/src/lib.rs

162	#![allow(clippy::explicit_iter_loop)]
163	#![allow(clippy::too_many_lines)]
164	#![allow(clippy::cast_sign_loss)]

async-trait 0.1.64/src/lib.rs

314	clippy::similar_names,
315	clippy::too_many_lines
316	)]

async-trait-fn 0.1.64/src/lib.rs

66	clippy::similar_names,
67	clippy::too_many_lines
68	)]

atat 0.18.0/src/lib.rs

213	#![allow(clippy::use_self)]
214	#![allow(clippy::too_many_lines)]
215	#![allow(clippy::module_name_repetitions)]

atat_derive 0.18.0/src/lib.rs

35	#![allow(clippy::module_name_repetitions)]
36	#![allow(clippy::too_many_lines)]
37	#![allow(clippy::similar_names)]

atomic-maybe-uninit 0.2.15/src/lib.rs

85	clippy::module_inception,
86	clippy::too_many_lines,
87	clippy::type_complexity

attheme 0.3.0/src/default_themes.rs

20	#![allow(clippy::unreadable_literal, clippy::too_many_lines)]

audio_device_tester 0.1.5/src/main.rs

1	#![allow(clippy::too_many_lines)]
2	#![allow(clippy::missing_errors_doc)]

auto_enums 0.8.0/src/lib.rs

863	#![warn(clippy::pedantic)]
864	#![allow(clippy::too_many_lines)]

av1an-core 0.4.0/src/lib.rs

8	#![allow(clippy::too_many_arguments)]
9	#![allow(clippy::too_many_lines)]
10	#![allow(clippy::cast_possible_wrap)]

babycat 0.0.14/src/lib.rs

101	#![warn(clippy::pedantic)]
102	#![allow(clippy::too_many_lines)]
103	#![allow(clippy::must_use_candidate)]

basic-toml 0.1.1/tests/de-errors.rs

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

bluedroid 0.3.6/src/gatt_server/gatts_event_handler.rs

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

boa_cli 0.16.0/src/main.rs

50	clippy::missing_panics_doc,
51	clippy::too_many_lines,
52	clippy::unreadable_literal,

boa_engine 0.16.0/src/lib.rs

61	clippy::missing_panics_doc,
62	clippy::too_many_lines,
63	clippy::unreadable_literal,

boa_interner 0.16.0/src/lib.rs

61	clippy::missing_panics_doc,
62	clippy::too_many_lines,
63	clippy::unreadable_literal,

boa_unicode 0.16.0/src/lib.rs

58	clippy::missing_panics_doc,
59	clippy::too_many_lines,
60	clippy::unreadable_literal,

boreal 0.1.0/src/lib.rs

59	#![allow(clippy::match_same_arms)]
60	#![allow(clippy::too_many_lines)]
61	#![allow(clippy::single_match_else)]

boreal-parser 0.1.0/src/lib.rs

30	#![allow(clippy::range_plus_one)]
31	#![allow(clippy::too_many_lines)]
32	#![allow(clippy::single_match_else)]

breadx 3.1.0/src/display/tests/setup.rs

6	#![allow(clippy::unreadable_literal, clippy::too_many_lines)]

btle 0.1.4/src/lib.rs

5	// Clippy complains about the mass enum matching functions
6	#![allow(clippy::too_many_lines)]
7	// #[must_use] doesn't need to be on absolutely everything even though it should.

bve 0.0.1/src/lib.rs

19	#![allow(clippy::cognitive_complexity)] // This is dumb
20	#![allow(clippy::too_many_lines)] // This is also dumb
21	// Annoying/irrelevant clippy Restrictions

bve-derive 0.0.1/src/lib.rs

20	#![allow(clippy::single_match_else)] // Future expansion
21	#![allow(clippy::too_many_lines)] // This is also dumb
22	// Annoying/irrelevant clippy Restrictions
44	#![allow(clippy::shadow_same)]
45	#![allow(clippy::too_many_lines)]
46	#![allow(clippy::unimplemented)] // Specific use case proc macro, lots of holes

bve-native 0.0.1/src/lib.rs

59	#![allow(clippy::cognitive_complexity)] // This is dumb
60	#![allow(clippy::too_many_lines)] // This is also dumb
61	// Annoying/irrelevant clippy Restrictions

camelpaste 0.1.0/src/lib.rs

145	clippy::needless_doctest_main,
146	clippy::too_many_lines
147	)]

cargo-cache 0.8.3/src/main.rs

57

// #![allow(clippy::redundant_pub_crate)] // conflicts with unreachable_pub

58

#![allow(clippy::too_many_lines, clippy::unused_self)] // I don't care

59

#![allow(clippy::wildcard_imports)] // breaks code, false positives

cargo-config2 0.1.4/src/lib.rs

60	clippy::single_match,
61	clippy::too_many_lines
62	)]

cargo-expand 1.0.40/src/main.rs

12	clippy::struct_excessive_bools,
13	clippy::too_many_lines,
14	clippy::trivially_copy_pass_by_ref

cargo-hack 0.5.27/src/main.rs

3	#![warn(clippy::pedantic)]
4	#![allow(clippy::cast_lossless, clippy::struct_excessive_bools, clippy::too_many_lines)]

cargo-llvm-cov 0.5.9/src/main.rs

8	clippy::struct_excessive_bools,
9	clippy::too_many_lines
10	)]

cargo-llvm-lines 0.4.23/src/main.rs

10	clippy::struct_excessive_bools,
11	clippy::too_many_lines,
12	clippy::uninlined_format_args,

cargo-no-dev-deps 0.2.1/src/main.rs

3	#![warn(clippy::pedantic)]
4	#![allow(clippy::too_many_lines)]

cargo-print 0.1.6/src/main.rs

17	)] // from https://github.com/rust-unofficial/patterns/blob/master/anti_patterns/deny-warnings.md
18	#![allow(clippy::if_not_else, clippy::too_many_lines, clippy::let_underscore_drop)]

cargo-tally 1.0.22/src/lib.rs

19	clippy::significant_drop_in_scrutinee,
20	clippy::too_many_lines,
21	clippy::unseparated_literal_suffix

cargo-tally 1.0.22/src/main.rs

12	clippy::single_match_else,
13	clippy::too_many_lines,
14	clippy::type_complexity,

cetkaik_full_state_transition 1.3.1/src/lib.rs

2	#![allow(
3	clippy::too_many_lines,
4	clippy::missing_errors_doc,

cetkaik_yhuap_move_candidates 1.3.1/src/lib.rs

2	#![allow(
3	clippy::too_many_lines,
4	clippy::non_ascii_literal,

circe 0.1.5/src/lib.rs

23	#![warn(missing_docs)]
24	#![allow(clippy::too_many_lines)]
25	#![cfg_attr(docsrs, feature(doc_cfg))]

config-loader 2.2.3/src/main.rs

21	clippy::similar_names,
22	clippy::too_many_lines,
23	clippy::unnecessary_wraps,

constellation-rs 0.2.0-alpha.2/src/bin/constellation/args.rs

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

constellation-rs 0.2.0-alpha.2/src/bin/constellation/bridge.rs

23	clippy::shadow_unrelated,
24	clippy::too_many_lines
25	)]

constellation-rs 0.2.0-alpha.2/src/bin/constellation/main.rs

71	clippy::shadow_unrelated,
72	clippy::too_many_lines,
73	clippy::unnested_or_patterns

constellation-rs 0.2.0-alpha.2/src/bin/constellation/master.rs

1	#![allow(clippy::too_many_lines, clippy::erasing_op)]

coprosize 1.0.4/src/lib.rs

7	#![warn(clippy::nursery, clippy::pedantic)]
8	#![allow(clippy::too_many_lines, clippy::unreadable_literal)]

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

coprosize 1.0.4/src/menu.rs

7	#![warn(clippy::nursery, clippy::pedantic)]
8	#![allow(clippy::too_many_lines)]

cruiser 0.2.0/src/lib.rs

12	clippy::missing_errors_doc,
13	clippy::too_many_lines,
14	clippy::mut_mut

crystalorb 0.3.0/src/lib.rs

11	clippy::redundant_feature_names, // Required because of feature names in Bevy turbulence plugin
12	clippy::too_many_lines,
13	clippy::module_name_repetitions,

cw-semver 1.0.14/tests/test_version.rs

2	clippy::nonminimal_bool,
3	clippy::too_many_lines,
4	clippy::wildcard_imports

cxx-build 1.0.88/src/lib.rs

75	clippy::too_many_arguments,
76	clippy::too_many_lines,
77	clippy::toplevel_ref_arg,

cxx-gen 0.7.88/src/lib.rs

35	clippy::too_many_arguments,
36	clippy::too_many_lines,
37	clippy::toplevel_ref_arg,

cxxbridge-cmd 1.0.88/src/main.rs

25	clippy::too_many_arguments,
26	clippy::too_many_lines,
27	clippy::toplevel_ref_arg,

cxxbridge-macro 1.0.88/src/lib.rs

24	clippy::too_many_arguments,
25	clippy::too_many_lines,
26	clippy::toplevel_ref_arg,

db-dump 0.4.1/src/lib.rs

11	clippy::never_loop,
12	clippy::too_many_lines,
13	clippy::uninlined_format_args,

db-dump-concat 0.1.1/main.rs

22	clippy::never_loop,
23	clippy::too_many_lines,
24	clippy::trivially_copy_pass_by_ref

dbg-pls 0.3.4/src/impls/syn/gen.rs

4	#![allow(clippy::too_many_lines)]
5	use crate::{DebugPls, Formatter};

dcv-color-primitives 0.5.1/tests/tests.rs

13	)]
14	#![allow(clippy::too_many_lines)] // This requires effort to handle

dissimilar 1.0.6/src/lib.rs

55	clippy::similar_names,
56	clippy::too_many_lines,
57	clippy::unseparated_literal_suffix,

dragonbox 0.1.4/src/lib.rs

67	clippy::similar_names,
68	clippy::too_many_lines,
69	clippy::toplevel_ref_arg,

dylint 2.1.3/src/toml.rs

9	#![allow(clippy::single_char_pattern)]
10	#![allow(clippy::too_many_lines)]
11	#![allow(clippy::uninlined_format_args)]

easy-ext 1.0.1/src/lib.rs

187	clippy::similar_names,
188	clippy::too_many_lines
189	)]

ethereum-forkid 0.11.1/src/lib.rs

1	#![deny(missing_docs)]
2	#![allow(clippy::redundant_else, clippy::too_many_lines)]
3	#![doc = include_str!("../README.md")]

exa 0.10.1/src/main.rs

19	#![allow(clippy::option_if_let_else)]
20	#![allow(clippy::too_many_lines)]
21	#![allow(clippy::unused_self)]

exacl 0.10.0/src/bindings.rs

9	deref_nullptr, // https://github.com/rust-lang/rust-bindgen/issues/1651
10	clippy::too_many_lines,
11	clippy::borrow_as_ptr

exonum-merkledb 1.0.0/src/indexes/proof_list/tests.rs

17	#![allow(clippy::too_many_lines)]

exonum-merkledb 1.0.0/src/indexes/proof_map/tests.rs

15	#![allow(clippy::too_many_lines)]

filmborders 0.0.32/src/lib.rs

1	// #![allow(warnings)]
2	#![allow(clippy::too_many_lines)]
3	#![allow(clippy::missing_errors_doc)]

fixed-map-derive 0.8.1/src/lib.rs

51	// style choice
52	clippy::too_many_lines,
53	// false positive

fruit-salad_proc-macro-definitions 0.0.1/src/lib.rs

3	#![warn(clippy::pedantic)]
4	#![allow(clippy::semicolon_if_nothing_returned, clippy::too_many_lines)]

funcmap_derive 0.1.2/src/lib.rs

20	#![allow(clippy::module_name_repetitions)]
21	#![allow(clippy::too_many_lines)]
22	#![deny(rustdoc::broken_intra_doc_links)]

gex 0.3.7/src/main.rs

3	clippy::cast_possible_truncation,
4	clippy::too_many_lines,
5	clippy::missing_errors_doc,

ghost 0.1.7/src/lib.rs

173	clippy::needless_pass_by_value,
174	clippy::too_many_lines
175	)]

girt-config 2.2.0/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

girt-core 2.2.1/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

girt-display 2.2.0/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

girt-git 2.2.0/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

girt-input 2.2.0/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

girt-runtime 0.1.0/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

girt-testutils 0.1.0/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

girt-todo-file 2.2.0/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

girt-view 2.2.0/src/lib.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

git_function_history 0.7.0/src/lib.rs

12	clippy::multiple_crate_versions,
13	clippy::too_many_lines
14	)]

git-interactive-rebase-tool 2.2.1/src/main.rs

62	clippy::tabs_in_doc_comments,
63	clippy::too_many_lines
64	)]

gonk 0.1.2/src/main.rs

5	clippy::cast_lossless,
6	clippy::too_many_lines,
7	clippy::cast_possible_truncation,

grafbase 0.15.0/tests/pagination.rs

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

grass 0.12.2/src/lib.rs

55	// to no longer be necessary
56	clippy::too_many_lines,
57	clippy::cast_possible_truncation,

grass_compiler 0.12.2/src/lib.rs

55	// to no longer be necessary
56	clippy::too_many_lines,
57	clippy::cast_possible_truncation,

haddock 0.1.3/src/main.rs

3	#![allow(clippy::struct_excessive_bools)]
4	#![allow(clippy::too_many_lines)]

headless_chrome 1.0.2/src/lib.rs

65	clippy::unreadable_literal, // not really applicable for timestamps
66	clippy::too_many_lines,
67	clippy::type_repetition_in_bounds,

headless_chrome_fork 1.0.2/src/lib.rs

66	clippy::unreadable_literal, // not really applicable for timestamps
67	clippy::too_many_lines,
68	clippy::type_repetition_in_bounds,

how-install-tealdeer 1.5.0/src/lib.rs

16	#![allow(clippy::struct_excessive_bools)]
17	#![allow(clippy::too_many_lines)]

html5gum 0.5.2/src/lib.rs

17	#![allow(clippy::missing_errors_doc)]
18	#![allow(clippy::too_many_lines)]

iced_aw 0.3.0/src/lib.rs

44	clippy::missing_const_for_fn,
45	clippy::too_many_lines
46	)]

imdl 0.1.12/src/lib.rs

18	clippy::struct_excessive_bools,
19	clippy::too_many_lines,
20	clippy::unseparated_literal_suffix,

interim 0.1.0/src/lib.rs

87	clippy::module_name_repetitions,
88	clippy::too_many_lines,
89	clippy::cast_lossless,

just 1.13.0/src/lib.rs

10	clippy::struct_excessive_bools,
11	clippy::too_many_lines,
12	clippy::type_repetition_in_bounds,

k8s-openapi 0.17.0/src/lib.rs

12	clippy::single_match_else,
13	clippy::too_many_lines,
14	clippy::type_complexity,

k8s-openapi-codegen-common 0.17.0/src/lib.rs

7	clippy::too_many_arguments,
8	clippy::too_many_lines,
9	)]

k8s-openapi-derive 0.17.0/src/lib.rs

4	#![allow(
5	clippy::too_many_lines,
6	)]

kdl-schema 0.1.0/src/schema_schema.rs

1	#![allow(clippy::too_many_lines, clippy::wildcard_imports)]

kvarn 0.5.0/src/lib.rs

37	// I WANT A LONG fn!
38	clippy::too_many_lines,
39	// I know what I'm doing with unwraps. They should all be motivated.

kvarn_async 0.5.0/src/lib.rs

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

lembas 0.4.0/src/lib.rs

2	#![allow(
3	clippy::too_many_lines,
4	clippy::module_name_repetitions,

libmangrove 0.1.2/src/lib.rs

23	#![allow(clippy::must_use_candidate)]
24	#![allow(clippy::too_many_lines)]
25	#![allow(clippy::module_name_repetitions)]

linkme-impl 0.3.7/src/lib.rs

3	clippy::needless_pass_by_value,
4	clippy::too_many_lines,
5	clippy::uninlined_format_args,

lngcnv 1.8.3/src/lang/modeng.rs

8	#![warn(clippy::nursery, clippy::pedantic)]
9	#![allow(clippy::too_many_lines, clippy::unicode_not_nfc)]
10	#![allow(clippy::string_lit_as_bytes)]

lngcnv 1.8.3/src/lang/modlat.rs

8	#![warn(clippy::nursery, clippy::pedantic)]
9	#![allow(clippy::too_many_lines, clippy::unicode_not_nfc)]
10	#![allow(clippy::string_lit_as_bytes)]

lngcnv 1.8.3/src/lang/modpol.rs

8	#![warn(clippy::nursery, clippy::pedantic)]
9	#![allow(clippy::similar_names, clippy::too_many_lines, clippy::unicode_not_nfc)]
10	#![allow(clippy::string_lit_as_bytes)]

lngcnv 1.8.3/src/lang/modque.rs

8	#![warn(clippy::nursery, clippy::pedantic)]
9	#![allow(clippy::too_many_lines, clippy::unicode_not_nfc)]
10	#![allow(clippy::string_lit_as_bytes)]

lngcnv 1.8.3/src/lang/modspa.rs

8	#![warn(clippy::nursery, clippy::pedantic)]
9	#![allow(clippy::similar_names, clippy::too_many_lines, clippy::unicode_not_nfc)]
10	#![allow(clippy::string_lit_as_bytes)]

lngcnv 1.8.3/src/lang/modtca.rs

8	#![warn(clippy::nursery, clippy::pedantic)]
9	#![allow(clippy::similar_names, clippy::too_many_lines, clippy::unicode_not_nfc)]
10	#![allow(clippy::string_lit_as_bytes)]

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

lngcnv 1.8.3/src/menu.rs

7	#![warn(clippy::nursery, clippy::pedantic)]
8	#![allow(clippy::too_many_lines)]

lofty 0.11.0/src/lib.rs

116	unknown_lints,
117	clippy::too_many_lines,
118	clippy::cast_precision_loss,

lucia-macros 0.2.0/src/lib.rs

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

markdown 1.0.0-alpha.6/src/lib.rs

18	#![allow(clippy::must_use_candidate)]
19	#![allow(clippy::too_many_lines)]
20	#![doc(

mcrypt 0.1.4/src/lib.rs

24	#![allow(clippy::must_use_candidate)]
25	#![allow(clippy::too_many_lines)]
26	#![allow(clippy::module_name_repetitions)]

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

65	clippy::unreadable_literal, // not really applicable for timestamps
66	clippy::too_many_lines,
67	clippy::type_repetition_in_bounds,

mdxjs 0.1.6/src/lib.rs

8	#![allow(clippy::must_use_candidate)]
9	#![allow(clippy::too_many_lines)]
10	#![allow(clippy::struct_excessive_bools)]

memedsn 0.1.0/src/lib.rs

35	clippy::struct_excessive_bools,
36	clippy::too_many_lines,
37	clippy::unreadable_literal

memega 0.1.0/src/lib.rs

33	clippy::similar_names,
34	clippy::too_many_lines,
35	clippy::unreadable_literal

memegeom 0.1.0/src/lib.rs

35	clippy::struct_excessive_bools,
36	clippy::too_many_lines,
37	clippy::unreadable_literal

memeroute 0.1.0/src/lib.rs

36	clippy::struct_excessive_bools,
37	clippy::too_many_lines,
38	clippy::unreadable_literal

memeroute-gui 0.1.0/src/lib.rs

35	clippy::struct_excessive_bools,
36	clippy::too_many_lines,
37	clippy::unreadable_literal

memestat 0.1.0/src/lib.rs

33	clippy::similar_names,
34	clippy::too_many_lines,
35	clippy::unreadable_literal

memestr 0.1.0/src/lib.rs

35	clippy::struct_excessive_bools,
36	clippy::too_many_lines,
37	clippy::unreadable_literal

mhrono 0.1.0/src/lib.rs

35	clippy::struct_excessive_bools,
36	clippy::too_many_lines,
37	clippy::unreadable_literal

microserde 0.1.13/src/lib.rs

148	clippy::single_match_else,
149	clippy::too_many_lines,
150	)]

minesweeprs 0.2.0/src/lib.rs

1	#![doc = include_str!("../README.md")]
2	#![allow(clippy::too_many_lines)]
3	use std::cmp::{max, min, Ordering};

miniserde 0.1.28/src/lib.rs

159	clippy::single_match_else,
160	clippy::too_many_lines,
161	)]

miniserde-miku 0.1.23/src/lib.rs

158	clippy::single_match_else,
159	clippy::too_many_lines,
160	)]

mm0_util 0.1.4/src/lib.rs

49	clippy::shadow_unrelated,
50	clippy::too_many_lines,
51	clippy::use_self

mm0b_parser 0.1.4/src/lib.rs

50	clippy::shadow_unrelated,
51	clippy::too_many_lines,
52	clippy::use_self

moldenfile 0.1.0/src/lib.rs

35	clippy::struct_excessive_bools,
36	clippy::too_many_lines,
37	clippy::unreadable_literal

monzo-lib 0.4.4/src/endpoints/transactions.rs

178	mod tests {
179	#![allow(clippy::too_many_lines, clippy::non_ascii_literal)]
180	use super::Transaction;

mprocs-vt100 0.1.1/src/lib.rs

45	#![allow(clippy::too_many_arguments)]
46	#![allow(clippy::too_many_lines)]
47	#![allow(clippy::type_complexity)]

nixpacks 1.1.1/src/lib.rs

9	clippy::cast_precision_loss,
10	clippy::too_many_lines,
11	clippy::doc_markdown,

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

20	#![allow(clippy::cast_possible_truncation)]
21	#![allow(clippy::too_many_lines)]

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

13	clippy::empty_enum,
14	clippy::too_many_lines,
15	unknown_lints,

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

13	clippy::empty_enum,
14	clippy::too_many_lines,
15	unknown_lints,

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

12	clippy::cognitive_complexity,
13	clippy::too_many_lines,
14	clippy::upper_case_acronyms,

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

nucleob 1.1.1/src/stat.rs

7	#![warn(clippy::nursery, clippy::pedantic)]
8	#![allow(clippy::missing_panics_doc, clippy::too_many_lines)]

openshift-openapi 0.3.1/src/lib.rs

11	clippy::single_match_else,
12	clippy::too_many_lines,
13	clippy::type_complexity,

paste 1.0.11/src/lib.rs

145	clippy::needless_doctest_main,
146	clippy::too_many_lines
147	)]

pin-project-internal 1.0.12/src/lib.rs

16	clippy::single_match_else,
17	clippy::too_many_lines,
18	clippy::unnested_or_patterns

polywrap_paste 1.0.0/src/lib.rs

145	clippy::needless_doctest_main,
146	clippy::too_many_lines
147	)]

portier_broker 0.5.2/src/main.rs

9	clippy::too_many_arguments,
10	clippy::too_many_lines,
11	clippy::unused_async,

prettyplease 0.1.23/src/lib.rs

335	clippy::similar_names,
336	clippy::too_many_lines,
337	clippy::unused_self,

proc-macro-hack 0.5.20+deprecated/src/lib.rs

153	clippy::needless_pass_by_value,
154	clippy::too_many_lines,
155	clippy::toplevel_ref_arg

pty-process 0.2.0/src/lib.rs

57	#![allow(clippy::too_many_arguments)]
58	#![allow(clippy::too_many_lines)]
59	#![allow(clippy::type_complexity)]

pyxel-core 1.9.11/src/lib.rs

20	clippy::too_many_arguments,
21	clippy::too_many_lines,
22	clippy::unreadable_literal,

pyxel-engine 1.8.2/src/lib.rs

17	clippy::too_many_arguments,
18	clippy::too_many_lines,
19	clippy::unreadable_literal,

pyxel-extension 1.9.11/src/lib.rs

13	clippy::too_many_arguments,
14	clippy::too_many_lines,
15	clippy::unused_self,

pyxel-wrapper 1.8.2/src/lib.rs

13	clippy::too_many_arguments,
14	clippy::too_many_lines,
15	clippy::unused_self,

rbw 1.4.3/src/bin/rbw/main.rs

10	#![allow(clippy::too_many_arguments)]
11	#![allow(clippy::too_many_lines)]
12	#![allow(clippy::type_complexity)]

rbw 1.4.3/src/bin/rbw-agent/main.rs

10	#![allow(clippy::too_many_arguments)]
11	#![allow(clippy::too_many_lines)]
12	#![allow(clippy::type_complexity)]

rbw 1.4.3/src/lib.rs

10	#![allow(clippy::too_many_arguments)]
11	#![allow(clippy::too_many_lines)]
12	#![allow(clippy::type_complexity)]

rcpp 0.1.3/src/main.rs

29	// These ones should be re-enabled, and possibly selectively disabled
30	#![allow(clippy::too_many_lines)]

rcpp 0.1.3/src/preprocessor/pretoken.rs

1	#![allow(clippy::too_many_lines)]
2	#![allow(clippy::use_self)]

refpack 2.0.0/src/lib.rs

78	// too many lines is a dumb metric
79	#![allow(clippy::too_many_lines)]
80	// causes weirdness with header and reader

reui 0.0.2/src/lib.rs

9	clippy::items_after_statements,
10	clippy::too_many_lines,
11	clippy::too_many_arguments,

rhizome_proc-macro-definitions 0.0.1/src/lib.rs

3	#![warn(clippy::pedantic)]
4	#![allow(clippy::too_many_lines)]

rtop_dev 1.1.0/src/lib.rs

57	clippy::exit,
58	clippy::too_many_lines,
59	clippy::exhaustive_structs,

rtop-rs 1.1.1/src/lib.rs

16	clippy::exit,
17	clippy::too_many_lines,
18	clippy::exhaustive_structs,

rust-query 0.0.0-alpha-1/src/lib.rs

93	// I like my complicated functions
94	#![allow(clippy::too_many_lines)]
95	// It useful

rustflags 0.1.2/src/lib.rs

139	clippy::must_use_candidate,
140	clippy::too_many_lines,
141	clippy::type_complexity,

rustycpp 0.1.6/src/main.rs

38	// These ones should be re-enabled, and possibly selectively disabled
39	#![allow(clippy::too_many_lines)]

rustycpp 0.1.6/src/preprocessor/pretoken.rs

1	//! Pretokens for the preprocessor. Parses very laxly
2	#![allow(clippy::too_many_lines)]
3	#![allow(clippy::use_self)]

ryu 1.0.12/src/lib.rs

98	clippy::similar_names,
99	clippy::too_many_lines,
100	clippy::unreadable_literal,

ryu 1.0.12/tests/s2d_test.rs

31	clippy::similar_names,
32	clippy::too_many_lines,
33	clippy::unreadable_literal,

ryu 1.0.12/tests/s2f_test.rs

31	clippy::similar_names,
32	clippy::too_many_lines,
33	clippy::unreadable_literal,

ryu-js 0.2.2/src/lib.rs

72	clippy::similar_names,
73	clippy::too_many_lines,
74	clippy::unreadable_literal,

ryu-js 0.2.2/tests/s2d_test.rs

32	clippy::similar_names,
33	clippy::too_many_lines,
34	clippy::unreadable_literal,

ryu-js 0.2.2/tests/s2f_test.rs

31	clippy::similar_names,
32	clippy::too_many_lines,
33	clippy::unreadable_literal,

safe-regex-compiler 0.2.5/tests/parser_parse.rs

1	#![forbid(unsafe_code)]
2	#![allow(clippy::too_many_lines)]
3	use safe_regex_compiler::parser::FinalNode::{

semver 1.0.16/tests/test_version.rs

2	clippy::nonminimal_bool,
3	clippy::too_many_lines,
4	clippy::wildcard_imports

semverver 0.1.51/src/bin/cargo-semver.rs

1	#![feature(rustc_private)]
2	#![allow(clippy::too_many_lines)]

semverver 0.1.51/src/lib.rs

4	#![allow(clippy::single_match_else)]
5	#![allow(clippy::too_many_lines)]
6	#![deny(warnings)]

semververfork 0.1.64/src/bin/cargo_semver.rs

2	#![feature(set_stdio)]
3	#![allow(clippy::too_many_lines)]

semververfork 0.1.64/src/lib.rs

3	#![allow(clippy::single_match_else)]
4	#![allow(clippy::too_many_lines)]
5	#![deny(warnings)]

serde 1.0.152/src/lib.rs

136	similar_names,
137	too_many_lines,
138	// preference

serde_closure 0.3.3/tests/smoke.rs

10	#![allow(
11	clippy::too_many_lines,
12	clippy::many_single_char_names,

serde_derive 1.0.152/src/lib.rs

56	clippy::struct_excessive_bools,
57	clippy::too_many_lines,
58	clippy::unseparated_literal_suffix,

serde_derive_internals 0.26.0/lib.rs

31	clippy::struct_excessive_bools,
32	clippy::too_many_lines,
33	clippy::unused_self,

serde_derive_state 0.4.10/src/lib.rs

48	clippy::struct_excessive_bools,
49	clippy::too_many_lines,
50	clippy::unseparated_literal_suffix,

serde_json 1.0.91/src/lib.rs

351	clippy::single_match_else,
352	clippy::too_many_lines,
353	clippy::unreadable_literal,

serde_json 1.0.91/tests/lexical.rs

16	clippy::single_match_else,
17	clippy::too_many_lines,
18	clippy::unreadable_literal,

serde_json 1.0.91/tests/test.rs

9	clippy::shadow_unrelated,
10	clippy::too_many_lines,
11	clippy::unreadable_literal,

serde_json_lenient 0.1.4/src/lib.rs

352	clippy::single_match_else,
353	clippy::too_many_lines,
354	clippy::unreadable_literal,

serde_partiql 1.1.65/src/lib.rs

344	clippy::single_match_else,
345	clippy::too_many_lines,
346	clippy::unreadable_literal,

serde_taml 0.0.3/src/lib.rs

84	#![warn(clippy::pedantic)]
85	#![allow(clippy::if_not_else, clippy::too_many_lines)]
86	#![warn(missing_docs)]

serde_test 1.0.152/src/lib.rs

159	redundant_field_names,
160	too_many_lines,
161	type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772

serde_yaml 0.9.17/src/lib.rs

153	clippy::return_self_not_must_use,
154	clippy::too_many_lines,
155	clippy::uninlined_format_args,

serenity 0.11.5/src/lib.rs

68	clippy::cast_sign_loss,
69	clippy::too_many_lines,
70	clippy::doc_markdown,

snazy 0.50.0/src/main.rs

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

soa_derive_internal 0.12.0/src/lib.rs

3	#![allow(clippy::needless_return, clippy::redundant_field_names)]
4	#![allow(clippy::use_self, clippy::too_many_lines, clippy::missing_panics_doc)]

spirv-layout 1.0.0/src/lib.rs

4	clippy::unreadable_literal,
5	clippy::too_many_lines,
6	clippy::must_use_candidate

sponsor-block 0.6.1/src/lib.rs

65	clippy::similar_names,
66	clippy::too_many_lines,
67	clippy::unnecessary_wraps,

sqlx-migrate 0.6.0/src/cli.rs

2	clippy::struct_excessive_bools,
3	clippy::too_many_lines,
4	unused_imports,

stack-string 0.8.0/src/lib.rs

1	#![allow(clippy::too_many_lines)]
2	#![allow(clippy::module_name_repetitions)]

star-history 1.0.10/src/main.rs

13	clippy::single_match_else,
14	clippy::too_many_lines,
15	clippy::toplevel_ref_arg,

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

1	#![allow(clippy::stable_sort_primitive)]
2	#![allow(clippy::too_many_lines)]
3	#![allow(clippy::cast_precision_loss)]

sts_profile_auth 0.7.1/src/lib.rs

2	#![allow(clippy::must_use_candidate)]
3	#![allow(clippy::too_many_lines)]
4	#![allow(clippy::module_name_repetitions)]

svg2polylines 0.8.1/src/lib.rs

26	#![allow(clippy::must_use_candidate)]
27	#![allow(clippy::too_many_lines)]

swarm-bot 0.3.4/src/main.rs

52	)]
53	#![allow(clippy::too_many_lines)]
54	#![allow(clippy::wildcard_imports)]

syn 1.0.107/src/lib.rs

285	clippy::too_many_arguments,
286	clippy::too_many_lines,
287	clippy::trivially_copy_pass_by_ref,

syn 1.0.107/tests/debug/mod.rs

2	clippy::no_effect_underscore_binding,
3	clippy::too_many_lines,
4	clippy::used_underscore_binding

syn 1.0.107/tests/test_derive_input.rs

1	#![allow(clippy::assertions_on_result_states, clippy::too_many_lines)]

syn 1.0.107/tests/test_generics.rs

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

syn 1.0.107/tests/test_meta.rs

1	#![allow(clippy::shadow_unrelated, clippy::too_many_lines)]

syn 1.0.107/tests/test_precedence.rs

8	clippy::match_wildcard_for_single_variants,
9	clippy::too_many_lines
10	)]

syn-impersonated 0.1.18/src/lib.rs

274	clippy::single_match_else,
275	clippy::too_many_lines,
276	clippy::unseparated_literal_suffix,

taml 0.0.11/src/parsing.rs

312	#![allow(clippy::items_after_statements)]
313	#![allow(clippy::too_many_lines)]
557	) -> Result<PathSegment<'a, P>, ()> {
558	#![allow(clippy::too_many_lines)]
798	) -> Result<TabularPathSegment<'a, P>, ()> {
799	#![allow(clippy::too_many_lines)]
1234	) -> Result<Taml<'a, P>, ()> {
1235	#![allow(clippy::too_many_lines)]

taplo-common 0.4.0/src/lib.rs

10	clippy::similar_names,
11	clippy::too_many_lines
12	)]

taplo-lsp 0.6.0/src/lib.rs

10	clippy::similar_names,
11	clippy::too_many_lines,
12	clippy::enum_glob_use

tealdeer 1.6.1/src/main.rs

16	#![allow(clippy::struct_excessive_bools)]
17	#![allow(clippy::too_many_lines)]

teleterm 0.2.0/src/main.rs

12	#![allow(clippy::too_many_arguments)]
13	#![allow(clippy::too_many_lines)]
14	#![allow(clippy::type_complexity)]

telexide 0.1.10/src/lib.rs

63	clippy::wildcard_imports,
64	clippy::too_many_lines
65	)]

textmode 0.3.0/src/lib.rs

75	#![allow(clippy::too_many_arguments)]
76	#![allow(clippy::too_many_lines)]
77	#![allow(clippy::type_complexity)]

thiserror-core-impl 1.0.37/src/lib.rs

11	clippy::single_match_else,
12	clippy::too_many_lines,
13	clippy::wrong_self_convention

thiserror_core2-impl 2.0.0/src/lib.rs

10	clippy::single_match_else,
11	clippy::too_many_lines,
12	clippy::wrong_self_convention

thiserror-impl 1.0.38/src/lib.rs

11	clippy::single_match_else,
12	clippy::too_many_lines,
13	clippy::wrong_self_convention

thiserror-impl-no-std 2.0.2/src/lib.rs

10	clippy::single_match_else,
11	clippy::too_many_lines,
12	clippy::wrong_self_convention

thunderstore-api 2.0.0/src/lib.rs

10	// too many lines is a dumb metric
11	#![allow(clippy::too_many_lines)]
12	// as is fine, clippy is silly

tkn-watch 0.3.0/src/tekton.rs

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

trybuild 1.0.77/src/lib.rs

227	clippy::single_match_else,
228	clippy::too_many_lines,
229	clippy::trivially_copy_pass_by_ref,

trybuild2 1.0.0/src/lib.rs

237	clippy::single_match_else,
238	clippy::too_many_lines,
239	clippy::trivially_copy_pass_by_ref,

tryrun 0.5.3/tests/ui.rs

2	#![forbid(unsafe_code)]
3	#![allow(clippy::too_many_lines)]
4	#![deny(clippy::semicolon_if_nothing_returned)]

ttyrec 0.3.3/src/lib.rs

23	#![allow(clippy::too_many_arguments)]
24	#![allow(clippy::too_many_lines)]
25	#![allow(clippy::type_complexity)]

ttyrec-bin 0.1.3/src/bin/ttyplay/main.rs

10	#![allow(clippy::too_many_arguments)]
11	#![allow(clippy::too_many_lines)]
12	#![allow(clippy::type_complexity)]

ttyrec-bin 0.1.3/src/bin/ttyrec/main.rs

10	#![allow(clippy::too_many_arguments)]
11	#![allow(clippy::too_many_lines)]
12	#![allow(clippy::type_complexity)]

twitch-tui 2.0.2/src/ui/mod.rs

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

uggo 0.9.5/src/main.rs

1	#![deny(clippy::pedantic)]
2	#![allow(clippy::too_many_lines)]
3	#![allow(clippy::module_name_repetitions)]

umbra-lang 0.21.0/src/lib.rs

46	#![allow(clippy::needless_pass_by_value)]
47	#![allow(clippy::too_many_lines)]
48	#![allow(clippy::module_name_repetitions)]

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

11	clippy::single_match_else,
12	clippy::too_many_lines,
13	clippy::unreadable_literal

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

9	clippy::missing_safety_doc,
10	clippy::too_many_lines
11	)]

unsafe-libyaml 0.2.5/src/lib.rs

35	clippy::too_many_arguments,
36	clippy::too_many_lines,
37	clippy::unnecessary_cast,

vsimd 0.8.0/src/unified.rs

1	#![allow(clippy::collapsible_if, clippy::too_many_lines)]

vt100 0.15.1/src/lib.rs

45	#![allow(clippy::too_many_arguments)]
46	#![allow(clippy::too_many_lines)]
47	#![allow(clippy::type_complexity)]

wasm-bus-macros 1.1.0/src/lib.rs

8	clippy::similar_names,
9	clippy::too_many_lines
10	)]

wasmer-bus-macros 1.1.0/src/lib.rs

8	clippy::similar_names,
9	clippy::too_many_lines
10	)]

weather-tui 0.1.0/src/main.rs

8	clippy::unused_self,
9	clippy::too_many_lines,
10	clippy::future_not_send

weather_util_rust 0.15.1/src/lib.rs

3	#![allow(clippy::cast_lossless)]
4	#![allow(clippy::too_many_lines)]
5	#![allow(clippy::module_name_repetitions)]

wikidata 0.3.0/src/lib.rs

12	#![allow(clippy::missing_panics_doc)]
13	#![allow(clippy::too_many_lines)]

wotw_seedgen 0.2.1/src/lib.rs

7	#![allow(clippy::module_name_repetitions)]
8	#![allow(clippy::too_many_lines)]
9	#![allow(clippy::struct_excessive_bools)]

wotw_seedgen_derive 0.1.1/src/lib.rs

1	#![allow(clippy::too_many_lines)]
2	#![allow(clippy::module_name_repetitions)]

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