Pre-allocate capacity for maps in json! macro.

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.

src/macros.rs

@@ -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.
     //
@@ -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
         })