Skip to content

Commit

Permalink
Pre-allocate capacity for maps in json! macro.
Browse files Browse the repository at this point in the history
Attempt to address issue serde-rs#810.

This implementation works by expanding the contents of the map twice,
first to produce a capacity value, then actually inserting the elements.

Because it expands the contents of the map twice, when encountering invalid syntax,
it may print error messages twice, which may be unwanted.
  • Loading branch information
zachs18 committed Oct 26, 2022
1 parent 4f194c9 commit 99629eb
Showing 1 changed file with 103 additions and 1 deletion.
104 changes: 103 additions & 1 deletion src/macros.rs
Original file line number Diff line number Diff line change
Expand Up @@ -234,6 +234,107 @@ macro_rules! json_internal {
json_internal!(@object $object ($($key)* $tt) ($($rest)*) ($($rest)*));
};


//////////////////////////////////////////////////////////////////////////
// TT muncher for counting the elements inside of an object {...}.
// Each entry is replaced with `1 + ` (or `1` if it is the last element).
// 0 is inserted if the object has a trailing comma.
//
// Must be invoked as: json_internal!(@object_capacity () ($($tt)*) ($($tt)*))
//
// We require two copies of the input tokens so that we can match on one
// copy and trigger errors on the other copy.
//////////////////////////////////////////////////////////////////////////

// Done.
(@object_capacity () () ()) => {0};

// Current entry followed by trailing comma.
(@object_capacity entry , $($rest:tt)*) => {
1 + json_internal!(@object_capacity () ($($rest)*) ($($rest)*))
};

// Current entry followed by unexpected token. The actual parsing macro will print the error message.
(@object_capacity entry $unexpected:tt $($rest:tt)*) => {
0
};

// Insert the last entry without trailing comma.
(@object_capacity entry) => {
1
};

// Next value is `null`.
(@object_capacity ($($key:tt)+) (: null $($rest:tt)*) $copy:tt) => {
json_internal!(@object_capacity entry $($rest)*)
};

// Next value is `true`.
(@object_capacity ($($key:tt)+) (: true $($rest:tt)*) $copy:tt) => {
json_internal!(@object_capacity entry $($rest)*)
};

// Next value is `false`.
(@object_capacity ($($key:tt)+) (: false $($rest:tt)*) $copy:tt) => {
json_internal!(@object_capacity entry $($rest)*)
};

// Next value is an array.
(@object_capacity ($($key:tt)+) (: [$($array:tt)*] $($rest:tt)*) $copy:tt) => {
json_internal!(@object_capacity entry $($rest)*)
};

// Next value is a map.
(@object_capacity ($($key:tt)+) (: {$($map:tt)*} $($rest:tt)*) $copy:tt) => {
json_internal!(@object_capacity entry $($rest)*)
};

// Next value is an expression followed by comma.
(@object_capacity ($($key:tt)+) (: $value:expr , $($rest:tt)*) $copy:tt) => {
json_internal!(@object_capacity entry , $($rest)*)
};

// Last value is an expression with no trailing comma.
(@object_capacity ($($key:tt)+) (: $value:expr) $copy:tt) => {
json_internal!(@object_capacity entry)
};

// Missing value for last entry. The actual parsing macro will print the error message.
(@object_capacity ($($key:tt)+) (:) $copy:tt) => {
0
};

// Missing colon and value for last entry. The actual parsing macro will print the error message.
(@object_capacity ($($key:tt)+) () $copy:tt) => {
0
};

// Misplaced colon. The actual parsing macro will print the error message.
(@object_capacity () (: $($rest:tt)*) ($colon:tt $($copy:tt)*)) => {
0
};

// Found a comma inside a key. The actual parsing macro will print the error message.
(@object_capacity ($($key:tt)*) (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => {
0
};

// Key is fully parenthesized. This is not necessary for counting capacity
// since we don't evaluate $key anyway, so just use the munching below.
// (@object_capacity () (($key:expr) : $($rest:tt)*) $copy:tt) => {
// json_internal!(@object_capacity ($key) (: $($rest)*) (: $($rest)*))
// };

// Refuse to absorb colon token into key expression.
(@object_capacity ($($key:tt)*) (: $($unexpected:tt)+) $copy:tt) => {
json_expect_expr_comma!($($unexpected)+)
};

// Munch a token into the current key.
(@object_capacity ($($key:tt)*) ($tt:tt $($rest:tt)*) $copy:tt) => {
json_internal!(@object_capacity ($($key)* $tt) ($($rest)*) ($($rest)*))
};

//////////////////////////////////////////////////////////////////////////
// The main implementation.
//
Expand Down Expand Up @@ -266,7 +367,8 @@ macro_rules! json_internal {

({ $($tt:tt)+ }) => {
$crate::Value::Object({
let mut object = $crate::Map::new();
let capacity = json_internal!(@object_capacity () ($($tt)+) ($($tt)+));
let mut object = $crate::Map::with_capacity(capacity);
json_internal!(@object object () ($($tt)+) ($($tt)+));
object
})
Expand Down

0 comments on commit 99629eb

Please sign in to comment.