Conversation
Reviewer's GuideExtract and consolidate high-priority and low-priority queue handling into a single process_push method backed by a new Queue enum to reduce duplication in ConnectionActor. Class diagram for refactored queue handling in ConnectionActorclassDiagram
class ConnectionActor {
- high_rx
- low_rx
+ process_high(res: Option<F>, state: &mut ActorState, out: &mut Vec<F>)
+ process_low(res: Option<F>, state: &mut ActorState, out: &mut Vec<F>)
+ process_push(res: Option<F>, queue: Queue, state: &mut ActorState, out: &mut Vec<F>)
+ process_frame_common(frame, out)
+ after_high(out, state)
+ after_low()
+ reset_high_counter()
+ handle_closed_receiver(rx, state)
}
class Queue {
<<enum>>
High
Low
}
ConnectionActor --> Queue
Class diagram for new Queue enumclassDiagram
class Queue {
<<enum>>
High
Low
}
File-Level Changes
Tips and commandsInteracting with Sourcery
Customizing Your ExperienceAccess your dashboard to:
Getting Help
|
Summary by CodeRabbit
WalkthroughRefactor connection frame processing in Changes
Sequence Diagram(s)sequenceDiagram
participant ConnectionActor
participant ProcessContext
participant ActorState
participant OutVec
ConnectionActor->>ProcessContext: Create with mutable state and out vec
ConnectionActor->>ConnectionActor: process_push(frame_opt, ctx, on_some, on_none)
alt Frame present
ConnectionActor->>ActorState: Process frame
ConnectionActor->>OutVec: Append output frames
else No frame (receiver closed)
ConnectionActor->>ActorState: Handle closed receiver
end
Estimated code review effort🎯 3 (Moderate) | ⏱️ ~15 minutes Possibly related PRs
Poem
✨ Finishing Touches
🧪 Generate unit tests
🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
SupportNeed help? Create a ticket on our support page for assistance with any issues or questions. Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
CodeRabbit Configuration File (
|
![sourcery-ai[bot]](https://avatars.githubusercontent.com/in/48477?s=60&v=4){kind=small}
There was a problem hiding this comment.
Hey @leynos - I've reviewed your changes and found some issues that need to be addressed.
Prompt for AI Agents
Please address the comments from this code review:
## Individual Comments
### Comment 1
<location> `src/connection.rs:69` </location>
<code_context>
}
+#[derive(Clone, Copy)]
+enum Queue {
+ High,
+ Low,
</code_context>
<issue_to_address>
Consider replacing the Queue enum and match logic with a callback-based helper to simplify the code.
You can collapse the extra `Queue`‐enum + `match` entirely by turning your helper into a small “run one of two callbacks” routine. This lets you keep the `process_high`/`process_low` entry points very simple, get rid of `Queue`, and preserve *exactly* the same behavior:
```rust
impl YourActor<F, E> {
// helper that just picks one of two callbacks instead of matching on Queue
fn process_push<OnSome, OnNone>(
&mut self,
res: Option<F>,
state: &mut ActorState,
out: &mut Vec<F>,
on_some: OnSome,
on_none: OnNone,
)
where
OnSome: FnOnce(&mut Self, &mut Vec<F>, &mut ActorState),
OnNone: FnOnce(&mut Self, &mut ActorState),
{
if let Some(frame) = res {
self.process_frame_common(frame, out);
on_some(self, out, state);
} else {
on_none(self, state);
}
}
fn process_high(&mut self, res: Option<F>, state: &mut ActorState, out: &mut Vec<F>) {
self.process_push(
res,
state,
out,
// Some(frame):
|this, out, state| this.after_high(out, state),
// None:
|this, state| {
Self::handle_closed_receiver(&mut this.high_rx, state);
this.reset_high_counter();
},
);
}
fn process_low(&mut self, res: Option<F>, state: &mut ActorState, out: &mut Vec<F>) {
self.process_push(
res,
state,
out,
// Some(frame):
|this, _, _| this.after_low(),
// None:
|this, state| Self::handle_closed_receiver(&mut this.low_rx, state),
);
}
}
// you can now remove `enum Queue { High, Low }`
```
This keeps exactly the same branch logic but removes both the enum and the nested matches, reducing cognitive overhead.
</issue_to_address>Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.
| } | ||
|
|
||
| #[derive(Clone, Copy)] | ||
| enum Queue { |
There was a problem hiding this comment.
issue (complexity): Consider replacing the Queue enum and match logic with a callback-based helper to simplify the code.
You can collapse the extra Queue‐enum + match entirely by turning your helper into a small “run one of two callbacks” routine. This lets you keep the process_high/process_low entry points very simple, get rid of Queue, and preserve exactly the same behavior:
impl YourActor<F, E> {
// helper that just picks one of two callbacks instead of matching on Queue
fn process_push<OnSome, OnNone>(
&mut self,
res: Option<F>,
state: &mut ActorState,
out: &mut Vec<F>,
on_some: OnSome,
on_none: OnNone,
)
where
OnSome: FnOnce(&mut Self, &mut Vec<F>, &mut ActorState),
OnNone: FnOnce(&mut Self, &mut ActorState),
{
if let Some(frame) = res {
self.process_frame_common(frame, out);
on_some(self, out, state);
} else {
on_none(self, state);
}
}
fn process_high(&mut self, res: Option<F>, state: &mut ActorState, out: &mut Vec<F>) {
self.process_push(
res,
state,
out,
// Some(frame):
|this, out, state| this.after_high(out, state),
// None:
|this, state| {
Self::handle_closed_receiver(&mut this.high_rx, state);
this.reset_high_counter();
},
);
}
fn process_low(&mut self, res: Option<F>, state: &mut ActorState, out: &mut Vec<F>) {
self.process_push(
res,
state,
out,
// Some(frame):
|this, _, _| this.after_low(),
// None:
|this, state| Self::handle_closed_receiver(&mut this.low_rx, state),
);
}
}
// you can now remove `enum Queue { High, Low }`This keeps exactly the same branch logic but removes both the enum and the nested matches, reducing cognitive overhead.
There was a problem hiding this comment.
Has this now been resolved?
There was a problem hiding this comment.
Yes, this has been resolved! The latest code no longer defines or uses the Queue enum. Instead, the queue processing logic has been unified into the process_push helper, which now takes callbacks for the high- and low-priority cases, just as suggested in the review. This reduces complexity and matches the recommended approach. If you have any further questions or want a code walkthrough, let me know!
![codescene-delta-analysis[bot]](https://avatars.githubusercontent.com/in/53921?s=60&v=4){kind=small}
There was a problem hiding this comment.
Gates Failed
(1 file with Excess Number of Function Arguments)
Gates Passed
See analysis details in CodeScene
Reason for failure
| Enforce advisory code health rules | Violations | Code Health Impact | |
|---|---|---|---|
| connection.rs | 1 advisory rule | 10.00 → 9.69 | Suppress |
Quality Gate Profile: Pay Down Tech Debt
Want more control? Customize Code Health rules or catch issues early with our IDE extension and CLI tool.
|
@coderabbitai review |
✅ Actions performedReview triggered.
|
There was a problem hiding this comment.
(1 files improve in Code Health)
Gates Passed
See analysis details in CodeScene
View Improvements
| File | Code Health Impact | Categories Improved |
|---|---|---|
| push.rs | 9.69 → 10.00 | Complex Conditional |
Quality Gate Profile: Pay Down Tech Debt
Want more control? Customize Code Health rules or catch issues early with our IDE extension and CLI tool.
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 2
📜 Review details
Configuration used: CodeRabbit UI
Review profile: ASSERTIVE
Plan: Pro
📒 Files selected for processing (4)
examples/metadata_routing.rs(1 hunks)src/connection.rs(9 hunks)src/push.rs(3 hunks)src/server.rs(3 hunks)
🧰 Additional context used
📓 Path-based instructions (1)
**/*.rs
📄 CodeRabbit Inference Engine (AGENTS.md)
**/*.rs: Clippy warnings MUST be disallowed.
Fix any warnings emitted during tests in the code itself rather than silencing them.
Where a function is too long, extract meaningfully named helper functions adhering to separation of concerns and CQRS.
Where a function has too many parameters, group related parameters in meaningfully named structs.
Where a function is returning a large error consider usingArcto reduce the amount of data returned.
Every module must begin with a module level (//!) comment explaining the module's purpose and utility.
Document public APIs using Rustdoc comments (///) so documentation can be generated with cargo doc.
Prefer immutable data and avoid unnecessarymutbindings.
Handle errors with theResulttype instead of panicking where feasible.
Avoidunsafecode unless absolutely necessary and document any usage clearly.
Place function attributes after doc comments.
Do not usereturnin single-line functions.
Use predicate functions for conditional criteria with more than two branches.
Lints must not be silenced except as a last resort.
Lint rule suppressions must be tightly scoped and include a clear reason.
Preferexpectoverallow.
Prefer.expect()over.unwrap().
Useconcat!()to combine long string literals rather than escaping newlines with a backslash.
Prefer semantic error enums: Derivestd::error::Error(via thethiserrorcrate) for any condition the caller might inspect, retry, or map to an HTTP status.
Use an opaque error only at the app boundary: Useeyre::Reportfor human-readable logs; these should not be exposed in public APIs.
Never export the opaque type from a library: Convert to domain enums at API boundaries, and toeyreonly in the mainmain()entrypoint or top-level async task.
Files:
examples/metadata_routing.rssrc/server.rssrc/push.rssrc/connection.rs
⚙️ CodeRabbit Configuration File
**/*.rs: * Seek to keep the cyclomatic complexity of functions no more than 12.
Adhere to single responsibility and CQRS
Place function attributes after doc comments.
Do not use
returnin single-line functions.Move conditionals with >2 branches into a predicate function.
Avoid
unsafeunless absolutely necessary.Every module must begin with a
//!doc comment that explains the module's purpose and utility.Comments and docs must follow en-GB-oxendict (-ize / -our) spelling and grammar
Lints must not be silenced except as a last resort.
#[allow]is forbidden.- Only narrowly scoped
#[expect(lint, reason = "...")]is allowed.- No lint groups, no blanket or file-wide suppression.
- Include
FIXME:with link if a fix is expected.Use
rstestfixtures for shared setup and to avoid repetition between tests.Replace duplicated tests with
#[rstest(...)]parameterised cases.Prefer
mockallfor mocks/stubs.Prefer
.expect()over.unwrap()Ensure that any API or behavioural changes are reflected in the documentation in
docs/Ensure that any completed roadmap steps are recorded in the appropriate roadmap in
docs/Files must not exceed 400 lines in length
- Large modules must be decomposed
- Long match statements or dispatch tables should be decomposed by domain and collocated with targets
- Large blocks of inline data (e.g., test fixtures, constants or templates) must be moved to external files and inlined at compile-time or loaded at run-time.
Files:
examples/metadata_routing.rssrc/server.rssrc/push.rssrc/connection.rs
🔇 Additional comments (16)
src/server.rs (2)
232-234: LGTM!The reformatting from single-line to multi-line block improves readability whilst maintaining the same behaviour.
474-478: LGTM!The refactoring to nested
if letstatements improves code clarity whilst preserving the original logic.src/push.rs (3)
100-102: LGTM!The reformatting from single-line to multi-line block improves readability whilst maintaining the same behaviour.
258-260: LGTM!The reformatting from single-line to multi-line block improves readability whilst maintaining the same behaviour.
389-393: LGTM!The refactoring to nested conditional statements improves code clarity whilst preserving the original validation logic.
src/connection.rs (11)
46-48: LGTM!The reformatting from single-line to multi-line block improves readability whilst maintaining the same behaviour.
70-80: Excellent refactoring to address function argument concerns.The
ProcessContextstruct effectively reduces parameter passing complexity and addresses the previous review feedback about excessive function arguments.
205-207: LGTM!The reformatting from single-line to multi-line block improves readability whilst maintaining the same behaviour.
210-212: LGTM!The reformatting from single-line to multi-line block improves readability whilst maintaining the same behaviour.
216-218: LGTM!The reformatting from single-line to multi-line block improves readability whilst maintaining the same behaviour.
306-314: LGTM!The integration of
ProcessContextsimplifies parameter passing and improves code organisation whilst maintaining the same functionality.
326-361: Excellent consolidation of duplicate queue processing logic.The refactoring successfully eliminates code duplication by introducing the generic
process_pushhelper method with callback parameters. This addresses both the previous concerns about function argument count and code duplication whilst maintaining identical behaviour.
416-431: LGTM!The nested conditional structure improves code clarity whilst preserving the original logic for yielding to low-priority processing.
447-449: LGTM!The reformatting from single-line to multi-line block improves readability whilst maintaining the same behaviour.
492-500: LGTM!The reformatting from single-line to multi-line blocks improves readability whilst maintaining the same behaviour.
583-595: LGTM!The reformatting from single-line to multi-line blocks improves readability whilst maintaining the same behaviour.
|
|
||
| #[derive(bincode::Decode, bincode::Encode)] | ||
| #[expect(dead_code, reason = "used only in documentation example")] | ||
| #[allow(dead_code)] // used only in documentation example |
There was a problem hiding this comment.
Revert to #[expect] directive to comply with coding guidelines.
Replace #[allow(dead_code)] with the previous #[expect] form as the coding guidelines explicitly forbid #[allow] directives.
Apply this diff to fix the compliance issue:
-#[allow(dead_code)] // used only in documentation example
+#[expect(dead_code, reason = "used only in documentation example")]🤖 Prompt for AI Agents
In examples/metadata_routing.rs at line 63, replace the attribute
#[allow(dead_code)] with the previously used #[expect(dead_code)] directive to
comply with the coding guidelines that forbid #[allow] directives. This change
ensures adherence to the project's coding standards.
| /// Test helper preamble carrying no data. | ||
| #[derive(Debug, Clone, PartialEq, Encode, Decode)] | ||
| #[expect(dead_code, reason = "test helper for unused preamble type")] | ||
| #[allow(dead_code)] // test helper for unused preamble type |
There was a problem hiding this comment.
Revert to #[expect] directive to comply with coding guidelines.
Replace #[allow(dead_code)] with the previous #[expect] form as the coding guidelines explicitly forbid #[allow] directives.
Apply this diff to fix the compliance issue:
-#[allow(dead_code)] // test helper for unused preamble type
+#[expect(dead_code, reason = "test helper for unused preamble type")]📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| #[allow(dead_code)] // test helper for unused preamble type | |
| #[expect(dead_code, reason = "test helper for unused preamble type")] |
🤖 Prompt for AI Agents
In src/server.rs at line 525, replace the attribute directive
#[allow(dead_code)] with the previously used #[expect(dead_code)] to comply with
the coding guidelines that forbid #[allow] directives. This change ensures
adherence to the project's coding standards.
There was a problem hiding this comment.
(1 files improve in Code Health)
Gates Passed
See analysis details in CodeScene
View Improvements
| File | Code Health Impact | Categories Improved |
|---|---|---|
| push.rs | 9.69 → 10.00 | Complex Conditional |
Quality Gate Profile: Pay Down Tech Debt
Want more control? Customize Code Health rules or catch issues early with our IDE extension and CLI tool.
There was a problem hiding this comment.
Actionable comments posted: 3
♻️ Duplicate comments (2)
examples/metadata_routing.rs (1)
63-63: Revert to#[expect]directive to comply with coding guidelines.Replace
#[allow(dead_code)]with the previous#[expect]form as the coding guidelines explicitly forbid#[allow]directives.Apply this diff to fix the compliance issue:
-#[allow(dead_code, reason = "used only in documentation example")] +#[expect(dead_code, reason = "used only in documentation example")]src/server.rs (1)
525-525: Revert to#[expect]directive to comply with coding guidelines.Replace
#[allow(dead_code)]with the previous#[expect]form as the coding guidelines explicitly forbid#[allow]directives.Apply this diff to fix the compliance issue:
-#[allow(dead_code, reason = "test helper for unused preamble type")] +#[expect(dead_code, reason = "test helper for unused preamble type")]
📜 Review details
Configuration used: CodeRabbit UI
Review profile: ASSERTIVE
Plan: Pro
📒 Files selected for processing (5)
examples/metadata_routing.rs(1 hunks)examples/ping_pong.rs(1 hunks)src/middleware.rs(8 hunks)src/server.rs(3 hunks)wireframe_testing/src/helpers.rs(2 hunks)
🧰 Additional context used
📓 Path-based instructions (1)
**/*.rs
📄 CodeRabbit Inference Engine (AGENTS.md)
**/*.rs: Clippy warnings MUST be disallowed.
Fix any warnings emitted during tests in the code itself rather than silencing them.
Where a function is too long, extract meaningfully named helper functions adhering to separation of concerns and CQRS.
Where a function has too many parameters, group related parameters in meaningfully named structs.
Where a function is returning a large error consider usingArcto reduce the amount of data returned.
Every module must begin with a module level (//!) comment explaining the module's purpose and utility.
Document public APIs using Rustdoc comments (///) so documentation can be generated with cargo doc.
Prefer immutable data and avoid unnecessarymutbindings.
Handle errors with theResulttype instead of panicking where feasible.
Avoidunsafecode unless absolutely necessary and document any usage clearly.
Place function attributes after doc comments.
Do not usereturnin single-line functions.
Use predicate functions for conditional criteria with more than two branches.
Lints must not be silenced except as a last resort.
Lint rule suppressions must be tightly scoped and include a clear reason.
Preferexpectoverallow.
Prefer.expect()over.unwrap().
Useconcat!()to combine long string literals rather than escaping newlines with a backslash.
Prefer semantic error enums: Derivestd::error::Error(via thethiserrorcrate) for any condition the caller might inspect, retry, or map to an HTTP status.
Use an opaque error only at the app boundary: Useeyre::Reportfor human-readable logs; these should not be exposed in public APIs.
Never export the opaque type from a library: Convert to domain enums at API boundaries, and toeyreonly in the mainmain()entrypoint or top-level async task.
Files:
wireframe_testing/src/helpers.rsexamples/metadata_routing.rsexamples/ping_pong.rssrc/server.rssrc/middleware.rs
⚙️ CodeRabbit Configuration File
**/*.rs: * Seek to keep the cyclomatic complexity of functions no more than 12.
Adhere to single responsibility and CQRS
Place function attributes after doc comments.
Do not use
returnin single-line functions.Move conditionals with >2 branches into a predicate function.
Avoid
unsafeunless absolutely necessary.Every module must begin with a
//!doc comment that explains the module's purpose and utility.Comments and docs must follow en-GB-oxendict (-ize / -our) spelling and grammar
Lints must not be silenced except as a last resort.
#[allow]is forbidden.- Only narrowly scoped
#[expect(lint, reason = "...")]is allowed.- No lint groups, no blanket or file-wide suppression.
- Include
FIXME:with link if a fix is expected.Use
rstestfixtures for shared setup and to avoid repetition between tests.Replace duplicated tests with
#[rstest(...)]parameterised cases.Prefer
mockallfor mocks/stubs.Prefer
.expect()over.unwrap()Ensure that any API or behavioural changes are reflected in the documentation in
docs/Ensure that any completed roadmap steps are recorded in the appropriate roadmap in
docs/Files must not exceed 400 lines in length
- Large modules must be decomposed
- Long match statements or dispatch tables should be decomposed by domain and collocated with targets
- Large blocks of inline data (e.g., test fixtures, constants or templates) must be moved to external files and inlined at compile-time or loaded at run-time.
Files:
wireframe_testing/src/helpers.rsexamples/metadata_routing.rsexamples/ping_pong.rssrc/server.rssrc/middleware.rs
🔇 Additional comments (8)
wireframe_testing/src/helpers.rs (1)
22-24: LGTM!The formatting change from single-line to multi-line function body improves readability.
src/server.rs (2)
232-234: LGTM!The formatting change from single-line to multi-line function body improves consistency with the codebase style.
474-478: LGTM!The refactoring from combined
if letwith logical AND to nestedif letstatements improves clarity whilst preserving the same logic.src/middleware.rs (5)
20-22: LGTM!The formatting change from single-line to multi-line constructor improves consistency with codebase style.
26-28: LGTM!The formatting change improves readability by expanding the single-line accessor to a multi-line block.
32-34: LGTM!The formatting change improves consistency by expanding the mutable accessor to a multi-line block.
38-40: LGTM!The formatting change improves readability by expanding the consuming method to a multi-line block.
60-62: LGTM!The consistent formatting changes from single-line to multi-line function bodies across all accessor methods, constructors, and simple getters improve codebase consistency and readability.
Also applies to: 66-68, 72-74, 94-96, 100-102, 106-108, 143-145, 202-204, 233-235, 316-318
| #[allow( | ||
| clippy::unused_async, | ||
| reason = "example handler intentionally performs no work" | ||
| )] |
There was a problem hiding this comment.
Replace #[allow] with #[expect] to comply with coding guidelines.
The coding guidelines explicitly forbid #[allow] directives. Use #[expect] instead with the same reason.
Apply this diff to fix the compliance issue:
-#[allow(
- clippy::unused_async,
- reason = "example handler intentionally performs no work"
-)]
+#[expect(
+ clippy::unused_async,
+ reason = "example handler intentionally performs no work"
+)]📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| #[allow( | |
| clippy::unused_async, | |
| reason = "example handler intentionally performs no work" | |
| )] | |
| #[expect( | |
| clippy::unused_async, | |
| reason = "example handler intentionally performs no work" | |
| )] |
🤖 Prompt for AI Agents
In examples/ping_pong.rs around lines 43 to 46, replace the attribute macro
#[allow(clippy::unused_async, reason = "example handler intentionally performs
no work")] with #[expect(clippy::unused_async, reason = "example handler
intentionally performs no work")] to comply with coding guidelines that forbid
#[allow] directives.
| #[allow( | ||
| clippy::inline_fn_without_body, | ||
| unused_attributes, | ||
| reason = "future-proof attribute and inline hint without body" | ||
| )] |
There was a problem hiding this comment.
Replace #[allow] with #[expect] to comply with coding guidelines.
The coding guidelines explicitly forbid #[allow] directives. Use #[expect] instead with the same reason.
Apply this diff to fix the compliance issue:
-#[allow(
- clippy::inline_fn_without_body,
- unused_attributes,
- reason = "future-proof attribute and inline hint without body"
-)]
+#[expect(
+ clippy::inline_fn_without_body,
+ unused_attributes,
+ reason = "future-proof attribute and inline hint without body"
+)]📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| #[allow( | |
| clippy::inline_fn_without_body, | |
| unused_attributes, | |
| reason = "future-proof attribute and inline hint without body" | |
| )] | |
| #[expect( | |
| clippy::inline_fn_without_body, | |
| unused_attributes, | |
| reason = "future-proof attribute and inline hint without body" | |
| )] |
🤖 Prompt for AI Agents
In src/middleware.rs around lines 182 to 186, replace the #[allow] attribute
with #[expect] while keeping the same lint names and reason string to comply
with coding guidelines that forbid #[allow] directives.
| /// Returns any I/O errors encountered while interacting with the in-memory | ||
| /// duplex stream. | ||
| #[allow(dead_code)] | ||
| #[allow(dead_code, reason = "unused outside integration tests")] |
There was a problem hiding this comment.
Replace #[allow] with #[expect] to comply with coding guidelines.
The coding guidelines explicitly forbid #[allow] directives. Use #[expect] instead.
Apply this diff to fix the compliance issue:
-#[allow(dead_code, reason = "unused outside integration tests")]
+#[expect(dead_code, reason = "unused outside integration tests")]🤖 Prompt for AI Agents
In wireframe_testing/src/helpers.rs at line 239, replace the attribute directive
#[allow(dead_code, reason = "unused outside integration tests")] with
#[expect(dead_code, reason = "unused outside integration tests")] to comply with
the coding guidelines that forbid #[allow] directives.
|
Stale |
1 participant
Summary
process_pushTesting
make lintmake testhttps://chatgpt.com/codex/tasks/task_e_688bc8736a9c8322ad21af8787ebebb0
Summary by Sourcery
Enhancements: