Open
Conversation
added 14 commits
April 2, 2026 23:12
…ct for fixed-alloc data types, added the ClassId enum to uniquely distinguish all class ids
|
Note Reviews pausedIt looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the Use the following commands to manage reviews:
Use the checkboxes below for quick actions:
WalkthroughAdds a new workspace crate 🚥 Pre-merge checks | ✅ 2 | ❌ 3❌ Failed checks (2 warnings, 1 inconclusive)
✅ Passed checks (2 passed)
✏️ Tip: You can configure your own custom pre-merge checks in the settings. Tip 💬 Introducing Slack Agent: The best way for teams to turn conversations into code.Slack Agent is built on CodeRabbit's deep understanding of your code, so your team can collaborate across the entire SDLC without losing context.
Built for teams:
One agent for your entire SDLC. Right inside Slack. Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Review rate limit: 0/1 reviews remaining, refill in 60 minutes.Comment |
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 16
🧹 Nitpick comments (6)
crates/flutterdec-serwalker/src/utils.rs (1)
6-7: Use snake_case for the macro identifier.Idiomatic Rust macros (and the established convention enforced by
clippy::upper_case_acronyms/community style) are lower_snake_case (vec!,println!,declare_fixed_length_cluster!). Renaming early avoids a churn-y rename later when the macro is invoked from more places.♻️ Suggested rename
-macro_rules! DECLARE_FIXED_LENGTH_CLUSTER +macro_rules! declare_fixed_length_cluster…with corresponding updates at the import site (
use crate::DECLARE_FIXED_LENGTH_CLUSTER;) and call site incrates/flutterdec-serwalker/src/cluster/mod.rs.🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed. In `@crates/flutterdec-serwalker/src/utils.rs` around lines 6 - 7, Rename the macro DECLARE_FIXED_LENGTH_CLUSTER to snake_case (e.g., declare_fixed_length_cluster) and update all references accordingly: change the macro definition identifier in utils.rs, update any import usages like use crate::DECLARE_FIXED_LENGTH_CLUSTER to use crate::declare_fixed_length_cluster, and update call sites (for example in crates/flutterdec-serwalker/src/cluster/mod.rs) to invoke declare_fixed_length_cluster! instead of DECLARE_FIXED_LENGTH_CLUSTER! so the naming follows Rust/Clippy conventions.crates/flutterdec-serwalker/src/snapshot.rs (1)
32-53:DataSnapshot/SnapshotKindare notpub— unusable outside the crate.These types model the public output of the deserializer, but neither
enum SnapshotKind(line 5) norstruct DataSnapshot(line 32) carries a visibility modifier. As a result they're module-private and the surrounding crate can't expose snapshot parsing to consumers (seelib.rs, where modules are also non-pub). Mark thempub(and consider derivingDebug) once the surface stabilizes.♻️ Quick fix
-enum SnapshotKind // pulled straight out of the C++ def +#[derive(Debug)] +pub enum SnapshotKind // pulled straight out of the C++ def ... -struct DataSnapshot +pub struct DataSnapshot🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed. In `@crates/flutterdec-serwalker/src/snapshot.rs` around lines 32 - 53, DataSnapshot and SnapshotKind are currently module-private; make them public so external crates can use the deserializer output by adding the pub visibility to the struct and enum declarations (i.e., change struct DataSnapshot and enum SnapshotKind to pub struct DataSnapshot and pub enum SnapshotKind) and consider adding derives such as Debug (e.g., #[derive(Debug, ...)]) to both types once the API surface stabilizes; update any related items (fields or constructors) that must be pub for external use as needed.crates/flutterdec-serwalker/src/raw_object/mod.rs (1)
229-244: Placeholder structs needDefault(and likelyPhantomDatainitializer) before the commented-out macro invocations can be enabled.The
DECLARE_FIXED_LENGTH_CLUSTER!macro inutils.rscallsBox::<$name>::default()(line 36). The currently-activeOneByteStringderivesDefault, but the upcoming invocations queued incluster/mod.rs(Type,TypeArguments,TypeParameter, …) reference these placeholder types whose definitions here lack anyDefaultimpl. Adding#[derive(Default)]to the placeholders now will avoid a chain of compile errors when those lines are uncommented.♻️ Suggested fix
-pub struct Array<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct Object<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct AbstractType<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct FunctionType<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct Script<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct Closure<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct Instance<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct WeakArray<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct TypedDataBase<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct TypedData<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct TypedDataView<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct GrowableObjectArray<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct Code<'a> { _marker: std::marker::PhantomData<&'a ()> } -pub struct LoadingUnit<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct Array<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct Object<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct AbstractType<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct FunctionType<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct Script<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct Closure<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct Instance<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct WeakArray<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct TypedDataBase<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct TypedData<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct TypedDataView<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct GrowableObjectArray<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct Code<'a> { _marker: std::marker::PhantomData<&'a ()> } +#[derive(Default)] pub struct LoadingUnit<'a> { _marker: std::marker::PhantomData<&'a ()> }🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed. In `@crates/flutterdec-serwalker/src/raw_object/mod.rs` around lines 229 - 244, The placeholder structs (Array, Object, AbstractType, FunctionType, Script, Closure, Instance, WeakArray, TypedDataBase, TypedData, TypedDataView, GrowableObjectArray, Code, LoadingUnit and similar) need a Default implementation so macros like DECLARE_FIXED_LENGTH_CLUSTER! that call Box::<$name>::default() compile; add #[derive(Default)] to each of these placeholder struct definitions (the ones using std::marker::PhantomData) so PhantomData is initialized by Default and the upcoming cluster/mod.rs invocations can be enabled without further errors.crates/flutterdec-serwalker/src/lib.rs (1)
1-8: Crate currently exposes no public API.All modules are private and items inside (
DataSnapshot,Cluster,read_and_decompress_smi,ClassId, …) are either non-pubor onlypubwithin their private module. Nothing from this crate is reachable to consumers yet. Plan to re-export the parsing entry points (e.g.pub use snapshot::DataSnapshot;) and markmod snapshot;/mod cluster;pub(orpub(crate)) once you're ready for outside consumption.🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed. In `@crates/flutterdec-serwalker/src/lib.rs` around lines 1 - 8, The crate currently exposes no public API because modules are private; make the intended consumer-facing types and functions public by marking modules and/or re-exporting their symbols: change module visibility for snapshot and cluster (e.g., make mod snapshot; and mod cluster; public via pub mod or pub(crate) as appropriate) and add pub re-exports such as pub use snapshot::DataSnapshot; pub use cluster::Cluster; pub use raw_object::ClassId; and pub use stream::read_and_decompress_smi; ensure the actual item declarations (DataSnapshot, Cluster, ClassId, read_and_decompress_smi) are declared pub so they become reachable to downstream crates.crates/flutterdec-serwalker/src/constants.rs (1)
29-30: Add#[repr(u32)]and standard derives toClassIdfor stability and ergonomics.The
ClassIdenum (lines 29–206) lacks#[repr(...)]and key derives. This causes two issues:
Discriminant stability: Without
#[repr(u32)], casting variantsas u32relies on unspecified layout. This is unsafe for FFI, deserialization, or any integer mapping. Dart's serialized class IDs expect a stable u32 representation.Ergonomics:
decide_clusterincluster/mod.rstakesClassIdby value and matches on it; the enum gets moved repeatedly withoutCopy. Downstream code will need to log, compare, and deserialize these IDs, which all requirePartialEq,Eq,Debug, and ideallyCopy+Clone.Add the repr and derives shown below, and consider a
TryFrom<u32> for ClassIdimpl (mirroringSnapshotKind's pattern) to decode the on-disk integer back to the enum.Suggested diff
-pub enum ClassId { +#[repr(u32)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum ClassId { IllegalCid = 0,🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed. In `@crates/flutterdec-serwalker/src/constants.rs` around lines 29 - 30, The ClassId enum lacks a stable representation and common derives; update the enum declaration `ClassId` to add `#[repr(u32)]` and derive `Debug, Copy, Clone, PartialEq, Eq` (and any other project-standard derives) so casting variants with `as u32` is deterministic and values are cheaply copyable, then add a `TryFrom<u32> for ClassId` implementation (mirroring `SnapshotKind`'s pattern) to safely decode persisted integers back into `ClassId`; update call sites like `decide_cluster` in `cluster/mod.rs` if necessary to take `ClassId` by value and use the new `TryFrom` for deserialization.crates/flutterdec-serwalker/src/stream.rs (1)
64-90: Slicing without bounds check will panic on truncated input.
read_u64/read_u32slice[curr_stream_offset..curr_stream_offset + N]directly; if the cursor is near the end (e.g., due to a malformed/truncated snapshot), this panics before reachingtry_into. For a parser that ingests untrusted binaries this is worth turning into a recoverable error (e.g., returnResult<u64, ParseError>or have callers checkremaining()first). Acceptable for now if the design is to fail fast, but please make that policy explicit.🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed. In `@crates/flutterdec-serwalker/src/stream.rs` around lines 64 - 90, read_u64 and read_u32 currently slice byte_stream with [curr_stream_offset..curr_stream_offset + N] which will panic on truncated input; change both to return Result (e.g., Result<u64, ParseError> / Result<u32, ParseError>) and perform a safe bounds check before slicing: check self.remaining() >= u64_size/u32_size (or use byte_stream.get(curr_stream_offset..curr_stream_offset + size) and return a ParseError like UnexpectedEof/InsufficientData if None), only then convert with try_into, call self.advance_pos(size) on success, and return Ok(value); reference the functions read_u64, read_u32, self.byte_stream, self.curr_stream_offset, self.advance_pos, and add/extend ParseError to represent truncated input.
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.
Inline comments:
In `@crates/flutterdec-serwalker/Cargo.toml`:
- Line 8: Remove the unused goblin dependency entry from this crate's
Cargo.toml: locate the 'goblin' workspace/dependency declaration (the line
containing "goblin.workspace = true" / the 'goblin' dependency) and delete that
entry so the crate no longer declares goblin until it's actually used; then run
cargo check to verify there are no missing references.
In `@crates/flutterdec-serwalker/src/cluster/mod.rs`:
- Around line 15-23: The functions read_cluster_alloc and read_cluster_fill
currently declare an unused local curr_ref_id causing clippy unused_variable
errors; remove the unused binding or rename it to _curr_ref_id (or prefix with
underscore) in both functions, and do the same for any similar unused bindings
in parse_version_and_features callers, so the compiler no longer treats them as
warnings/errors while you implement the real logic.
- Around line 45-47: The placeholder block for the DECLARE_FIXED_LENGTH_CLUSTER
expansion for OneByteString currently evaluates to `1` (silently returning a
consumed-bytes value and leaving macro parameters like `read_fill`,
`last_ref_id`, and `stream` unused); replace the `{ 1 // to-do }` body with a
`todo!()` (or otherwise panic) so callers fail loudly and Clippy doesn’t error
on unused variables, and when you implement `read_fill` later, use the
`last_ref_id` and `stream` parameters inside the OneByteString implementation to
return the correct consumed byte count.
- Around line 32-38: decide_cluster currently always returns Err, ignores the
clusters parameter, and uses an elided &str lifetime; change it to a proper
unimplemented placeholder (e.g., call todo!() or leave a clear TODO) so callers
know it's a stub, and update the signature to either return a mutable reference
into the provided array (Result<&mut Box<dyn Cluster>, &'static str>) if the
intent is to look up/return an existing cluster by ClassId, or change the
clusters parameter to an index or owned value if you intend to take ownership;
also replace the error type &str with an explicit &'static str (or a real error
enum) to avoid incorrect borrowed lifetimes. Ensure references to
decide_cluster, Cluster, constants::MAX_CLUSTER_NUM, ClassId, and IllegalCid are
updated accordingly.
- Line 6: The Smi alias is inconsistent: cluster/mod.rs defines type Smi = i32
while raw_object/mod.rs uses type Smi = i64, causing silent truncation; fix by
centralizing a single pub type Smi = i64 (either in a new constants.rs or make
it pub in raw_object/mod.rs), remove the local type alias in cluster/mod.rs,
import that pub Smi where needed, and change the public function signature of
read_and_decompress_smi (and any other uses) to return the centralized Smi type
so all modules use i64 consistently.
- Around line 1-4: The file currently imports SIGNED_M (unused) and glob-imports
everything from crate::raw_object, which causes unused-import warnings and
namespace pollution; remove SIGNED_M from the constants import list and replace
use crate::raw_object::*; with explicit imports for only the types used by
DECLARE_FIXED_LENGTH_CLUSTER! (inspect the macro invocations to identify which
placeholder/object type names are referenced) so the module only imports those
symbols; if/when read_and_decompress_smi is updated to require SIGNED_M, re-add
it then.
- Around line 25-30: Update the misleading comment in read_and_decompress_smi to
state that SMIs are encoded with unsigned LEB128 (UNSIGNED_M), not signed; then
fix the type-width bug by making Smi match the target platform width (use i64
like raw_object::Smi in raw_object/mod.rs), have read_and_decompress_smi call
read_modified_leb128() into a u64, perform the right-shift by
constants::SMI_SHIFT at full width, and only then cast the shifted value to Smi
(i64) to avoid truncation on 64-bit platforms.
In `@crates/flutterdec-serwalker/src/snapshot.rs`:
- Around line 79-83: Change the read_clusters signature to take a mutable stream
reference (fn read_clusters(&mut self, stream: &mut Stream)) so cluster parsing
can advance the cursor and match the mutability of stream.read_* methods; also
remove the unused binding curr_ref_id (or rename it to _curr_ref_id / initialize
it where used) to silence clippy warnings, and apply the same unused-variable
fix pattern used in cluster/mod.rs::read_cluster_alloc and read_cluster_fill.
- Around line 10-28: Fix two typos in snapshot.rs: change the truncated comment
near the FullAOT enum variant to read "Full + AOT code, this is the one we care
about, as the" (or rephrase to a complete sentence) and correct the trailing
inline comment in the TryFrom<u64> match's default arm from "Handle invalid
snapshot kidjns" to "Handle invalid snapshot kinds" (the code regions to edit
are the SnapshotKind enum declaration around FullAOT and the default match arm
in impl TryFrom<u64> for SnapshotKind).
- Around line 71-77: In parse_version_and_features, avoid panicking from
String::split_off by validating the C string returned by Stream::read_c_string()
before splitting: check that its byte length is at least
constants::VERSION_HASH_LENGTH and that the split index is on a UTF-8 char
boundary (so splitting won't panic); if validation fails, return or propagate an
error (instead of panicking) and do not assign to
self.features/self.version_hash. Locate the logic in parse_version_and_features,
the call to Stream::read_c_string(), and the use of
constants::VERSION_HASH_LENGTH, and replace the unconditional split_off with a
guarded branch that safely sets self.features and self.version_hash only on
valid input.
- Around line 56-69: Change parse_header to return a Result<(), E> (use the
workspace's Error type or anyhow::Result) and replace the panic!/expect calls
with early-return Err variants: check magic_bytes read from Stream against
MAGIC_BYTES and return a descriptive error on mismatch, replace
SnapshotKind::try_from(...).expect(...) with mapping the Err into an Err result,
and propagate any Stream read errors likewise; keep calling
parse_version_and_features(stream) but have it also return a Result and
propagate its error (use ?). Update signatures and call sites to handle the
Result accordingly.
In `@crates/flutterdec-serwalker/src/stream.rs`:
- Around line 10-13: The seek implementation in fn seek(&mut self, pos: usize)
incorrectly rejects pos == 0 and silently ignores out-of-range positions; change
seek to accept the full range 0..=self.byte_stream.len() and return a Result so
callers get notified on bad input. Specifically, update fn seek(&mut self, pos:
usize) to return Result<(), SeekError> (or a suitable error type), set
self.curr_stream_offset = pos when pos <= self.byte_stream.len(), and return
Err(...) when pos > self.byte_stream.len(); keep references to
self.byte_stream.len() and self.curr_stream_offset so the check and assignment
are obvious in the implementation.
- Around line 99-110: read_c_string currently searches from the start of
self.byte_stream, slices with an inclusive end that can be out-of-bounds, and
returns a string that includes the NUL; fix it by searching from
self.curr_stream_offset (e.g. let hay =
&self.byte_stream[self.curr_stream_offset..]), find position of 0x00 in that
subslice (using position or iter().enumerate()), then compute absolute indices:
if a NUL is found set text_end = curr_stream_offset + pos and take the returned
bytes as &self.byte_stream[self.curr_stream_offset..text_end] (exclusive of the
NUL) and advance_pos by pos + 1 to skip the NUL; if no NUL is found use the rest
of the buffer (&self.byte_stream[self.curr_stream_offset..]), advance_pos by
that length, and convert the sliced bytes to String with proper UTF-8 handling
(e.g. from_utf8 with a clear error message) — update references to
self.byte_stream, self.curr_stream_offset, read_c_string, and advance_pos
accordingly.
- Around line 32-62: The read_modified_leb128 function has three fixes: replace
direct indexing of self.byte_stream[self.curr_stream_offset + idx as usize] with
safe .get(...) checks and return a typed parse error (e.g.,
Result::Err(ParseError::TruncatedStream)) when .get returns None; enforce a max
index bound (cap idx at 9) and check before any left-shift using (idx as usize *
DATA_BITS_PER_BYTE) to return a ParseError::Overflow if exceeded to avoid
>=64-bit shifts; and remove the redundant initial byte re-read by either
initializing read_num from first_byte and starting idx at 1 or by folding the
single-byte case into the main loop so the code only reads each byte once
(update calls to advance_pos and uses of UNSIGNED_MAX_DATA_PER_BYTE,
UNSIGNED_END_OF_DATA_BYTE, DATA_BITS_PER_BYTE, advance_pos, curr_stream_offset
accordingly).
- Around line 2-6: Stream is not constructible and read_c_string/seek contain
logic bugs; add a public constructor (e.g., pub fn new(byte_stream: &'a [u8]) ->
Stream<'a>) that initializes byte_stream and curr_stream_offset = 0 so callers
can create Stream, fix read_c_string to search starting at
self.curr_stream_offset (use
self.byte_stream[self.curr_stream_offset..].iter().position(|&b| b==0)), handle
the case when no null is found without panicking (treat as end-of-buffer or
return the slice to end), return the string slice excluding the null byte, and
advance curr_stream_offset by the relative length + 1 only when a null was found
(or by the remaining length if none); finally, change seek to accept zero by
allowing pos == 0 and validate pos <= self.byte_stream.len() before setting
self.curr_stream_offset = pos.
In `@crates/flutterdec-serwalker/src/utils.rs`:
- Around line 27-50: The generated read_alloc implementation fails to
read/assign the tags field and doesn't set
start_of_fill/end_of_fill/end_of_alloc, and read_fill's parameters can be unused
causing -D warnings; fix by (1) updating read_alloc to consume the tag word
before reading obj_count and assign self.tags (matching CLUSTER_TAGS_SZ/expected
on-disk layout) or remove the tags field/doc if tags aren't present, (2) ensure
start_of_fill, end_of_fill and end_of_alloc are written at the appropriate
points (e.g., set start_of_alloc at the start, set end_of_alloc after allocation
read or set start_of_fill/end_of_fill inside read_fill), and (3) avoid
unused-parameter warnings in fn read_fill by renaming parameters to _last_ref_id
and _stream in the signature or adding a discard like let _ = (&last_ref_id,
&stream); before $fill_impl; adjust the OneByteString invocation accordingly so
last_ref_id/stream use is explicit if intended.
---
Nitpick comments:
In `@crates/flutterdec-serwalker/src/constants.rs`:
- Around line 29-30: The ClassId enum lacks a stable representation and common
derives; update the enum declaration `ClassId` to add `#[repr(u32)]` and derive
`Debug, Copy, Clone, PartialEq, Eq` (and any other project-standard derives) so
casting variants with `as u32` is deterministic and values are cheaply copyable,
then add a `TryFrom<u32> for ClassId` implementation (mirroring `SnapshotKind`'s
pattern) to safely decode persisted integers back into `ClassId`; update call
sites like `decide_cluster` in `cluster/mod.rs` if necessary to take `ClassId`
by value and use the new `TryFrom` for deserialization.
In `@crates/flutterdec-serwalker/src/lib.rs`:
- Around line 1-8: The crate currently exposes no public API because modules are
private; make the intended consumer-facing types and functions public by marking
modules and/or re-exporting their symbols: change module visibility for snapshot
and cluster (e.g., make mod snapshot; and mod cluster; public via pub mod or
pub(crate) as appropriate) and add pub re-exports such as pub use
snapshot::DataSnapshot; pub use cluster::Cluster; pub use raw_object::ClassId;
and pub use stream::read_and_decompress_smi; ensure the actual item declarations
(DataSnapshot, Cluster, ClassId, read_and_decompress_smi) are declared pub so
they become reachable to downstream crates.
In `@crates/flutterdec-serwalker/src/raw_object/mod.rs`:
- Around line 229-244: The placeholder structs (Array, Object, AbstractType,
FunctionType, Script, Closure, Instance, WeakArray, TypedDataBase, TypedData,
TypedDataView, GrowableObjectArray, Code, LoadingUnit and similar) need a
Default implementation so macros like DECLARE_FIXED_LENGTH_CLUSTER! that call
Box::<$name>::default() compile; add #[derive(Default)] to each of these
placeholder struct definitions (the ones using std::marker::PhantomData) so
PhantomData is initialized by Default and the upcoming cluster/mod.rs
invocations can be enabled without further errors.
In `@crates/flutterdec-serwalker/src/snapshot.rs`:
- Around line 32-53: DataSnapshot and SnapshotKind are currently module-private;
make them public so external crates can use the deserializer output by adding
the pub visibility to the struct and enum declarations (i.e., change struct
DataSnapshot and enum SnapshotKind to pub struct DataSnapshot and pub enum
SnapshotKind) and consider adding derives such as Debug (e.g., #[derive(Debug,
...)]) to both types once the API surface stabilizes; update any related items
(fields or constructors) that must be pub for external use as needed.
In `@crates/flutterdec-serwalker/src/stream.rs`:
- Around line 64-90: read_u64 and read_u32 currently slice byte_stream with
[curr_stream_offset..curr_stream_offset + N] which will panic on truncated
input; change both to return Result (e.g., Result<u64, ParseError> / Result<u32,
ParseError>) and perform a safe bounds check before slicing: check
self.remaining() >= u64_size/u32_size (or use
byte_stream.get(curr_stream_offset..curr_stream_offset + size) and return a
ParseError like UnexpectedEof/InsufficientData if None), only then convert with
try_into, call self.advance_pos(size) on success, and return Ok(value);
reference the functions read_u64, read_u32, self.byte_stream,
self.curr_stream_offset, self.advance_pos, and add/extend ParseError to
represent truncated input.
In `@crates/flutterdec-serwalker/src/utils.rs`:
- Around line 6-7: Rename the macro DECLARE_FIXED_LENGTH_CLUSTER to snake_case
(e.g., declare_fixed_length_cluster) and update all references accordingly:
change the macro definition identifier in utils.rs, update any import usages
like use crate::DECLARE_FIXED_LENGTH_CLUSTER to use
crate::declare_fixed_length_cluster, and update call sites (for example in
crates/flutterdec-serwalker/src/cluster/mod.rs) to invoke
declare_fixed_length_cluster! instead of DECLARE_FIXED_LENGTH_CLUSTER! so the
naming follows Rust/Clippy conventions.
🪄 Autofix (Beta)
Fix all unresolved CodeRabbit comments on this PR:
- Push a commit to this branch (recommended)
- Create a new PR with the fixes
ℹ️ Review info
⚙️ Run configuration
Configuration used: Organization UI
Review profile: CHILL
Plan: Pro
Run ID: 81abc6b3-480b-43c8-b7b9-e44ff7b00fda
⛔ Files ignored due to path filters (1)
Cargo.lockis excluded by!**/*.lock
📒 Files selected for processing (10)
Cargo.tomlcrates/flutterdec-serwalker/Cargo.tomlcrates/flutterdec-serwalker/src/cluster/mod.rscrates/flutterdec-serwalker/src/constants.rscrates/flutterdec-serwalker/src/lib.rscrates/flutterdec-serwalker/src/raw_object/mod.rscrates/flutterdec-serwalker/src/snapshot.rscrates/flutterdec-serwalker/src/stream.rscrates/flutterdec-serwalker/src/utils.rsrust-toolchain.toml
| license.workspace = true | ||
|
|
||
| [dependencies] | ||
| goblin.workspace = true |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
#!/bin/bash
# Verify whether `goblin` is referenced anywhere inside the new crate.
fd -t f -e rs . crates/flutterdec-serwalker | xargs rg -nP '\bgoblin\b'Repository: caverav/flutterdec
Length of output: 46
Remove the unused goblin dependency from this crate.
The goblin crate is declared in Cargo.toml but is not referenced anywhere in the source files. Unused dependencies increase build time and dependency surface; drop it until actually needed.
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/Cargo.toml` at line 8, Remove the unused goblin
dependency entry from this crate's Cargo.toml: locate the 'goblin'
workspace/dependency declaration (the line containing "goblin.workspace = true"
/ the 'goblin' dependency) and delete that entry so the crate no longer declares
goblin until it's actually used; then run cargo check to verify there are no
missing references.
| use crate::raw_object::*; | ||
| use crate::constants::{ClassId, ClassId::*, SIGNED_M, UNSIGNED_M}; | ||
|
|
||
| type Smi = i32; |
There was a problem hiding this comment.
Smi is i32 here but i64 in raw_object/mod.rs — pick one.
crates/flutterdec-serwalker/src/raw_object/mod.rs line 2 declares type Smi = i64; (with comment "Using i64 for Smi fields to be decompressed") and is used by every struct field marked // Smi. This file declares its own type Smi = i32; and uses it as the return type of the public read_and_decompress_smi. The decompressed value is therefore returned at i32 width while every consumer in raw_object stores it at i64 width — an obvious foot-gun that will silently truncate large Dart Smis on 64-bit targets.
Centralize this in constants.rs (or raw_object) as a single pub type Smi = i64; and import it in both modules.
♻️ Suggested fix
-type Smi = i32;
+use crate::raw_object::Smi;…and make Smi pub in raw_object/mod.rs:
-type Smi = i64; // Using i64 for Smi fields to be decompressed
+pub type Smi = i64; // Using i64 for Smi fields to be decompressed🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/cluster/mod.rs` at line 6, The Smi alias is
inconsistent: cluster/mod.rs defines type Smi = i32 while raw_object/mod.rs uses
type Smi = i64, causing silent truncation; fix by centralizing a single pub type
Smi = i64 (either in a new constants.rs or make it pub in raw_object/mod.rs),
remove the local type alias in cluster/mod.rs, import that pub Smi where needed,
and change the public function signature of read_and_decompress_smi (and any
other uses) to return the centralized Smi type so all modules use i64
consistently.
Comment on lines
+2
to
+6
| pub struct Stream<'a> | ||
| { | ||
| byte_stream: &'a [u8], | ||
| curr_stream_offset: usize, | ||
| } |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
#!/bin/bash
# Confirm there is no constructor or pub field for Stream elsewhere, and find call sites.
fd -e rs . crates/flutterdec-serwalker
echo "--- Stream constructor / instantiation sites ---"
rg -nP -C2 '\bStream\s*(::|\{|<)' crates/flutterdec-serwalker
echo "--- impl blocks for Stream ---"
ast-grep --pattern 'impl<$_> Stream<$_> { $$$ }'Repository: caverav/flutterdec
Length of output: 9674
🏁 Script executed:
#!/bin/bash
# Search for Stream instantiation patterns across the codebase
echo "=== Searching for Stream instantiation (Stream { ... } or Stream::new) ==="
rg -n 'Stream\s*\{|Stream::new' crates/flutterdec-serwalker
echo ""
echo "=== Checking lib.rs for Stream re-exports or helpers ==="
cat -n crates/flutterdec-serwalker/src/lib.rs | head -50
echo ""
echo "=== Checking snapshot.rs for Stream usage ==="
rg -n -B2 -A2 'Stream' crates/flutterdec-serwalker/src/snapshot.rs | head -40
echo ""
echo "=== Checking cluster/mod.rs for Stream usage ==="
rg -n -B2 -A2 'Stream' crates/flutterdec-serwalker/src/cluster/mod.rs | head -40Repository: caverav/flutterdec
Length of output: 1524
🏁 Script executed:
#!/bin/bash
# Search more broadly for Stream instantiation and creation patterns
echo "=== Search for any direct Stream usage/creation ==="
rg -n 'Stream' crates/flutterdec-serwalker/src --type rs
echo ""
echo "=== Check if there's a main.rs or test files creating Stream ==="
find crates/flutterdec-serwalker -name 'main.rs' -o -name '*test*'
</parameter>Repository: caverav/flutterdec
Length of output: 331
🏁 Script executed:
#!/bin/bash
# Search more broadly for Stream instantiation and creation patterns
echo "=== Search for any direct Stream creation or reference ==="
rg -n 'Stream\(' crates/flutterdec-serwalker/src
echo ""
echo "=== Check if there's a main.rs or entry point ==="
find crates/flutterdec-serwalker -name 'main.rs'
echo ""
echo "=== Search for where Stream is actually instantiated ==="
rg -n -A5 'fn.*Stream' crates/flutterdec-serwalker/src/snapshot.rs | head -50Repository: caverav/flutterdec
Length of output: 893
🏁 Script executed:
#!/bin/bash
# Look for public methods that might create or initialize Stream
echo "=== Search in snapshot.rs for impl blocks and constructors ==="
rg -n 'impl\|pub fn' crates/flutterdec-serwalker/src/snapshot.rs | head -30
echo ""
echo "=== Look at the full DataSnapshot struct and any from/new methods ==="
sed -n '1,60p' crates/flutterdec-serwalker/src/snapshot.rs
echo ""
echo "=== Check if Stream is instantiated in any parent crate ==="
find . -name 'main.rs' -o -name 'lib.rs' | xargs grep -l 'Stream' 2>/dev/null
</parameter>Repository: caverav/flutterdec
Length of output: 2057
🏁 Script executed:
#!/bin/bash
# Look for who calls these functions that take Stream as parameter
echo "=== Search for calls to parse_header or functions using Stream ==="
rg -n 'parse_header\|read_clusters' crates/flutterdec-serwalker/src
echo ""
echo "=== Look for any public methods in DataSnapshot ==="
grep -n 'pub fn' crates/flutterdec-serwalker/src/snapshot.rsRepository: caverav/flutterdec
Length of output: 182
🏁 Script executed:
#!/bin/bash
# Get the complete snapshot.rs file to see the full picture
echo "=== Full snapshot.rs to understand the architecture ==="
wc -l crates/flutterdec-serwalker/src/snapshot.rs
echo ""
echo "=== Check for public methods/entry points in snapshot ==="
sed -n '1,150p' crates/flutterdec-serwalker/src/snapshot.rs
echo ""
echo "=== Look for who creates DataSnapshot ==="
rg -n 'DataSnapshot' crates/flutterdec-serwalker/srcRepository: caverav/flutterdec
Length of output: 2778
🏁 Script executed:
#!/bin/bash
# Check the Cargo.toml to understand the crate structure
echo "=== Cargo.toml for flutterdec-serwalker ==="
cat crates/flutterdec-serwalker/Cargo.toml
echo ""
echo "=== Check if there's a parent flutterdec crate ==="
ls -la crates/
echo ""
echo "=== Look at parent crate Cargo.toml if it exists ==="
cat Cargo.toml 2>/dev/null | head -30Repository: caverav/flutterdec
Length of output: 1720
🏁 Script executed:
#!/bin/bash
# Check if there are any public functions or exports in snapshot.rs
echo "=== Complete snapshot.rs file ==="
cat crates/flutterdec-serwalker/src/snapshot.rs
echo ""
echo "=== Check if lib.rs exports anything from snapshot ==="
cat crates/flutterdec-serwalker/src/lib.rsRepository: caverav/flutterdec
Length of output: 2611
🏁 Script executed:
#!/bin/bash
# Let's check if there's any way Stream gets instantiated - maybe in tests or build scripts
echo "=== Look for any build.rs ==="
find crates/flutterdec-serwalker -name 'build.rs'
echo ""
echo "=== Check for tests directory ==="
find crates/flutterdec-serwalker -type d -name tests
echo ""
echo "=== Look at the cluster trait to confirm Stream parameter pattern ==="
head -30 crates/flutterdec-serwalker/src/cluster/mod.rs
echo ""
echo "=== Verify read_c_string is actually using wrong offset ==="
sed -n '99,110p' crates/flutterdec-serwalker/src/stream.rs | cat -nRepository: caverav/flutterdec
Length of output: 1525
Stream is uninstantiable outside this module — add a public constructor.
byte_stream and curr_stream_offset are private fields with no public constructor. Although modules within flutterdec-serwalker receive &mut Stream as parameters, there is currently no way to construct a Stream.
Critical: read_c_string has multiple correctness bugs (lines 99–110).
-
Searches from buffer start, not current offset: Line 103–104 iterates over
self.byte_streamfrom index 0, ignoringcurr_stream_offset. Advancing the stream has no effect on subsequentread_c_string()calls. -
Out-of-bounds panic when no null terminator exists: If no null byte is found,
unwrap_or(self.byte_stream.len())returns the buffer length. Line 106 then attempts&self.byte_stream[..=self.byte_stream.len()], which panics. -
Includes the null byte in the result: Using
[..=first_nullbyte_pos]appends\0to the returned string. -
Incorrect position advance: Line 107 advances by
raw_str.len()measured from the buffer start, not from the current offset.
Minor: seek rejects valid position zero (line 12).
The condition pos > 0 prevents seeking to offset 0, which is a valid position in the buffer.
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/stream.rs` around lines 2 - 6, Stream is not
constructible and read_c_string/seek contain logic bugs; add a public
constructor (e.g., pub fn new(byte_stream: &'a [u8]) -> Stream<'a>) that
initializes byte_stream and curr_stream_offset = 0 so callers can create Stream,
fix read_c_string to search starting at self.curr_stream_offset (use
self.byte_stream[self.curr_stream_offset..].iter().position(|&b| b==0)), handle
the case when no null is found without panicking (treat as end-of-buffer or
return the slice to end), return the string slice excluding the null byte, and
advance curr_stream_offset by the relative length + 1 only when a null was found
(or by the remaining length if none); finally, change seek to accept zero by
allowing pos == 0 and validate pos <= self.byte_stream.len() before setting
self.curr_stream_offset = pos.
Comment on lines
+10
to
+13
| fn seek(&mut self, pos: usize) // might be useful? | ||
| { | ||
| if self.byte_stream.len() > pos && pos > 0 { self.curr_stream_offset = pos; } | ||
| } |
There was a problem hiding this comment.
seek rejects valid pos == 0 and silently no-ops on invalid input.
pos > 0 makes seeking back to the start of the buffer impossible, and an out-of-range value is silently ignored, which can mask logic errors. Either accept 0..=len and bubble up a Result, or use <=/>= correctly:
♻️ Suggested change
- fn seek(&mut self, pos: usize) // might be useful?
- {
- if self.byte_stream.len() > pos && pos > 0 { self.curr_stream_offset = pos; }
- }
+ fn seek(&mut self, pos: usize) -> Result<(), &'static str> {
+ if pos > self.byte_stream.len() {
+ return Err("seek past end of stream");
+ }
+ self.curr_stream_offset = pos;
+ Ok(())
+ }📝 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.
Suggested change
| fn seek(&mut self, pos: usize) // might be useful? | |
| { | |
| if self.byte_stream.len() > pos && pos > 0 { self.curr_stream_offset = pos; } | |
| } | |
| fn seek(&mut self, pos: usize) -> Result<(), &'static str> { | |
| if pos > self.byte_stream.len() { | |
| return Err("seek past end of stream"); | |
| } | |
| self.curr_stream_offset = pos; | |
| Ok(()) | |
| } |
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/stream.rs` around lines 10 - 13, The seek
implementation in fn seek(&mut self, pos: usize) incorrectly rejects pos == 0
and silently ignores out-of-range positions; change seek to accept the full
range 0..=self.byte_stream.len() and return a Result so callers get notified on
bad input. Specifically, update fn seek(&mut self, pos: usize) to return
Result<(), SeekError> (or a suitable error type), set self.curr_stream_offset =
pos when pos <= self.byte_stream.len(), and return Err(...) when pos >
self.byte_stream.len(); keep references to self.byte_stream.len() and
self.curr_stream_offset so the check and assignment are obvious in the
implementation.
Comment on lines
+32
to
+62
| pub fn read_modified_leb128(&mut self, sign_marker: u8) -> u64 // 8 bytes should be enough for anything... | ||
| { | ||
| let mut idx: u8 = 0; | ||
|
|
||
| let first_byte = self.byte_stream[self.curr_stream_offset]; | ||
| if first_byte > UNSIGNED_MAX_DATA_PER_BYTE // if the first byte has its MSb set | ||
| { | ||
| self.advance_pos(1); | ||
| // wrapping_sub mimics C++ unsigned underflow, giving us perfect sign-extension | ||
| // for negative numbers, while behaving normally for positive numbers. gotta get used to this :) | ||
| return (first_byte as u64).wrapping_sub(sign_marker as u64); | ||
| } | ||
|
|
||
| let mut read_num: u64 = 0; | ||
| let mut byte: u8; | ||
|
|
||
| loop { | ||
| byte = self.byte_stream[self.curr_stream_offset + idx as usize]; | ||
| if byte & UNSIGNED_END_OF_DATA_BYTE == UNSIGNED_END_OF_DATA_BYTE { break; } // final byte | ||
| read_num |= (byte as u64) << (idx as usize * DATA_BITS_PER_BYTE); | ||
| idx += 1; | ||
| } | ||
|
|
||
| self.advance_pos((idx + 1) as usize); // advance the stream position | ||
|
|
||
| // Same wrapping trick for the final byte | ||
| let final_chunk = (byte as u64).wrapping_sub(sign_marker as u64); | ||
| read_num |= final_chunk << (idx as usize * DATA_BITS_PER_BYTE); | ||
|
|
||
| read_num | ||
| } |
There was a problem hiding this comment.
🧩 Analysis chain
🌐 Web query:
Dart VM snapshot modified LEB128 encoding sign marker constants 0x80 0xC0
💡 Result:
The Dart VM uses a custom modified variant of LEB128 (Little Endian Base 128) encoding for serializing integers in its snapshot format. Standard LEB128 uses continuation bits (MSB=1 for more bytes, MSB=0 for last byte). Dart's variant reverses this: read bytes until (and including) one with value > 0x7F (MSB=1), reverse their order, discard the MSB from each, then interpret as little-endian integer. For signed integers, after reconstructing the positive value, the MSB of the last read byte (before discarding MSB) serves as the sign bit: if set, the number is negative, and it is sign-extended to the full bit width. The constants 0x80 (10000000b, MSB=1, 7 data bits=0) and 0xC0 (11000000b, MSB=1, 7 data bits=64=0x40) likely serve as special sign markers or terminators in this scheme. 0x80 could terminate a positive value (sign bit=0 after shift), while 0xC0 terminates a negative one (sign bit=1). They may be predefined constants in the snapshot deserializer (e.g., in runtime/vm/datastream.h ReadStream::Read(end_byte_marker)) representing common small signed values like 0 or -64, or used as explicit end_byte_markers for signed reads (kEndByteMarker possibly 0x80, kEndUnsignedByteMarker=0xC0 or vice versa). This encoding appears throughout Dart snapshots (AOT, clustered format via SerializationCluster/ReadStream in runtime/vm/), including Flutter apps, for compact serialization of offsets, lengths, and references. The reverse-engineered description matches result 11, and datastream.h confirms the custom varint with configurable end markers supporting signed extension.
Citations:
- 1: https://rloura.wordpress.com/2020/12/04/reversing-flutter-for-android-wip/
- 2: https://github.com/dart-lang/sdk/blob/7340a569caac6431d8698dc3788579b57ffcf0c6/runtime/vm/datastream.h
- 3: https://codebrowser.dev/flutter_engine/flutter_engine/third_party/dart/runtime/vm/datastream.h.html
- 4: https://github.com/dart-lang/sdk/blob/7340a569caac6431d8698dc3788579b57ffcf0c6/runtime/vm/clustered_snapshot.h
- 5: https://recipes.tst.sh/docs/reverse-engineering/anatomy-of-a-snapshot.html
- 6: https://github.com/dart-lang/sdk/blob/main/runtime/vm/app_snapshot.cc
🏁 Script executed:
#!/bin/bash
# Locate and examine the stream.rs file
fd -t f "stream.rs" | head -5Repository: caverav/flutterdec
Length of output: 104
🏁 Script executed:
#!/bin/bash
# Read the full function with surrounding context to understand constants and logic
cd crates/flutterdec-serwalker/src 2>/dev/null && wc -l stream.rsRepository: caverav/flutterdec
Length of output: 76
🏁 Script executed:
#!/bin/bash
# Get the constants and the full function
rg -A 50 "read_modified_leb128" crates/flutterdec-serwalker/src/stream.rs | head -80Repository: caverav/flutterdec
Length of output: 2011
🏁 Script executed:
#!/bin/bash
# Search for the constant definitions
rg "UNSIGNED_MAX_DATA_PER_BYTE|UNSIGNED_END_OF_DATA_BYTE|DATA_BITS_PER_BYTE" crates/flutterdec-serwalker/src/Repository: caverav/flutterdec
Length of output: 1165
🏁 Script executed:
#!/bin/bash
# Find byte_stream type definition and initialization
rg -B 5 "byte_stream" crates/flutterdec-serwalker/src/stream.rs | head -40Repository: caverav/flutterdec
Length of output: 1216
🏁 Script executed:
#!/bin/bash
# Look for the struct definition of this type
rg -A 10 "^pub struct|^struct" crates/flutterdec-serwalker/src/stream.rs | head -30Repository: caverav/flutterdec
Length of output: 316
🏁 Script executed:
#!/bin/bash
# Check for any error handling or validation patterns used elsewhere
rg "Result|Error|expect|unwrap" crates/flutterdec-serwalker/src/stream.rsRepository: caverav/flutterdec
Length of output: 486
read_modified_leb128: critical robustness gaps—unvalidated indexing and shift overflow.
- Line 49 index access without bounds check: Direct indexing
self.byte_stream[self.curr_stream_offset + idx as usize]will panic with an OOB error if the stream is truncated before encountering a terminator byte (0x80). Use.get()and return a typed parse error instead. - Lines 51/59 shift-by-idx overflow: With
idxas au8and shifts ofidx * 7bits into au64, a maliciously long or unterminated sequence causes shifts ≥ 64 bits, triggering undefined behavior (debug panic, release OOB). Capidxat 9 (max safe shift for u64 with 7-bit values) and return an error on overflow. - Minor: redundant byte read at loop start: The first iteration (idx=0) re-reads the byte already inspected at line 36. Either seed
read_numfromfirst_byteand startidx=1, or drop the early-return path and handle the single-byte case in the loop.
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/stream.rs` around lines 32 - 62, The
read_modified_leb128 function has three fixes: replace direct indexing of
self.byte_stream[self.curr_stream_offset + idx as usize] with safe .get(...)
checks and return a typed parse error (e.g.,
Result::Err(ParseError::TruncatedStream)) when .get returns None; enforce a max
index bound (cap idx at 9) and check before any left-shift using (idx as usize *
DATA_BITS_PER_BYTE) to return a ParseError::Overflow if exceeded to avoid
>=64-bit shifts; and remove the redundant initial byte re-read by either
initializing read_num from first_byte and starting idx at 1 or by folding the
single-byte case into the main loop so the code only reads each byte once
(update calls to advance_pos and uses of UNSIGNED_MAX_DATA_PER_BYTE,
UNSIGNED_END_OF_DATA_BYTE, DATA_BITS_PER_BYTE, advance_pos, curr_stream_offset
accordingly).
Comment on lines
+27
to
+50
| fn read_alloc(&mut self, last_ref_id: &mut u64, stream: &mut Stream) -> usize // read tags and count | ||
| { | ||
| let initial_pos = stream.get_current_pos(); | ||
| self.start_of_alloc = initial_pos; | ||
|
|
||
| self.obj_count = stream.read_modified_leb128(UNSIGNED_M); | ||
|
|
||
| for obj_idx in 0..self.obj_count | ||
| { | ||
| self.objs.push((*last_ref_id + obj_idx, Box::<$name>::default())); | ||
| } | ||
|
|
||
| *last_ref_id = *last_ref_id + self.obj_count; | ||
|
|
||
| stream.get_current_pos() - initial_pos | ||
| } | ||
|
|
||
| fn read_fill(&mut self, last_ref_id: &mut u64, stream: &mut Stream) -> usize | ||
| $fill_impl | ||
|
|
||
| fn is_fixed_len(&self) -> bool | ||
| { | ||
| true | ||
| } |
There was a problem hiding this comment.
read_alloc doesn't read tags, leaves several fields uninitialized, and read_fill will trip -D warnings.
A few correctness/CI concerns in the generated impl:
- The doc-comment on
read_allocsays "read tags and count" but onlyobj_countis read —self.tagsis never assigned. If the on-disk layout has a tag word preceding the count (matching theCLUSTER_TAGS_SZconstant in the commented-out section ofconstants.rs), this is a parsing bug; otherwise drop the field and the doc comment. start_of_fill,end_of_fill,end_of_allocare part of the generated struct but never written here or anywhere visible in the macro. Either set them inread_fill/ a future "end" hook, or remove them until used.read_fill's parameterslast_ref_idandstreammay be unused inside$fill_impl(the currentOneByteStringinvocation incluster/mod.rsis a{ 1 // to-do }block that uses neither). Combined with the PR's-D warningsvalidation, this will fail clippy viaunused_variables. Either prefix the params with_in the macro signature, or have the macrolet _ = (last_ref_id, stream);before the$fill_implblock.
♻️ Sketch of the fix
- fn read_alloc(&mut self, last_ref_id: &mut u64, stream: &mut Stream) -> usize // read tags and count
+ fn read_alloc(&mut self, last_ref_id: &mut u64, stream: &mut Stream) -> usize // read tags and count
{
let initial_pos = stream.get_current_pos();
self.start_of_alloc = initial_pos;
+ self.tags = stream.read_u32(); // if cluster layout actually starts with a tags word
self.obj_count = stream.read_modified_leb128(UNSIGNED_M);
for obj_idx in 0..self.obj_count
{
self.objs.push((*last_ref_id + obj_idx, Box::<$name>::default()));
}
- *last_ref_id = *last_ref_id + self.obj_count;
+ *last_ref_id += self.obj_count;
stream.get_current_pos() - initial_pos
}
- fn read_fill(&mut self, last_ref_id: &mut u64, stream: &mut Stream) -> usize
- $fill_impl
+ fn read_fill(&mut self, _last_ref_id: &mut u64, _stream: &mut Stream) -> usize
+ $fill_impl(Alternatively keep the original parameter names and put a let _ = (&last_ref_id, &stream); discard line at the top of the inserted block.)
📝 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.
Suggested change
| fn read_alloc(&mut self, last_ref_id: &mut u64, stream: &mut Stream) -> usize // read tags and count | |
| { | |
| let initial_pos = stream.get_current_pos(); | |
| self.start_of_alloc = initial_pos; | |
| self.obj_count = stream.read_modified_leb128(UNSIGNED_M); | |
| for obj_idx in 0..self.obj_count | |
| { | |
| self.objs.push((*last_ref_id + obj_idx, Box::<$name>::default())); | |
| } | |
| *last_ref_id = *last_ref_id + self.obj_count; | |
| stream.get_current_pos() - initial_pos | |
| } | |
| fn read_fill(&mut self, last_ref_id: &mut u64, stream: &mut Stream) -> usize | |
| $fill_impl | |
| fn is_fixed_len(&self) -> bool | |
| { | |
| true | |
| } | |
| fn read_alloc(&mut self, last_ref_id: &mut u64, stream: &mut Stream) -> usize // read tags and count | |
| { | |
| let initial_pos = stream.get_current_pos(); | |
| self.start_of_alloc = initial_pos; | |
| self.tags = stream.read_u32(); // if cluster layout actually starts with a tags word | |
| self.obj_count = stream.read_modified_leb128(UNSIGNED_M); | |
| for obj_idx in 0..self.obj_count | |
| { | |
| self.objs.push((*last_ref_id + obj_idx, Box::<$name>::default())); | |
| } | |
| *last_ref_id += self.obj_count; | |
| stream.get_current_pos() - initial_pos | |
| } | |
| fn read_fill(&mut self, _last_ref_id: &mut u64, _stream: &mut Stream) -> usize | |
| $fill_impl | |
| fn is_fixed_len(&self) -> bool | |
| { | |
| true | |
| } |
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/utils.rs` around lines 27 - 50, The generated
read_alloc implementation fails to read/assign the tags field and doesn't set
start_of_fill/end_of_fill/end_of_alloc, and read_fill's parameters can be unused
causing -D warnings; fix by (1) updating read_alloc to consume the tag word
before reading obj_count and assign self.tags (matching CLUSTER_TAGS_SZ/expected
on-disk layout) or remove the tags field/doc if tags aren't present, (2) ensure
start_of_fill, end_of_fill and end_of_alloc are written at the appropriate
points (e.g., set start_of_alloc at the start, set end_of_alloc after allocation
read or set start_of_fill/end_of_fill inside read_fill), and (3) avoid
unused-parameter warnings in fn read_fill by renaming parameters to _last_ref_id
and _stream in the signature or adding a discard like let _ = (&last_ref_id,
&stream); before $fill_impl; adjust the OneByteString invocation accordingly so
last_ref_id/stream use is explicit if intended.
caverav
force-pushed
the
flutterdec-dart-serwalker
branch
from
ac2a614 to
b36733a
Compare
There was a problem hiding this comment.
Actionable comments posted: 2
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.
Inline comments:
In `@crates/flutterdec-serwalker/src/raw_object/mod.rs`:
- Around line 16-21: The struct field types like TypeArguments.instantiations
(and similar fields in the other structs referenced) must not use Option<&'a mut
X> because Rust borrow exclusivity prevents shared/cyclic Dart graphs; replace
those Option<&'a mut ...> references with a shared handle type — e.g.
Option<std::rc::Rc<std::cell::RefCell<X>>> for single-threaded shared mutable
references or Option<RefId> if you maintain a flat arena of RawObject entries —
and update the affected structs (TypeArguments and the other structs at the
listed ranges) to use the chosen handle type so multiple objects can point to
the same target without violating Rust's mutability rules.
In `@crates/flutterdec-serwalker/src/stream.rs`:
- Around line 1-4: The import list includes SIGNED_END_OF_DATA_BYTE which is
unused and will cause a warning-as-error; edit the use crate::constants { ... }
in stream.rs to remove SIGNED_END_OF_DATA_BYTE (leaving
UNSIGNED_END_OF_DATA_BYTE, UNSIGNED_MAX_DATA_PER_BYTE, and DATA_BITS_PER_BYTE)
and re-add SIGNED_END_OF_DATA_BYTE later when the signed-LEB128 reader is
implemented.
🪄 Autofix (Beta)
Fix all unresolved CodeRabbit comments on this PR:
- Push a commit to this branch (recommended)
- Create a new PR with the fixes
ℹ️ Review info
⚙️ Run configuration
Configuration used: Organization UI
Review profile: CHILL
Plan: Pro
Run ID: 70b7509e-0cff-4504-92a0-b2fc135bb312
⛔ Files ignored due to path filters (1)
Cargo.lockis excluded by!**/*.lock
📒 Files selected for processing (10)
Cargo.tomlcrates/flutterdec-serwalker/Cargo.tomlcrates/flutterdec-serwalker/src/cluster/mod.rscrates/flutterdec-serwalker/src/constants.rscrates/flutterdec-serwalker/src/lib.rscrates/flutterdec-serwalker/src/raw_object/mod.rscrates/flutterdec-serwalker/src/snapshot.rscrates/flutterdec-serwalker/src/stream.rscrates/flutterdec-serwalker/src/utils.rsrust-toolchain.toml
✅ Files skipped from review due to trivial changes (4)
- Cargo.toml
- crates/flutterdec-serwalker/Cargo.toml
- crates/flutterdec-serwalker/src/lib.rs
- rust-toolchain.toml
🚧 Files skipped from review as they are similar to previous changes (2)
- crates/flutterdec-serwalker/src/utils.rs
- crates/flutterdec-serwalker/src/constants.rs
Comment on lines
+16
to
+21
| pub struct TypeArguments<'a> { | ||
| pub instantiations: Option<&'a mut Array<'a>>, // ArrayPtr | ||
| pub length: Smi, // Smi | ||
| pub hash: Smi, // Smi | ||
| pub nullability: Smi, // Smi | ||
| } |
There was a problem hiding this comment.
Option<&'a mut X> cannot represent a shared/cyclic Dart object graph.
Rust's exclusivity rule guarantees that at most one &mut T to the same value can exist at a time. Dart snapshots routinely share references — multiple Fields point at the same AbstractType, several Library entries see the same Class, Class.super_type/declaration_type aliases the same Type, and the cluster system itself indexes a single ref-id table that every cluster's read_fill will mutate by id. With the current types you can't even build a populated object graph: the moment one struct holds Some(&mut t) to a target, no other struct can hold a reference to t.
Recommendation: drop &'a mut from these reference fields and pick one of:
Option<std::rc::Rc<std::cell::RefCell<X>>>(single-threaded; simplest match for the pointer-y Dart layout),Option<RefId>(a numeric handle into a flatVec<RawObject>arena owned byDataSnapshot::clusters/objects table — usually the cleanest design for clustered snapshots and matches howlast_ref_idis already being tracked incluster::DECLARE_FIXED_LENGTH_CLUSTER!), orOption<Box<X>>only for fields that are guaranteed to be uniquely owned.
This is much cheaper to revisit while these structs are still placeholders than after fill/alloc logic is wired in across all the clusters.
Also applies to: 44-48, 69-83, 93-106, 133-163, 166-178, 181-199
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/raw_object/mod.rs` around lines 16 - 21, The
struct field types like TypeArguments.instantiations (and similar fields in the
other structs referenced) must not use Option<&'a mut X> because Rust borrow
exclusivity prevents shared/cyclic Dart graphs; replace those Option<&'a mut
...> references with a shared handle type — e.g.
Option<std::rc::Rc<std::cell::RefCell<X>>> for single-threaded shared mutable
references or Option<RefId> if you maintain a flat arena of RawObject entries —
and update the affected structs (TypeArguments and the other structs at the
listed ranges) to use the chosen handle type so multiple objects can point to
the same target without violating Rust's mutability rules.
added 4 commits
April 27, 2026 15:40
… strings and ref ids, fixed minor bugs
There was a problem hiding this comment.
Actionable comments posted: 3
♻️ Duplicate comments (1)
crates/flutterdec-serwalker/src/raw_object/mod.rs (1)
16-21:⚠️ Potential issue | 🟠 Major | 🏗️ Heavy lift
Option<&'a mut T>cannot model Dart snapshot sharing/cycles; switch to handle/shared ownership.These reference fields enforce exclusive borrows, so multiple objects cannot point to the same target (or cyclicly point back), which is required for snapshot graphs. This will break population/fill design as clusters grow.
Use a shared representation (
Option<RefId>into an arena/object table, orRc<RefCell<T>>for single-threaded mutable sharing). Given your cluster flow already trackslast_ref_id,RefIdis the cleaner fit.Suggested direction (illustrative)
+pub type RefId = u64; pub struct Type<'a> { - pub arguments: Option<&'a mut TypeArguments<'a>>, // TypeArgumentsPtr + pub arguments: Option<RefId>, // TypeArgumentsPtr } pub struct Class<'a> { - pub super_type: Option<&'a mut Type<'a>>, // TypePtr - pub declaration_type: Option<&'a mut Type<'a>>, // TypePtr + pub super_type: Option<RefId>, // TypePtr + pub declaration_type: Option<RefId>, // TypePtr }#!/bin/bash set -euo pipefail # 1) Enumerate all mutable reference fields in raw objects. rg -nP "pub\\s+\\w+:\\s+Option<&'a mut [A-Za-z_]\\w*(?:<'a>)?>" crates/flutterdec-serwalker/src/raw_object/mod.rs # 2) Show ref-id based allocation plumbing in serwalker. rg -n --type=rust -C2 "\\blast_ref_id\\b|objs:\\s*Vec<\\(\\s*u64,\\s*Box<" crates/flutterdec-serwalker/srcAlso applies to: 24-33, 36-41, 44-48, 51-67, 69-83, 86-92, 94-106, 109-118, 133-164, 166-200
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed. In `@crates/flutterdec-serwalker/src/raw_object/mod.rs` around lines 16 - 21, The TypeArguments struct (and other raw object structs with fields like instantiations: Option<&'a mut Array<'a>>) currently uses exclusive borrows which prevents shared/cyclic references; change these mutable reference fields to a reference-id based representation (e.g., Option<RefId> or Option<usize>) that indexes the serwalker arena/object table instead of Option<&'a mut T>, and update the population/fill logic that uses last_ref_id/objs to allocate and resolve those RefId entries when building/patching objects; alternatively for single-threaded mutability use Rc<RefCell<T>> consistently, but prefer RefId to match existing last_ref_id allocation plumbing and to enable sharing/cycles across TypeArguments and other raw object types referenced in this module.
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.
Inline comments:
In `@crates/flutterdec-serwalker/src/stream.rs`:
- Around line 68-89: read_u64 and read_u32 currently panic because they take a
slice using curr_stream_offset..curr_stream_offset+size before verifying enough
bytes exist; change both functions to first check that
self.byte_stream.len().saturating_sub(self.curr_stream_offset) >= size and
return a parse error (Result::Err) if not, only then safely slice (or use
get(..) to obtain the subslice), call self.advance_pos(size) on success and
decode with from_le_bytes; update the functions' signatures to return
Result<u64, ParseError>/Result<u32, ParseError> (or the crate's error type) and
propagate that error where these readers are used so truncated input no longer
panics.
- Around line 113-121: Change read_string to be fallible by returning a
Result<String, Error> (or a crate-specific ParseError) instead of panicking:
first validate that curr_stream_offset + len <= byte_stream.len() and return an
error if the buffer is too short; then take the slice
&byte_stream[self.curr_stream_offset..final_pos], call advance_pos(len) only
after validation, and attempt UTF-8 conversion using std::str::from_utf8 or
String::from_utf8, propagating the UTF-8 error into your Result rather than
calling expect; update any call sites of read_string accordingly to handle the
Result.
- Around line 130-160: read_ref_id can read past the end of byte_stream and
overflow the 32-bit accumulator; modify read_ref_id to validate input length and
prevent overflow by (1) checking before each byte access that
self.curr_stream_offset + idx < self.byte_stream.len() and returning an error
(or Option) on truncation, (2) imposing a sane max byte count for ref-ids (e.g.,
4 or 5 iterations) to avoid unbounded loops, and (3) using a larger accumulator
or checked arithmetic (checked_shl/checked_add or i64 accumulator with explicit
limit checks) instead of unbounded left shifts on ref_id; update the signature
of read_ref_id to return Result<u32, Error> (or Option<u32>) and only call
self.advance_pos(...) on the successfully consumed byte count.
---
Duplicate comments:
In `@crates/flutterdec-serwalker/src/raw_object/mod.rs`:
- Around line 16-21: The TypeArguments struct (and other raw object structs with
fields like instantiations: Option<&'a mut Array<'a>>) currently uses exclusive
borrows which prevents shared/cyclic references; change these mutable reference
fields to a reference-id based representation (e.g., Option<RefId> or
Option<usize>) that indexes the serwalker arena/object table instead of
Option<&'a mut T>, and update the population/fill logic that uses
last_ref_id/objs to allocate and resolve those RefId entries when
building/patching objects; alternatively for single-threaded mutability use
Rc<RefCell<T>> consistently, but prefer RefId to match existing last_ref_id
allocation plumbing and to enable sharing/cycles across TypeArguments and other
raw object types referenced in this module.
🪄 Autofix (Beta)
Fix all unresolved CodeRabbit comments on this PR:
- Push a commit to this branch (recommended)
- Create a new PR with the fixes
ℹ️ Review info
⚙️ Run configuration
Configuration used: Organization UI
Review profile: CHILL
Plan: Pro
Run ID: 96824466-5739-4ec9-9ab2-eb3c8721eb50
📒 Files selected for processing (4)
crates/flutterdec-serwalker/src/cluster/mod.rscrates/flutterdec-serwalker/src/raw_object/mod.rscrates/flutterdec-serwalker/src/snapshot.rscrates/flutterdec-serwalker/src/stream.rs
🚧 Files skipped from review as they are similar to previous changes (1)
- crates/flutterdec-serwalker/src/cluster/mod.rs
Comment on lines
+68
to
+89
| pub fn read_u64(&mut self) -> u64 { | ||
| let u64_size = std::mem::size_of::<u64>(); | ||
| let num_slice = | ||
| &self.byte_stream[self.curr_stream_offset..self.curr_stream_offset + u64_size]; | ||
|
|
||
| let converted_slice: [u8; 8] = num_slice.try_into().expect("Slice wasn't 8 bytes long..."); | ||
|
|
||
| self.advance_pos(u64_size); | ||
|
|
||
| u64::from_le_bytes(converted_slice) | ||
| } | ||
|
|
||
| pub fn read_u32(&mut self) -> u32 { | ||
| let u32_size = std::mem::size_of::<u32>(); | ||
| let num_slice = | ||
| &self.byte_stream[self.curr_stream_offset..self.curr_stream_offset + u32_size]; | ||
|
|
||
| let converted_slice: [u8; 4] = num_slice.try_into().expect("Slice wasn't 4 bytes long..."); | ||
|
|
||
| self.advance_pos(u32_size); | ||
|
|
||
| u32::from_le_bytes(converted_slice) |
There was a problem hiding this comment.
Bounds-check the fixed-width readers.
read_u64 and read_u32 slice the buffer before checking that enough bytes remain, so truncated input will panic before try_into() can help. Return a parse error from a checked slice instead.
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/stream.rs` around lines 68 - 89, read_u64 and
read_u32 currently panic because they take a slice using
curr_stream_offset..curr_stream_offset+size before verifying enough bytes exist;
change both functions to first check that
self.byte_stream.len().saturating_sub(self.curr_stream_offset) >= size and
return a parse error (Result::Err) if not, only then safely slice (or use
get(..) to obtain the subslice), call self.advance_pos(size) on success and
decode with from_le_bytes; update the functions' signatures to return
Result<u64, ParseError>/Result<u32, ParseError> (or the crate's error type) and
propagate that error where these readers are used so truncated input no longer
panics.
Comment on lines
+113
to
+121
| // read a non null-terminated string given a length | ||
| pub fn read_string(&mut self, len: usize) -> String | ||
| { | ||
| let final_pos = self.curr_stream_offset + len; | ||
| let raw_str = &self.byte_stream[self.curr_stream_offset..final_pos]; | ||
|
|
||
| self.advance_pos(len); | ||
|
|
||
| String::from_utf8(raw_str.to_vec()).expect("Couldn't turn UTF-8 bytes into a String.") |
There was a problem hiding this comment.
Make read_string fallible.
This still slices blindly and unwraps UTF-8 conversion, so a short buffer or invalid encoding will panic the parser. Validate the length first and return an error instead of unwrapping.
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/stream.rs` around lines 113 - 121, Change
read_string to be fallible by returning a Result<String, Error> (or a
crate-specific ParseError) instead of panicking: first validate that
curr_stream_offset + len <= byte_stream.len() and return an error if the buffer
is too short; then take the slice
&byte_stream[self.curr_stream_offset..final_pos], call advance_pos(len) only
after validation, and attempt UTF-8 conversion using std::str::from_utf8 or
String::from_utf8, propagating the UTF-8 error into your Result rather than
calling expect; update any call sites of read_string accordingly to handle the
Result.
Comment on lines
+130
to
+160
| pub fn read_ref_id(&mut self) -> u32 | ||
| { | ||
| let mut idx: usize = 0; | ||
| let mut byte: i8 = self.byte_stream[self.curr_stream_offset + idx] as i8; | ||
| let mut ref_id: i32 = 0; // as far as I know, ref_ids are up to 2^28, so 32 bits is good enough | ||
|
|
||
| if byte < 0 | ||
| { | ||
| ref_id += byte as i32; | ||
| self.advance_pos(1); | ||
| return (ref_id + 128) as u32; | ||
| } | ||
|
|
||
| loop | ||
| { | ||
| ref_id = ref_id << 7; | ||
| ref_id += byte as i32; | ||
| idx += 1; | ||
|
|
||
| if byte < 0 | ||
| { | ||
| break | ||
| } | ||
|
|
||
| byte = self.byte_stream[self.curr_stream_offset + idx] as i8; | ||
| } | ||
|
|
||
| self.advance_pos(idx); | ||
|
|
||
| (ref_id + 128) as u32 | ||
| } |
There was a problem hiding this comment.
Guard read_ref_id against malformed input.
The loop can read past the end of the stream, and the repeated << 7 shifts have no upper bound. A truncated or oversized ref-id can panic or overflow the accumulator.
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/stream.rs` around lines 130 - 160,
read_ref_id can read past the end of byte_stream and overflow the 32-bit
accumulator; modify read_ref_id to validate input length and prevent overflow by
(1) checking before each byte access that self.curr_stream_offset + idx <
self.byte_stream.len() and returning an error (or Option) on truncation, (2)
imposing a sane max byte count for ref-ids (e.g., 4 or 5 iterations) to avoid
unbounded loops, and (3) using a larger accumulator or checked arithmetic
(checked_shl/checked_add or i64 accumulator with explicit limit checks) instead
of unbounded left shifts on ref_id; update the signature of read_ref_id to
return Result<u32, Error> (or Option<u32>) and only call self.advance_pos(...)
on the successfully consumed byte count.
added 2 commits
April 29, 2026 23:38
…size alloc cluster types, implemented parse_clusters, implemented a macro to declare the ClassId enum and TryFrom for u32 for said enum
There was a problem hiding this comment.
Actionable comments posted: 2
🧹 Nitpick comments (1)
crates/flutterdec-serwalker/src/cluster/mod.rs (1)
15-21: 💤 Low valueEmpty placeholder functions.
These appear to be unused stubs. Consider removing them if not needed, or mark with
todo!()if they're intended for future implementation.🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed. In `@crates/flutterdec-serwalker/src/cluster/mod.rs` around lines 15 - 21, The two functions read_cluster_alloc and read_cluster_fill are empty stubs; either remove these unused functions or replace their bodies with a clear placeholder to indicate future work (e.g., use todo!() or unimplemented!()) so the intent is explicit; update the definitions of read_cluster_alloc and read_cluster_fill accordingly.
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.
Inline comments:
In `@crates/flutterdec-serwalker/src/snapshot.rs`:
- Around line 101-102: The expect call on decide_cluster(cid) uses a literal
"{cid}" so the class id won't be shown; replace the panic with proper error
propagation (return Result) or at minimum format the message using format! to
include cid (e.g. format!("Couldn't find cluster implementation for class {}",
cid)); update the surrounding function signature to return Result and propagate
the error from decide_cluster (or use ?) instead of panicking so behavior
matches the parse_header change; look for decide_cluster and the cluster binding
to implement this change.
In `@crates/flutterdec-serwalker/src/utils.rs`:
- Around line 100-106: The function decode_tags currently unwraps the class id
via DECODE_IS_CID! which calls ClassId::try_from(...).unwrap(), causing a panic
on malformed/unknown class IDs; change decode_tags to return Result<DecodedTags,
ErrorType> (propagate a suitable error from ClassId::try_from) instead of
unwrapping, compute is_deeply_immutable and is_canonical as before and return
Ok(DecodedTags::new(...)), and update the caller in snapshot.rs (the call at
snapshot.rs:98) to handle the Result (propagate or map the error) so parsing no
longer panics on invalid class IDs.
---
Nitpick comments:
In `@crates/flutterdec-serwalker/src/cluster/mod.rs`:
- Around line 15-21: The two functions read_cluster_alloc and read_cluster_fill
are empty stubs; either remove these unused functions or replace their bodies
with a clear placeholder to indicate future work (e.g., use todo!() or
unimplemented!()) so the intent is explicit; update the definitions of
read_cluster_alloc and read_cluster_fill accordingly.
🪄 Autofix (Beta)
Fix all unresolved CodeRabbit comments on this PR:
- Push a commit to this branch (recommended)
- Create a new PR with the fixes
ℹ️ Review info
⚙️ Run configuration
Configuration used: Organization UI
Review profile: CHILL
Plan: Pro
Run ID: 05e1b493-3408-41e1-84ef-9a16b7857c2b
📒 Files selected for processing (6)
crates/flutterdec-serwalker/src/cluster/mod.rscrates/flutterdec-serwalker/src/constants.rscrates/flutterdec-serwalker/src/raw_object/mod.rscrates/flutterdec-serwalker/src/snapshot.rscrates/flutterdec-serwalker/src/stream.rscrates/flutterdec-serwalker/src/utils.rs
🚧 Files skipped from review as they are similar to previous changes (3)
- crates/flutterdec-serwalker/src/constants.rs
- crates/flutterdec-serwalker/src/stream.rs
- crates/flutterdec-serwalker/src/raw_object/mod.rs
Comment on lines
+101
to
+102
| let mut cluster = | ||
| decide_cluster(cid).expect("Couldn't find cluster implementation for class {cid}"); |
There was a problem hiding this comment.
String literal "{cid}" won't interpolate the variable.
Rust string literals don't perform inline interpolation. The error message will literally print {cid} instead of the class ID value.
🐛 Proposed fix
let mut cluster =
- decide_cluster(cid).expect("Couldn't find cluster implementation for class {cid}");
+ decide_cluster(cid).unwrap_or_else(|_| panic!("Couldn't find cluster implementation for class {:?}", cid));Or better yet, propagate the error instead of panicking (aligning with the previous feedback about parse_header).
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/snapshot.rs` around lines 101 - 102, The
expect call on decide_cluster(cid) uses a literal "{cid}" so the class id won't
be shown; replace the panic with proper error propagation (return Result) or at
minimum format the message using format! to include cid (e.g. format!("Couldn't
find cluster implementation for class {}", cid)); update the surrounding
function signature to return Result and propagate the error from decide_cluster
(or use ?) instead of panicking so behavior matches the parse_header change;
look for decide_cluster and the cluster binding to implement this change.
Comment on lines
+100
to
+106
| pub fn decode_tags(tags: u32) -> DecodedTags { | ||
| let class_id: ClassId = DECODE_IS_CID!(tags).unwrap(); | ||
| let is_deeply_immutable: bool = DECODE_IS_DEEPLY_IMMUTABLE!(tags); | ||
| let is_canonical: bool = DECODE_IS_CANONICAL!(tags); | ||
|
|
||
| DecodedTags::new(class_id, is_deeply_immutable, is_canonical) | ||
| } |
There was a problem hiding this comment.
decode_tags panics on invalid class ID via unwrap().
If the snapshot contains a malformed or unknown class ID, ClassId::try_from(...).unwrap() will panic. This is on the parsing hot path and should propagate an error instead.
🐛 Proposed fix: Return Result
-pub fn decode_tags(tags: u32) -> DecodedTags {
- let class_id: ClassId = DECODE_IS_CID!(tags).unwrap();
+pub fn decode_tags(tags: u32) -> Result<DecodedTags, &'static str> {
+ let class_id: ClassId = DECODE_IS_CID!(tags)?;
let is_deeply_immutable: bool = DECODE_IS_DEEPLY_IMMUTABLE!(tags);
let is_canonical: bool = DECODE_IS_CANONICAL!(tags);
- DecodedTags::new(class_id, is_deeply_immutable, is_canonical)
+ Ok(DecodedTags::new(class_id, is_deeply_immutable, is_canonical))
}Then update the call site in snapshot.rs:98 to handle the Result.
📝 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.
Suggested change
| pub fn decode_tags(tags: u32) -> DecodedTags { | |
| let class_id: ClassId = DECODE_IS_CID!(tags).unwrap(); | |
| let is_deeply_immutable: bool = DECODE_IS_DEEPLY_IMMUTABLE!(tags); | |
| let is_canonical: bool = DECODE_IS_CANONICAL!(tags); | |
| DecodedTags::new(class_id, is_deeply_immutable, is_canonical) | |
| } | |
| pub fn decode_tags(tags: u32) -> Result<DecodedTags, &'static str> { | |
| let class_id: ClassId = DECODE_IS_CID!(tags)?; | |
| let is_deeply_immutable: bool = DECODE_IS_DEEPLY_IMMUTABLE!(tags); | |
| let is_canonical: bool = DECODE_IS_CANONICAL!(tags); | |
| Ok(DecodedTags::new(class_id, is_deeply_immutable, is_canonical)) | |
| } |
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/utils.rs` around lines 100 - 106, The
function decode_tags currently unwraps the class id via DECODE_IS_CID! which
calls ClassId::try_from(...).unwrap(), causing a panic on malformed/unknown
class IDs; change decode_tags to return Result<DecodedTags, ErrorType>
(propagate a suitable error from ClassId::try_from) instead of unwrapping,
compute is_deeply_immutable and is_canonical as before and return
Ok(DecodedTags::new(...)), and update the caller in snapshot.rs (the call at
snapshot.rs:98) to handle the Result (propagate or map the error) so parsing no
longer panics on invalid class IDs.
…s and serializable types
There was a problem hiding this comment.
Actionable comments posted: 1
🤖 Prompt for all review comments with AI agents
Verify each finding against the current code and only fix it if needed.
Inline comments:
In `@crates/flutterdec-serwalker/src/utils.rs`:
- Line 7: The macro currently captures a `$last_ref_id` identifier but never
binds it in the generated `read_fill` body, causing references to that
identifier inside `$fill_impl` to fail; fix by either removing `$last_ref_id`
from the macro pattern and all macro invocations (e.g., in `cluster/mod.rs`) so
the macro signature matches the `read_fill` trait method, or if `last_ref_id` is
required, add it to the trait signature for `read_fill` and update the generated
code to bind `let $last_ref_id = <appropriate_source>;` before invoking
`$fill_impl`; locate the macro definition (the arm with ($name:ident
$(<$lt:lifetime>)?, |$_self:ident, $last_ref_id:ident, $stream:ident|
$fill_impl:block) => { ...) and the generated `read_fill` binding lines (`let
$_self = self; let $stream = stream;`) to apply the change.
🪄 Autofix (Beta)
Fix all unresolved CodeRabbit comments on this PR:
- Push a commit to this branch (recommended)
- Create a new PR with the fixes
ℹ️ Review info
⚙️ Run configuration
Configuration used: Organization UI
Review profile: CHILL
Plan: Pro
Run ID: ba0570a5-c4e4-4c90-a890-35b13b1022d2
📒 Files selected for processing (4)
crates/flutterdec-serwalker/src/cluster/mod.rscrates/flutterdec-serwalker/src/raw_object/mod.rscrates/flutterdec-serwalker/src/snapshot.rscrates/flutterdec-serwalker/src/utils.rs
✅ Files skipped from review due to trivial changes (1)
- crates/flutterdec-serwalker/src/raw_object/mod.rs
🚧 Files skipped from review as they are similar to previous changes (1)
- crates/flutterdec-serwalker/src/snapshot.rs
|
|
||
| #[macro_export] | ||
| macro_rules! DECLARE_FIXED_LENGTH_CLUSTER { | ||
| ($name:ident $(<$lt:lifetime>)?, |$_self:ident, $last_ref_id:ident, $stream:ident| $fill_impl:block) => { |
There was a problem hiding this comment.
$last_ref_id is captured in the macro signature but never bound in read_fill.
The macro syntax captures three identifiers: $_self, $last_ref_id, $stream. However, in the generated read_fill (lines 45-56), only $_self and $stream are bound:
let $_self = self;
let $stream = stream;
// $last_ref_id is never bound!If any $fill_impl block references the last_ref_id identifier, compilation will fail with "cannot find value". Current invocations use { 1 } which sidesteps this, but the macro API is misleading.
Either remove $last_ref_id from the macro signature (since read_fill in the trait doesn't provide it), or if it's needed, add it to the trait method and pass it through.
Option 1: Remove misleading parameter
- ($name:ident $(<$lt:lifetime>)?, |$_self:ident, $last_ref_id:ident, $stream:ident| $fill_impl:block) => {
+ ($name:ident $(<$lt:lifetime>)?, |$_self:ident, $stream:ident| $fill_impl:block) => {And update invocations in cluster/mod.rs:
-DECLARE_FIXED_LENGTH_CLUSTER!(TypeParameters<'a>, |_self, last_ref_id, stream| { 1 });
+DECLARE_FIXED_LENGTH_CLUSTER!(TypeParameters<'a>, |_self, stream| { 1 });Also applies to: 45-56
🤖 Prompt for AI Agents
Verify each finding against the current code and only fix it if needed.
In `@crates/flutterdec-serwalker/src/utils.rs` at line 7, The macro currently
captures a `$last_ref_id` identifier but never binds it in the generated
`read_fill` body, causing references to that identifier inside `$fill_impl` to
fail; fix by either removing `$last_ref_id` from the macro pattern and all macro
invocations (e.g., in `cluster/mod.rs`) so the macro signature matches the
`read_fill` trait method, or if `last_ref_id` is required, add it to the trait
signature for `read_fill` and update the generated code to bind `let
$last_ref_id = <appropriate_source>;` before invoking `$fill_impl`; locate the
macro definition (the arm with ($name:ident $(<$lt:lifetime>)?, |$_self:ident,
$last_ref_id:ident, $stream:ident| $fill_impl:block) => { ...) and the generated
`read_fill` binding lines (`let $_self = self; let $stream = stream;`) to apply
the change.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Describe what changed and why.
Validation
cargo fmt --all --checkcargo clippy --workspace --all-targets -- -D warningscargo test --workspaceScope
type(scope): description)README.md,docs/*,context.md) when behavior changed