Define a separate local Place type per Deserialize impl

Fixes warning about non_local_definitions.

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/de/impls.rs:21:9
       |
    21 | /         impl Visitor for Place<()> {
    22 | |             fn null(&mut self) -> Result<()> {
    23 | |                 self.out = Some(());
    24 | |                 Ok(())
    25 | |             }
    26 | |         }
       | |_________^
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
       = note: `#[warn(non_local_definitions)]` on by default

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/de/impls.rs:33:9
       |
    33 | /         impl Visitor for Place<bool> {
    34 | |             fn boolean(&mut self, b: bool) -> Result<()> {
    35 | |                 self.out = Some(b);
    36 | |                 Ok(())
    37 | |             }
    38 | |         }
       | |_________^
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/de/impls.rs:45:9
       |
    45 | /         impl Visitor for Place<String> {
    46 | |             fn string(&mut self, s: &str) -> Result<()> {
    47 | |                 self.out = Some(s.to_owned());
    48 | |                 Ok(())
    49 | |             }
    50 | |         }
       | |_________^
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/de/impls.rs:59:17
       |
    59 | /                 impl Visitor for Place<$ty> {
    60 | |                     fn negative(&mut self, n: i64) -> Result<()> {
    61 | |                         if n >= $ty::min_value() as i64 {
    62 | |                             self.out = Some(n as $ty);
    ...  |
    76 | |                     }
    77 | |                 }
       | |_________________^
    ...
    83 |   signed!(i8);
       |   ----------- in this macro invocation
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
       = note: this warning originates in the macro `signed` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/de/impls.rs:59:17
       |
    59 | /                 impl Visitor for Place<$ty> {
    60 | |                     fn negative(&mut self, n: i64) -> Result<()> {
    61 | |                         if n >= $ty::min_value() as i64 {
    62 | |                             self.out = Some(n as $ty);
    ...  |
    76 | |                     }
    77 | |                 }
       | |_________________^
    ...
    84 |   signed!(i16);
       |   ------------ in this macro invocation
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
       = note: this warning originates in the macro `signed` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/de/impls.rs:59:17
       |
    59 | /                 impl Visitor for Place<$ty> {
    60 | |                     fn negative(&mut self, n: i64) -> Result<()> {
    61 | |                         if n >= $ty::min_value() as i64 {
    62 | |                             self.out = Some(n as $ty);
    ...  |
    76 | |                     }
    77 | |                 }
       | |_________________^
    ...
    85 |   signed!(i32);
       |   ------------ in this macro invocation
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
       = note: this warning originates in the macro `signed` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/de/impls.rs:59:17
       |
    59 | /                 impl Visitor for Place<$ty> {
    60 | |                     fn negative(&mut self, n: i64) -> Result<()> {
    61 | |                         if n >= $ty::min_value() as i64 {
    62 | |                             self.out = Some(n as $ty);
    ...  |
    76 | |                     }
    77 | |                 }
       | |_________________^
    ...
    86 |   signed!(i64);
       |   ------------ in this macro invocation
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
       = note: this warning originates in the macro `signed` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/de/impls.rs:59:17
       |
    59 | /                 impl Visitor for Place<$ty> {
    60 | |                     fn negative(&mut self, n: i64) -> Result<()> {
    61 | |                         if n >= $ty::min_value() as i64 {
    62 | |                             self.out = Some(n as $ty);
    ...  |
    76 | |                     }
    77 | |                 }
       | |_________________^
    ...
    87 |   signed!(isize);
       |   -------------- in this macro invocation
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
       = note: this warning originates in the macro `signed` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:93:17
        |
    93  | /                 impl Visitor for Place<$ty> {
    94  | |                     fn nonnegative(&mut self, n: u64) -> Result<()> {
    95  | |                         if n <= $ty::max_value() as u64 {
    96  | |                             self.out = Some(n as $ty);
    ...   |
    101 | |                     }
    102 | |                 }
        | |_________________^
    ...
    108 |   unsigned!(u8);
        |   ------------- in this macro invocation
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
        = note: this warning originates in the macro `unsigned` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:93:17
        |
    93  | /                 impl Visitor for Place<$ty> {
    94  | |                     fn nonnegative(&mut self, n: u64) -> Result<()> {
    95  | |                         if n <= $ty::max_value() as u64 {
    96  | |                             self.out = Some(n as $ty);
    ...   |
    101 | |                     }
    102 | |                 }
        | |_________________^
    ...
    109 |   unsigned!(u16);
        |   -------------- in this macro invocation
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
        = note: this warning originates in the macro `unsigned` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:93:17
        |
    93  | /                 impl Visitor for Place<$ty> {
    94  | |                     fn nonnegative(&mut self, n: u64) -> Result<()> {
    95  | |                         if n <= $ty::max_value() as u64 {
    96  | |                             self.out = Some(n as $ty);
    ...   |
    101 | |                     }
    102 | |                 }
        | |_________________^
    ...
    110 |   unsigned!(u32);
        |   -------------- in this macro invocation
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
        = note: this warning originates in the macro `unsigned` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:93:17
        |
    93  | /                 impl Visitor for Place<$ty> {
    94  | |                     fn nonnegative(&mut self, n: u64) -> Result<()> {
    95  | |                         if n <= $ty::max_value() as u64 {
    96  | |                             self.out = Some(n as $ty);
    ...   |
    101 | |                     }
    102 | |                 }
        | |_________________^
    ...
    111 |   unsigned!(u64);
        |   -------------- in this macro invocation
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
        = note: this warning originates in the macro `unsigned` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:93:17
        |
    93  | /                 impl Visitor for Place<$ty> {
    94  | |                     fn nonnegative(&mut self, n: u64) -> Result<()> {
    95  | |                         if n <= $ty::max_value() as u64 {
    96  | |                             self.out = Some(n as $ty);
    ...   |
    101 | |                     }
    102 | |                 }
        | |_________________^
    ...
    112 |   unsigned!(usize);
        |   ---------------- in this macro invocation
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
        = note: this warning originates in the macro `unsigned` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:118:17
        |
    118 | /                 impl Visitor for Place<$ty> {
    119 | |                     fn negative(&mut self, n: i64) -> Result<()> {
    120 | |                         self.out = Some(n as $ty);
    121 | |                         Ok(())
    ...   |
    132 | |                     }
    133 | |                 }
        | |_________________^
    ...
    139 |   float!(f32);
        |   ----------- in this macro invocation
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
        = note: this warning originates in the macro `float` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:118:17
        |
    118 | /                 impl Visitor for Place<$ty> {
    119 | |                     fn negative(&mut self, n: i64) -> Result<()> {
    120 | |                         self.out = Some(n as $ty);
    121 | |                         Ok(())
    ...   |
    132 | |                     }
    133 | |                 }
        | |_________________^
    ...
    140 |   float!(f64);
        |   ----------- in this macro invocation
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>
        = note: this warning originates in the macro `float` (in Nightly builds, run with -Z macro-backtrace for more info)

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:144:9
        |
    144 | /         impl<T: Deserialize> Visitor for Place<Box<T>> {
    145 | |             fn null(&mut self) -> Result<()> {
    146 | |                 let mut out = None;
    147 | |                 Deserialize::begin(&mut out).null()?;
    ...   |
    205 | |             }
    206 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:270:9
        |
    270 | /         impl<T: Deserialize> Visitor for Place<Option<T>> {
    271 | |             fn null(&mut self) -> Result<()> {
    272 | |                 self.out = Some(None);
    273 | |                 Ok(())
    ...   |
    309 | |             }
    310 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:318:9
        |
    318 | /         impl<A: Deserialize, B: Deserialize> Visitor for Place<(A, B)> {
    319 | |             fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
    320 | |                 Ok(Box::new(TupleBuilder {
    321 | |                     out: &mut self.out,
    ...   |
    324 | |             }
    325 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:359:9
        |
    359 | /         impl<T: Deserialize> Visitor for Place<Vec<T>> {
    360 | |             fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
    361 | |                 Ok(Box::new(VecBuilder {
    362 | |                     out: &mut self.out,
    ...   |
    366 | |             }
    367 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:402:9
        |
    402 | /         impl<T: Deserialize, const N: usize> Visitor for Place<[T; N]> {
    403 | |             fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
    404 | |                 Ok(Box::new(ArrayBuilder {
    405 | |                     out: &mut self.out,
    ...   |
    410 | |             }
    411 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:472:9
        |
    472 | /         impl<K, V, H> Visitor for Place<HashMap<K, V, H>>
    473 | |         where
    474 | |             K: FromStr + Hash + Eq,
    475 | |             V: Deserialize,
    ...   |
    485 | |             }
    486 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/de/impls.rs:532:9
        |
    532 | /         impl<K: FromStr + Ord, V: Deserialize> Visitor for Place<BTreeMap<K, V>> {
    533 | |             fn map(&mut self) -> Result<Box<dyn Map + '_>> {
    534 | |                 Ok(Box::new(MapBuilder {
    535 | |                     out: &mut self.out,
    ...   |
    540 | |             }
    541 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/json/value.rs:75:9
        |
    75  | /         impl Visitor for Place<Value> {
    76  | |             fn null(&mut self) -> Result<()> {
    77  | |                 self.out = Some(Value::Null);
    78  | |                 Ok(())
    ...   |
    121 | |             }
    122 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
      --> src/json/number.rs:37:9
       |
    37 | /         impl Visitor for Place<Number> {
    38 | |             fn negative(&mut self, n: i64) -> Result<()> {
    39 | |                 self.out = Some(Number::I64(n));
    40 | |                 Ok(())
    ...  |
    51 | |             }
    52 | |         }
       | |_________^
       |
       = help: move this `impl` block outside the of the current associated function `begin`
       = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
       = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
       = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/json/array.rs:116:9
        |
    116 | /         impl Visitor for Place<Array> {
    117 | |             fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
    118 | |                 Ok(Box::new(ArrayBuilder {
    119 | |                     out: &mut self.out,
    ...   |
    123 | |             }
    124 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

    warning: non-local `impl` definition, they should be avoided as they go against expectation
       --> src/json/object.rs:119:9
        |
    119 | /         impl Visitor for Place<Object> {
    120 | |             fn map(&mut self) -> Result<Box<dyn Map + '_>> {
    121 | |                 Ok(Box::new(ObjectBuilder {
    122 | |                     out: &mut self.out,
    ...   |
    127 | |             }
    128 | |         }
        | |_________^
        |
        = help: move this `impl` block outside the of the current associated function `begin`
        = note: an `impl` definition is non-local if it is nested inside an item and neither the type nor the trait are at the same nesting level as the `impl` block
        = note: one exception to the rule are anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type
        = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <rust-lang/rust#120363>

Author: dtolnay

src/de/impls.rs

@@ -2,7 +2,6 @@ use crate::de::{Deserialize, Map, Seq, Visitor};
 use crate::error::{Error, Result};
 use crate::ignore::Ignore;
 use crate::ptr::NonuniqueBox;
-use crate::Place;
 use alloc::borrow::ToOwned;
 use alloc::boxed::Box;
 use alloc::collections::BTreeMap;
@@ -18,36 +17,45 @@ use std::hash::{BuildHasher, Hash};
 
 impl Deserialize for () {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl Visitor for Place<()> {
             fn null(&mut self) -> Result<()> {
                 self.out = Some(());
                 Ok(())
             }
         }
+
         Place::new(out)
     }
 }
 
 impl Deserialize for bool {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl Visitor for Place<bool> {
             fn boolean(&mut self, b: bool) -> Result<()> {
                 self.out = Some(b);
                 Ok(())
             }
         }
+
         Place::new(out)
     }
 }
 
 impl Deserialize for String {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl Visitor for Place<String> {
             fn string(&mut self, s: &str) -> Result<()> {
                 self.out = Some(s.to_owned());
                 Ok(())
             }
         }
+
         Place::new(out)
     }
 }
@@ -56,6 +64,8 @@ macro_rules! signed {
     ($ty:ident) => {
         impl Deserialize for $ty {
             fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+                make_place!(Place);
+
                 impl Visitor for Place<$ty> {
                     fn negative(&mut self, n: i64) -> Result<()> {
                         if n >= $ty::min_value() as i64 {
@@ -75,6 +85,7 @@ macro_rules! signed {
                         }
                     }
                 }
+
                 Place::new(out)
             }
         }
@@ -90,6 +101,8 @@ macro_rules! unsigned {
     ($ty:ident) => {
         impl Deserialize for $ty {
             fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+                make_place!(Place);
+
                 impl Visitor for Place<$ty> {
                     fn nonnegative(&mut self, n: u64) -> Result<()> {
                         if n <= $ty::max_value() as u64 {
@@ -100,6 +113,7 @@ macro_rules! unsigned {
                         }
                     }
                 }
+
                 Place::new(out)
             }
         }
@@ -115,6 +129,8 @@ macro_rules! float {
     ($ty:ident) => {
         impl Deserialize for $ty {
             fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+                make_place!(Place);
+
                 impl Visitor for Place<$ty> {
                     fn negative(&mut self, n: i64) -> Result<()> {
                         self.out = Some(n as $ty);
@@ -131,6 +147,7 @@ macro_rules! float {
                         Ok(())
                     }
                 }
+
                 Place::new(out)
             }
         }
@@ -141,6 +158,8 @@ float!(f64);
 
 impl<T: Deserialize> Deserialize for Box<T> {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl<T: Deserialize> Visitor for Place<Box<T>> {
             fn null(&mut self) -> Result<()> {
                 let mut out = None;
@@ -266,7 +285,10 @@ impl<T: Deserialize> Deserialize for Option<T> {
     fn default() -> Option<Self> {
         Some(None)
     }
+
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl<T: Deserialize> Visitor for Place<Option<T>> {
             fn null(&mut self) -> Result<()> {
                 self.out = Some(None);
@@ -315,6 +337,8 @@ impl<T: Deserialize> Deserialize for Option<T> {
 
 impl<A: Deserialize, B: Deserialize> Deserialize for (A, B) {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl<A: Deserialize, B: Deserialize> Visitor for Place<(A, B)> {
             fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
                 Ok(Box::new(TupleBuilder {
@@ -356,6 +380,8 @@ impl<A: Deserialize, B: Deserialize> Deserialize for (A, B) {
 
 impl<T: Deserialize> Deserialize for Vec<T> {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl<T: Deserialize> Visitor for Place<Vec<T>> {
             fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
                 Ok(Box::new(VecBuilder {
@@ -399,6 +425,8 @@ impl<T: Deserialize> Deserialize for Vec<T> {
 
 impl<T: Deserialize, const N: usize> Deserialize for [T; N] {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl<T: Deserialize, const N: usize> Visitor for Place<[T; N]> {
             fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
                 Ok(Box::new(ArrayBuilder {
@@ -469,6 +497,8 @@ where
     H: BuildHasher + Default,
 {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl<K, V, H> Visitor for Place<HashMap<K, V, H>>
         where
             K: FromStr + Hash + Eq,
@@ -529,6 +559,8 @@ where
 
 impl<K: FromStr + Ord, V: Deserialize> Deserialize for BTreeMap<K, V> {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl<K: FromStr + Ord, V: Deserialize> Visitor for Place<BTreeMap<K, V>> {
             fn map(&mut self) -> Result<Box<dyn Map + '_>> {
                 Ok(Box::new(MapBuilder {

src/json/array.rs

@@ -3,7 +3,6 @@ use crate::error::Result;
 use crate::json::{drop, Value};
 use crate::private;
 use crate::ser::{Fragment, Serialize};
-use crate::Place;
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 use core::fmt::{self, Debug};
@@ -113,6 +112,8 @@ impl Serialize for Array {
 
 impl Deserialize for Array {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl Visitor for Place<Array> {
             fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
                 Ok(Box::new(ArrayBuilder {

src/json/number.rs

@@ -1,7 +1,6 @@
 use crate::de::{Deserialize, Visitor};
 use crate::error::Result;
 use crate::ser::{Fragment, Serialize};
-use crate::Place;
 use core::fmt::{self, Display};
 
 /// A JSON number represented by some Rust primitive.
@@ -34,6 +33,8 @@ impl Serialize for Number {
 
 impl Deserialize for Number {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl Visitor for Place<Number> {
             fn negative(&mut self, n: i64) -> Result<()> {
                 self.out = Some(Number::I64(n));

src/json/object.rs

@@ -2,7 +2,6 @@ use crate::de::{Deserialize, Map, Visitor};
 use crate::error::Result;
 use crate::json::{drop, Value};
 use crate::ser::{self, Fragment, Serialize};
-use crate::Place;
 use alloc::borrow::{Cow, ToOwned};
 use alloc::boxed::Box;
 use alloc::collections::{btree_map, BTreeMap};
@@ -116,6 +115,8 @@ impl Serialize for Object {
 
 impl Deserialize for Object {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl Visitor for Place<Object> {
             fn map(&mut self) -> Result<Box<dyn Map + '_>> {
                 Ok(Box::new(ObjectBuilder {

src/json/value.rs

@@ -2,7 +2,6 @@ use crate::de::{Deserialize, Map, Seq, Visitor};
 use crate::error::Result;
 use crate::json::{Array, Number, Object};
 use crate::ser::{Fragment, Serialize};
-use crate::Place;
 use alloc::borrow::{Cow, ToOwned};
 use alloc::boxed::Box;
 use alloc::string::String;
@@ -72,6 +71,8 @@ impl Serialize for Value {
 
 impl Deserialize for Value {
     fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
+        make_place!(Place);
+
         impl Visitor for Place<Value> {
             fn null(&mut self) -> Result<()> {
                 self.out = Some(Value::Null);

src/lib.rs

@@ -197,7 +197,5 @@ pub use crate::error::{Error, Result};
 #[doc(inline)]
 pub use crate::ser::Serialize;
 
-make_place!(Place);
-
 #[allow(non_camel_case_types)]
 struct private;