Update pdl-compiler to 0.1.3

Test: TreeHugger
Change-Id: I117a9881f4f11c1ebaef7565f6b48a3d176d25c2

99 files changed, 704 insertions, 1247 deletions

diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 686a0a1..24636e7 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "c2c504a038cfe412ad8a3f8c0a1b747126eeedda"
+    "sha1": "6b05a0616ef2a982068e0d5fbe28d2058d49d8e0"
   },
   "path_in_vcs": ""
 }
\ No newline at end of file
diff --git a/Android.bp b/Android.bp
index f8f8ee2..60940fe 100644
--- a/Android.bp
+++ b/Android.bp
@@ -7,7 +7,7 @@ rust_binary_host {
     name: "generate_canonical_tests",
     crate_name: "generate_canonical_tests",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.1.2",
+    cargo_pkg_version: "0.1.3",
     srcs: ["src/bin/generate-canonical-tests.rs"],
     edition: "2021",
     features: [
@@ -37,7 +37,7 @@ rust_library_host {
     name: "libpdl_compiler",
     crate_name: "pdl_compiler",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.1.2",
+    cargo_pkg_version: "0.1.3",
     srcs: ["src/lib.rs"],
     edition: "2021",
     features: [
@@ -66,7 +66,7 @@ rust_binary_host {
     name: "pdlc",
     crate_name: "pdlc",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.1.2",
+    cargo_pkg_version: "0.1.3",
     srcs: ["src/main.rs"],
     edition: "2021",
     features: [
diff --git a/Cargo.toml b/Cargo.toml
index 6bbb7d4..57d75db 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,13 +12,16 @@
 [package]
 edition = "2021"
 name = "pdl-compiler"
-version = "0.1.2"
+version = "0.1.3"
 authors = [
     "Henri Chataing <henrichataing@google.com>",
     "David de Jesus Duarte <licorne@google.com>",
     "Martin Geisler <mgeisler@google.com>",
 ]
-exclude = [".github/*"]
+exclude = [
+    ".github/*",
+    "editors/*",
+]
 default-run = "pdlc"
 description = "Parser and serializer generator for protocol binary packets"
 readme = "README.md"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 878053d..c9fa183 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "pdl-compiler"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 description = "Parser and serializer generator for protocol binary packets"
 repository = "https://github.com/google/pdl/"
@@ -12,7 +12,7 @@ authors = [
     "David de Jesus Duarte <licorne@google.com>",
     "Martin Geisler <mgeisler@google.com>"
 ]
-exclude = [".github/*"]
+exclude = [".github/*", "editors/*"]
 categories = ["parsing"]
 default-run = "pdlc"
 
diff --git a/METADATA b/METADATA
index 5d18826..b35258e 100644
--- a/METADATA
+++ b/METADATA
@@ -11,13 +11,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/pdl-compiler/pdl-compiler-0.1.2.crate"
+    value: "https://static.crates.io/crates/pdl-compiler/pdl-compiler-0.1.3.crate"
   }
-  version: "0.1.2"
+  version: "0.1.3"
   license_type: NOTICE
   last_upgrade_date {
     year: 2023
     month: 6
-    day: 20
+    day: 27
   }
 }
diff --git a/scripts/Android.bp b/scripts/Android.bp
index a11b007..bb0932c 100644
--- a/scripts/Android.bp
+++ b/scripts/Android.bp
@@ -34,3 +34,10 @@ python_binary_host {
     ],
 }
 
+// C++ packet runtime.
+cc_library_headers {
+    name: "pdl_cxx_packet_runtime",
+    export_include_dirs: ["."],
+    host_supported: true,
+    vendor_available: true,
+}
diff --git a/scripts/generate_cxx_backend.py b/scripts/generate_cxx_backend.py
index 0c8b9e3..13ea23d 100755
--- a/scripts/generate_cxx_backend.py
+++ b/scripts/generate_cxx_backend.py
@@ -1003,7 +1003,7 @@ def generate_packet_view_field_accessors(packet: ast.PacketDeclaration) -> List[
             accessors.append(
                 dedent("""\
                 std::vector<uint8_t> GetPayload() const {
-                    ASSERT(valid_);
+                    _ASSERT_VALID(valid_);
                     return payload_.bytes();
                 }
 
@@ -1015,7 +1015,7 @@ def generate_packet_view_field_accessors(packet: ast.PacketDeclaration) -> List[
             accessors.append(
                 dedent("""\
                 {array_type} Get{accessor_name}() const {{
-                    ASSERT(valid_);
+                    _ASSERT_VALID(valid_);
                     {accessor}
                 }}
 
@@ -1028,7 +1028,7 @@ def generate_packet_view_field_accessors(packet: ast.PacketDeclaration) -> List[
             accessors.append(
                 dedent("""\
                 {field_type} Get{accessor_name}() const {{
-                    ASSERT(valid_);
+                    _ASSERT_VALID(valid_);
                     return {member_name}_;
                 }}
 
@@ -1039,7 +1039,7 @@ def generate_packet_view_field_accessors(packet: ast.PacketDeclaration) -> List[
             accessors.append(
                 dedent("""\
                 {field_type}{field_qualifier} Get{accessor_name}() const {{
-                    ASSERT(valid_);
+                    _ASSERT_VALID(valid_);
                     return {member_name}_;
                 }}
 
@@ -1542,10 +1542,14 @@ def run(input: argparse.FileType, output: argparse.FileType, namespace: Optional
         {include_header}
         {using_namespace}
 
-        #ifndef ASSERT
+        #ifndef _ASSERT_VALID
+        #ifdef ASSERT
+        #define _ASSERT_VALID ASSERT
+        #else
         #include <cassert>
-        #define ASSERT assert
-        #endif  // !ASSERT
+        #define _ASSERT_VALID assert
+        #endif  // ASSERT
+        #endif  // !_ASSERT_VALID
 
         {open_namespace}
         """).format(input_name=input.name,
diff --git a/scripts/generate_cxx_backend_tests.py b/scripts/generate_cxx_backend_tests.py
index 123b08c..880988e 100755
--- a/scripts/generate_cxx_backend_tests.py
+++ b/scripts/generate_cxx_backend_tests.py
@@ -269,7 +269,7 @@ def generate_packet_serializer_test(serializer_test_suite: str, packet: ast.Pack
                 }};
                 {intermediate_declarations}
                 {child_packet_id}Builder packet = {built_packet};
-                ASSERT_EQ(packet.pdl::packet::Builder::Serialize(), expected_output);
+                ASSERT_EQ(packet.SerializeToBytes(), expected_output);
             }}
             """).format(serializer_test_suite=serializer_test_suite,
                         packet_id=packet.id,
diff --git a/scripts/generate_python_backend.py b/scripts/generate_python_backend.py
index 3a1a82b..475154d 100755
--- a/scripts/generate_python_backend.py
+++ b/scripts/generate_python_backend.py
@@ -908,7 +908,11 @@ def generate_enum_declaration(decl: ast.EnumDeclaration) -> str:
     enum_name = decl.id
     tag_decls = []
     for t in decl.tags:
-        tag_decls.append(f"{t.id} = {hex(t.value)}")
+        if t.value is not None:
+            tag_decls.append(f"{t.id} = {hex(t.value)}")
+        if t.range is not None:
+            tag_decls.append(f"{t.id}_START = {hex(t.range[0])}")
+            tag_decls.append(f"{t.id}_END = {hex(t.range[1])}")
 
     return dedent("""\
 
diff --git a/scripts/packet_runtime.h b/scripts/packet_runtime.h
index 4a76383..555d092 100644
--- a/scripts/packet_runtime.h
+++ b/scripts/packet_runtime.h
@@ -150,7 +150,7 @@ class Builder {
   }
 
   /// Helper method to serialize the packet to a byte vector.
-  virtual std::vector<uint8_t> Serialize() const {
+  virtual std::vector<uint8_t> SerializeToBytes() const {
     std::vector<uint8_t> output;
     Serialize(output);
     return output;
diff --git a/scripts/pdl/ast.py b/scripts/pdl/ast.py
index 4f884e5..b07f6ad 100644
--- a/scripts/pdl/ast.py
+++ b/scripts/pdl/ast.py
@@ -268,7 +268,7 @@ def convert_(obj: object) -> object:
         return [convert_(elt) for elt in obj]
     if isinstance(obj, object):
         if 'start' in obj.keys() and 'end' in obj.keys():
-            return (objs.start, obj.end)
+            return (obj['start'], obj['end'])
         kind = obj['kind']
         loc = obj['loc']
         loc = SourceRange(loc['file'], SourceLocation(**loc['start']), SourceLocation(**loc['end']))
diff --git a/src/backends/rust.rs b/src/backends/rust.rs
index cda1a8f..f369179 100644
--- a/src/backends/rust.rs
+++ b/src/backends/rust.rs
@@ -483,9 +483,9 @@ fn generate_packet_decl(
         }
 
         quote! {
-            let #parent_id_lower = Arc::new(#parent_data {
+            let #parent_id_lower = #parent_data {
                 #(#field: #value,)*
-            });
+            };
         }
     });
 
@@ -510,7 +510,7 @@ fn generate_packet_decl(
             #[derive(Debug, Clone, PartialEq, Eq)]
             #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
             pub enum #id_data_child {
-                #(#child(Arc<#child_data>),)*
+                #(#child(#child_data),)*
                 Payload(Bytes),
                 None,
             }
@@ -588,7 +588,7 @@ fn generate_packet_decl(
         pub struct #id_packet {
             #(
                 #[cfg_attr(feature = "serde", serde(flatten))]
-                #parent_lower_ids: Arc<#parent_data>,
+                #parent_lower_ids: #parent_data,
             )*
         }
 
@@ -637,12 +637,12 @@ fn generate_packet_decl(
 
             fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
                 let data = #top_level_data::parse_inner(&mut bytes)?;
-                Self::new(Arc::new(data))
+                Self::new(data)
             }
 
             #specialize
 
-            fn new(#top_level_id_lower: Arc<#top_level_data>) -> Result<Self> {
+            fn new(#top_level_id_lower: #top_level_data) -> Result<Self> {
                 #(
                     let #parent_shifted_lower_ids = match &#parent_lower_ids.child {
                         #parent_data_child::#parent_shifted_ids(value) => value.clone(),
@@ -656,7 +656,7 @@ fn generate_packet_decl(
             }
 
             #(pub fn #all_field_getter_names(&self) -> #all_field_borrows #all_field_types {
-                #all_field_borrows #all_field_self_field.as_ref().#all_field_names
+                #all_field_borrows #all_field_self_field.#all_field_names
             })*
 
             #get_payload
diff --git a/src/backends/rust/parser.rs b/src/backends/rust/parser.rs
index 33dd840..203a19b 100644
--- a/src/backends/rust/parser.rs
+++ b/src/backends/rust/parser.rs
@@ -702,7 +702,7 @@ impl<'a> FieldParser<'a> {
                     let mut cell = Cell::new(payload);
                     let child_data = #child_ids_data::parse_inner(&mut cell #child_parse_args)?;
                     // TODO(mgeisler): communicate back to user if !cell.get().is_empty()?
-                    #packet_data_child::#child_ids(Arc::new(child_data))
+                    #packet_data_child::#child_ids(child_data)
                 }),*
                 _ if !payload.is_empty() => {
                     #packet_data_child::Payload(Bytes::copy_from_slice(payload))
diff --git a/src/backends/rust/preamble.rs b/src/backends/rust/preamble.rs
index 45978f1..ce8b742 100644
--- a/src/backends/rust/preamble.rs
+++ b/src/backends/rust/preamble.rs
@@ -55,7 +55,6 @@ pub fn generate(path: &Path) -> proc_macro2::TokenStream {
         use std::convert::{TryFrom, TryInto};
         use std::cell::Cell;
         use std::fmt;
-        use std::sync::Arc;
         use thiserror::Error;
 
         type Result<T> = std::result::Result<T, Error>;
diff --git a/tests/examples/array-field.pdl b/tests/examples/array-field.pdl
deleted file mode 100644
index 070a6cc..0000000
--- a/tests/examples/array-field.pdl
+++ /dev/null
@@ -1,39 +0,0 @@
-little_endian_packets
-
-custom_field custom: 1 "custom"
-checksum checksum: 1 "checksum"
-
-enum Enum : 1 {
-    tag = 0,
-}
-
-struct Struct {
-    a: 1,
-}
-
-packet Packet {
-    a: 1,
-}
-
-group Group {
-    a: 1,
-}
-
-packet InvalidKind {
-    array_0: Group[],
-    array_1: Packet[],
-    array_2: checksum[],
-}
-
-packet UndeclaredType {
-    array: Unknown[],
-}
-
-packet Correct {
-    array_0: custom[],
-    array_1: Enum[],
-    array_2: Struct[],
-    array_3: 1[],
-    array_4: 1[42],
-    array_5: 1[+2],
-}
diff --git a/tests/examples/checksum-field.pdl b/tests/examples/checksum-field.pdl
deleted file mode 100644
index 0e1a98b..0000000
--- a/tests/examples/checksum-field.pdl
+++ /dev/null
@@ -1,22 +0,0 @@
-little_endian_packets
-
-checksum crc16: 16 "crc16"
-
-packet Undefined {
-    _checksum_start_ (crc16),
-}
-
-packet InvalidType {
-    crc16: 16,
-    _checksum_start_ (crc16),
-}
-
-packet InvalidOrder {
-    _checksum_start_ (crc16),
-    crc16: crc16,
-}
-
-packet Correct {
-    crc16: crc16,
-    _checksum_start_ (crc16),
-}
diff --git a/tests/examples/count-field.pdl b/tests/examples/count-field.pdl
deleted file mode 100644
index a88cccd..0000000
--- a/tests/examples/count-field.pdl
+++ /dev/null
@@ -1,25 +0,0 @@
-little_endian_packets
-
-packet Undefined {
-    _count_ (array): 8,
-}
-
-packet InvalidType {
-    _count_ (array): 8,
-    array: 16,
-}
-
-packet InvalidOrder {
-    array: 16[],
-    _count_ (array): 8,
-}
-
-packet InvalidSize {
-    _count_ (array): 8,
-    array: 16[32],
-}
-
-packet Correct {
-    _count_ (array): 8,
-    array: 16[],
-}
diff --git a/tests/examples/decl-scope.pdl b/tests/examples/decl-scope.pdl
deleted file mode 100644
index c1391ab..0000000
--- a/tests/examples/decl-scope.pdl
+++ /dev/null
@@ -1,26 +0,0 @@
-
-// Clashes with custom_field, struct, enum
-checksum decl_name: 16 "crc16"
-
-// Clashes with checksum, struct, enum
-custom_field decl_name: 1 "custom"
-
-// Clashes with checksum, custom_field, struct
-enum decl_name : 1 {
-    A = 1,
-}
-
-// Clashes with checksum, custom_field, enum
-struct decl_name {
-    a: 1,
-}
-
-// OK
-group decl_name {
-    a: 1,
-}
-
-// OK
-packet decl_name {
-    a: 1,
-}
diff --git a/tests/examples/example.pdl b/tests/examples/example.pdl
deleted file mode 100644
index b34d140..0000000
--- a/tests/examples/example.pdl
+++ /dev/null
@@ -1,78 +0,0 @@
-// line comment
-/* block comment */
-
-little_endian_packets
-
-/* stuff */
-enum FourBits : 4 {
-  ONE = 1,
-  TWO = 2,
-  THREE = 3,
-  FIVE = 5,
-  TEN = 10,
-  LAZY_ME = 15,
-}
-
-/* other stuff */
-enum FourBits : 4 {
-  ONE = 1,
-  TWO = 2,
-  THREE = 3,
-  FIVE = 5,
-  TEN = 10,
-  LAZY_ME = 15
-}
-
-packet Test {
-    /* Checksum */
-    _checksum_start_ (crc16),
-    /* Padding */
-    _padding_ [1],
-    /* Size */
-    _size_ (_payload_) : 1,
-    _size_ (_body_) : 1,
-    _size_ (id) : 1,
-    /* Body */
-    _body_,
-    /* Payload */
-    _payload_,
-    _payload_ : [+1],
-    /* Fixed */
-    _fixed_ = 1:1,
-    _fixed_ = id:id,
-    /* Reserved */
-    _reserved_ : 1,
-    /* Array */
-    id: 1[+1],
-    id: id[+1],
-    id: 1[1],
-    id: id[1],
-    id: 1[],
-    id: id[],
-    /* Scalar */
-    id: 1,
-    /* Typedef */
-    id : id,
-    /* Group */
-    id { a=1, b=2 },
-    id,
-}
-
-packet TestChild : Test {
-}
-
-packet TestChild (a=1, b=2) {
-}
-
-packet TestChild : Test (a=1, b=2) {
-}
-
-checksum id: 1 "id"
-
-custom_field id : 1 "id"
-custom_field id "id"
-
-test Test {
-    "1111",
-    "2222",
-}
diff --git a/tests/examples/fixed-field.pdl b/tests/examples/fixed-field.pdl
deleted file mode 100644
index e69fc7e..0000000
--- a/tests/examples/fixed-field.pdl
+++ /dev/null
@@ -1,22 +0,0 @@
-little_endian_packets
-
-enum Enum : 1 {
-    tag = 0,
-}
-
-packet InvalidValue {
-    _fixed_ = 1: 256,
-}
-
-packet UndeclaredEnum {
-    _fixed_ = tag : InvalidEnum,
-}
-
-packet UndeclaredTag {
-    _fixed_ = invalid_tag : Enum,
-}
-
-packet Correct {
-    _fixed_ = 1: 256,
-    _fixed_ = tag: Enum,
-}
diff --git a/tests/examples/group-constraint.pdl b/tests/examples/group-constraint.pdl
deleted file mode 100644
index 34ee2ab..0000000
--- a/tests/examples/group-constraint.pdl
+++ /dev/null
@@ -1,39 +0,0 @@
-little_endian_packets
-
-custom_field custom_field: 1 "custom"
-checksum checksum: 1 "checksum"
-
-enum Enum : 1 {
-    tag = 0,
-}
-
-group Group {
-    a: 4,
-    b: Enum,
-    c: custom_field,
-    d: checksum,
-}
-
-struct Undeclared {
-    Group { e=1 },
-}
-
-struct Redeclared {
-    Group { a=1, a=2 },
-}
-
-struct TypeMismatch {
-    Group { a=tag, b=1, c=1, d=1 },
-}
-
-struct InvalidLiteral {
-    Group { a=42 },
-}
-
-struct UndeclaredTag {
-    Group { b=undeclared_tag },
-}
-
-struct Correct {
-    Group { a=1, b=tag },
-}
diff --git a/tests/examples/packet.pdl b/tests/examples/packet.pdl
deleted file mode 100644
index 9b9ca20..0000000
--- a/tests/examples/packet.pdl
+++ /dev/null
@@ -1,52 +0,0 @@
-little_endian_packets
-
-custom_field custom: 1 "custom"
-checksum checksum: 1 "checksum"
-
-enum Enum : 1 {
-    tag = 0,
-}
-
-packet Packet {
-    a: 4,
-    b: Enum,
-    c: custom,
-    d: checksum,
-}
-
-struct Struct {
-    a: 4,
-}
-
-packet RecursivePacket_0 : RecursivePacket_1 {
-}
-
-packet RecursivePacket_1 : RecursivePacket_0 {
-}
-
-packet InvalidParent : Struct {
-}
-
-packet UndeclaredParent : FooBar {
-}
-
-packet UnnecessaryConstraints (a=1) {
-}
-
-packet Undeclared : Packet (c=1) {
-}
-
-packet Redeclared : Packet (a=1, a=2) {
-}
-
-packet TypeMismatch : Packet (a=tag, b=1, c=1, d=1) {
-}
-
-packet InvalidLiteral : Packet (a=42) {
-}
-
-packet UndeclaredTag : Packet (b=undeclared_tag) {
-}
-
-packet Correct : Packet (a=1, b=tag) {
-}
diff --git a/tests/examples/recurse.pdl b/tests/examples/recurse.pdl
deleted file mode 100644
index ad3a200..0000000
--- a/tests/examples/recurse.pdl
+++ /dev/null
@@ -1,38 +0,0 @@
-
-struct Struct_0: Struct_1 {
-}
-
-struct Struct_1: Struct_0 {
-}
-
-
-struct Packet_0: Packet_1 {
-}
-
-struct Packet_1: Packet_0 {
-}
-
-
-group Group_0 {
-    Group_1
-}
-
-struct Struct_2 {
-    Group_0
-}
-
-group Group_1 {
-    a: Struct_2
-}
-
-
-struct Struct_3: Struct_4 {
-}
-
-struct Struct_4 {
-    Group_2
-}
-
-group Group_2 {
-    a: Struct_3
-}
diff --git a/tests/examples/size-field.pdl b/tests/examples/size-field.pdl
deleted file mode 100644
index dfa9ad7..0000000
--- a/tests/examples/size-field.pdl
+++ /dev/null
@@ -1,58 +0,0 @@
-little_endian_packets
-
-packet Undefined {
-    _size_ (array): 8,
-}
-
-packet UndefinedPayloadWithBody {
-    _size_ (_payload_): 8,
-    _body_,
-}
-
-packet UndefinedPayload {
-    _size_ (_payload_): 8,
-}
-
-packet UndefinedBodyWithPayload {
-    _size_ (_body_): 8,
-    _payload_,
-}
-
-packet UndefinedBody {
-    _size_ (_body_): 8,
-}
-
-packet InvalidType {
-    _size_ (array): 8,
-    array: 16,
-}
-
-packet InvalidArrayOrder {
-    array: 16[],
-    _size_ (array): 8,
-}
-
-packet InvalidPayloadOrder {
-    _payload_,
-    _size_ (_payload_): 8,
-}
-
-packet InvalidBodyOrder {
-    _body_,
-    _size_ (_body_): 8,
-}
-
-packet CorrectArray {
-    _size_ (array): 8,
-    array: 16[],
-}
-
-packet CorrectPayload {
-    _size_ (_payload_): 8,
-    _payload_,
-}
-
-packet CorrectBody {
-    _size_ (_body_): 8,
-    _body_,
-}
diff --git a/tests/examples/struct.pdl b/tests/examples/struct.pdl
deleted file mode 100644
index d8ed439..0000000
--- a/tests/examples/struct.pdl
+++ /dev/null
@@ -1,52 +0,0 @@
-little_endian_packets
-
-custom_field custom: 1 "custom"
-checksum checksum: 1 "checksum"
-
-enum Enum : 1 {
-    tag = 0,
-}
-
-struct Struct {
-    a: 4,
-    b: Enum,
-    c: custom,
-    d: checksum,
-}
-
-packet Packet {
-    a: 4,
-}
-
-struct RecursiveStruct_0 : RecursiveStruct_1 {
-}
-
-struct RecursiveStruct_1 : RecursiveStruct_0 {
-}
-
-struct InvalidParent : Packet {
-}
-
-struct UndeclaredParent : FooBar {
-}
-
-struct UnnecessaryConstraints (a=1) {
-}
-
-struct Undeclared : Struct (c=1) {
-}
-
-struct Redeclared : Struct (a=1, a=2) {
-}
-
-struct TypeMismatch : Struct (a=tag, b=1, c=1, d=1) {
-}
-
-struct InvalidLiteral : Struct (a=42) {
-}
-
-struct UndeclaredTag : Struct (b=undeclared_tag) {
-}
-
-struct Correct : Struct (a=1, b=tag) {
-}
diff --git a/tests/examples/typedef-field.pdl b/tests/examples/typedef-field.pdl
deleted file mode 100644
index 2e56676..0000000
--- a/tests/examples/typedef-field.pdl
+++ /dev/null
@@ -1,36 +0,0 @@
-little_endian_packets
-
-custom_field custom: 1 "custom"
-checksum checksum: 1 "checksum"
-
-enum Enum : 1 {
-    tag = 0,
-}
-
-struct Struct {
-    a: 1,
-}
-
-packet Packet {
-    a: 1,
-}
-
-group Group {
-    a: 1,
-}
-
-packet InvalidKind {
-    typedef_0: Group,
-    typedef_1: Packet,
-}
-
-packet UndeclaredType {
-    typedef: Unknown,
-}
-
-packet Correct {
-    typedef_0: custom,
-    typedef_1: checksum,
-    typedef_2: Enum,
-    typedef_3: Struct,
-}
diff --git a/tests/generated/custom_field_declaration_big_endian.rs b/tests/generated/custom_field_declaration_big_endian.rs
index 31fa603..8046f5a 100644
--- a/tests/generated/custom_field_declaration_big_endian.rs
+++ b/tests/generated/custom_field_declaration_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
diff --git a/tests/generated/custom_field_declaration_little_endian.rs b/tests/generated/custom_field_declaration_little_endian.rs
index 31fa603..8046f5a 100644
--- a/tests/generated/custom_field_declaration_little_endian.rs
+++ b/tests/generated/custom_field_declaration_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
diff --git a/tests/generated/enum_declaration_big_endian.rs b/tests/generated/enum_declaration_big_endian.rs
index 87b5d0e..badb3f0 100644
--- a/tests/generated/enum_declaration_big_endian.rs
+++ b/tests/generated/enum_declaration_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
diff --git a/tests/generated/enum_declaration_little_endian.rs b/tests/generated/enum_declaration_little_endian.rs
index 87b5d0e..badb3f0 100644
--- a/tests/generated/enum_declaration_little_endian.rs
+++ b/tests/generated/enum_declaration_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
diff --git a/tests/generated/packet_decl_24bit_enum_array_big_endian.rs b/tests/generated/packet_decl_24bit_enum_array_big_endian.rs
index bd352ef..47b45dc 100644
--- a/tests/generated/packet_decl_24bit_enum_array_big_endian.rs
+++ b/tests/generated/packet_decl_24bit_enum_array_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -99,7 +98,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -178,13 +177,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &[Foo; 5] {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -195,7 +194,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_24bit_enum_array_little_endian.rs b/tests/generated/packet_decl_24bit_enum_array_little_endian.rs
index 5027984..a413ce1 100644
--- a/tests/generated/packet_decl_24bit_enum_array_little_endian.rs
+++ b/tests/generated/packet_decl_24bit_enum_array_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -99,7 +98,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -178,13 +177,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &[Foo; 5] {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -195,7 +194,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_24bit_enum_big_endian.rs b/tests/generated/packet_decl_24bit_enum_big_endian.rs
index d2b63be..c63b562 100644
--- a/tests/generated/packet_decl_24bit_enum_big_endian.rs
+++ b/tests/generated/packet_decl_24bit_enum_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -99,7 +98,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -170,13 +169,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> Foo {
-        self.bar.as_ref().x
+        self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -187,7 +186,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_24bit_enum_little_endian.rs b/tests/generated/packet_decl_24bit_enum_little_endian.rs
index 40f9894..2e58a9e 100644
--- a/tests/generated/packet_decl_24bit_enum_little_endian.rs
+++ b/tests/generated/packet_decl_24bit_enum_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -99,7 +98,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -170,13 +169,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> Foo {
-        self.bar.as_ref().x
+        self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -187,7 +186,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs b/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs
index eaa7537..193c5e5 100644
--- a/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs
+++ b/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -124,13 +123,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> &[u32; 5] {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -141,7 +140,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs b/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs
index f987846..fafba2c 100644
--- a/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs
+++ b/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -124,13 +123,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> &[u32; 5] {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -141,7 +140,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_24bit_scalar_big_endian.rs b/tests/generated/packet_decl_24bit_scalar_big_endian.rs
index e5aa0e2..15e76b0 100644
--- a/tests/generated/packet_decl_24bit_scalar_big_endian.rs
+++ b/tests/generated/packet_decl_24bit_scalar_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -121,13 +120,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> u32 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -138,7 +137,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_24bit_scalar_little_endian.rs b/tests/generated/packet_decl_24bit_scalar_little_endian.rs
index c9a65ed..77ede78 100644
--- a/tests/generated/packet_decl_24bit_scalar_little_endian.rs
+++ b/tests/generated/packet_decl_24bit_scalar_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -121,13 +120,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> u32 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -138,7 +137,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_64bit_enum_array_big_endian.rs b/tests/generated/packet_decl_64bit_enum_array_big_endian.rs
index 6940901..dd28666 100644
--- a/tests/generated/packet_decl_64bit_enum_array_big_endian.rs
+++ b/tests/generated/packet_decl_64bit_enum_array_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -84,7 +83,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -163,13 +162,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &[Foo; 7] {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -180,7 +179,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_64bit_enum_array_little_endian.rs b/tests/generated/packet_decl_64bit_enum_array_little_endian.rs
index a7008b3..371c1eb 100644
--- a/tests/generated/packet_decl_64bit_enum_array_little_endian.rs
+++ b/tests/generated/packet_decl_64bit_enum_array_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -84,7 +83,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -163,13 +162,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &[Foo; 7] {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -180,7 +179,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_64bit_enum_big_endian.rs b/tests/generated/packet_decl_64bit_enum_big_endian.rs
index a8f182c..bd46742 100644
--- a/tests/generated/packet_decl_64bit_enum_big_endian.rs
+++ b/tests/generated/packet_decl_64bit_enum_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -84,7 +83,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -155,13 +154,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> Foo {
-        self.bar.as_ref().x
+        self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -172,7 +171,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_64bit_enum_little_endian.rs b/tests/generated/packet_decl_64bit_enum_little_endian.rs
index 8fa8467..75a43b6 100644
--- a/tests/generated/packet_decl_64bit_enum_little_endian.rs
+++ b/tests/generated/packet_decl_64bit_enum_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -84,7 +83,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -155,13 +154,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> Foo {
-        self.bar.as_ref().x
+        self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -172,7 +171,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs b/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs
index d162424..b4816d6 100644
--- a/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs
+++ b/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -124,13 +123,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> &[u64; 7] {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -141,7 +140,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs b/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs
index 5d8c77e..b6c3423 100644
--- a/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs
+++ b/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -124,13 +123,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> &[u64; 7] {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -141,7 +140,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_64bit_scalar_big_endian.rs b/tests/generated/packet_decl_64bit_scalar_big_endian.rs
index 176a4af..1cda594 100644
--- a/tests/generated/packet_decl_64bit_scalar_big_endian.rs
+++ b/tests/generated/packet_decl_64bit_scalar_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -118,13 +117,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> u64 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -135,7 +134,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_64bit_scalar_little_endian.rs b/tests/generated/packet_decl_64bit_scalar_little_endian.rs
index 3f26f6c..10e62d4 100644
--- a/tests/generated/packet_decl_64bit_scalar_little_endian.rs
+++ b/tests/generated/packet_decl_64bit_scalar_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -118,13 +117,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> u64 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -135,7 +134,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_8bit_enum_array_big_endian.rs b/tests/generated/packet_decl_8bit_enum_array_big_endian.rs
index ef47d85..4c16ddf 100644
--- a/tests/generated/packet_decl_8bit_enum_array_big_endian.rs
+++ b/tests/generated/packet_decl_8bit_enum_array_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -114,7 +113,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -193,13 +192,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &[Foo; 3] {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -210,7 +209,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_8bit_enum_array_little_endian.rs b/tests/generated/packet_decl_8bit_enum_array_little_endian.rs
index ef47d85..4c16ddf 100644
--- a/tests/generated/packet_decl_8bit_enum_array_little_endian.rs
+++ b/tests/generated/packet_decl_8bit_enum_array_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -114,7 +113,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -193,13 +192,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &[Foo; 3] {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -210,7 +209,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_8bit_enum_big_endian.rs b/tests/generated/packet_decl_8bit_enum_big_endian.rs
index b3c4979..8ceb132 100644
--- a/tests/generated/packet_decl_8bit_enum_big_endian.rs
+++ b/tests/generated/packet_decl_8bit_enum_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -114,7 +113,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -185,13 +184,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> Foo {
-        self.bar.as_ref().x
+        self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -202,7 +201,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_8bit_enum_little_endian.rs b/tests/generated/packet_decl_8bit_enum_little_endian.rs
index b3c4979..8ceb132 100644
--- a/tests/generated/packet_decl_8bit_enum_little_endian.rs
+++ b/tests/generated/packet_decl_8bit_enum_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -114,7 +113,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -185,13 +184,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> Foo {
-        self.bar.as_ref().x
+        self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -202,7 +201,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_8bit_scalar_array_big_endian.rs b/tests/generated/packet_decl_8bit_scalar_array_big_endian.rs
index a1915a2..518a775 100644
--- a/tests/generated/packet_decl_8bit_scalar_array_big_endian.rs
+++ b/tests/generated/packet_decl_8bit_scalar_array_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -124,13 +123,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> &[u8; 3] {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -141,7 +140,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_8bit_scalar_array_little_endian.rs b/tests/generated/packet_decl_8bit_scalar_array_little_endian.rs
index a1915a2..518a775 100644
--- a/tests/generated/packet_decl_8bit_scalar_array_little_endian.rs
+++ b/tests/generated/packet_decl_8bit_scalar_array_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -124,13 +123,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> &[u8; 3] {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -141,7 +140,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_8bit_scalar_big_endian.rs b/tests/generated/packet_decl_8bit_scalar_big_endian.rs
index ae3515a..19b51a9 100644
--- a/tests/generated/packet_decl_8bit_scalar_big_endian.rs
+++ b/tests/generated/packet_decl_8bit_scalar_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -118,13 +117,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> u8 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -135,7 +134,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_8bit_scalar_little_endian.rs b/tests/generated/packet_decl_8bit_scalar_little_endian.rs
index ae3515a..19b51a9 100644
--- a/tests/generated/packet_decl_8bit_scalar_little_endian.rs
+++ b/tests/generated/packet_decl_8bit_scalar_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -118,13 +117,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> u8 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -135,7 +134,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { x: self.x });
+        let foo = FooData { x: self.x };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_dynamic_count_big_endian.rs b/tests/generated/packet_decl_array_dynamic_count_big_endian.rs
index c9a5e22..e1887d6 100644
--- a/tests/generated/packet_decl_array_dynamic_count_big_endian.rs
+++ b/tests/generated/packet_decl_array_dynamic_count_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -54,7 +53,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -144,16 +143,16 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_padding(&self) -> u8 {
-        self.foo.as_ref().padding
+        self.foo.padding
     }
     pub fn get_x(&self) -> &Vec<u32> {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -164,10 +163,10 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             padding: self.padding,
             x: self.x,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_dynamic_count_little_endian.rs b/tests/generated/packet_decl_array_dynamic_count_little_endian.rs
index 7a9f27f..a7fcdd1 100644
--- a/tests/generated/packet_decl_array_dynamic_count_little_endian.rs
+++ b/tests/generated/packet_decl_array_dynamic_count_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -54,7 +53,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -144,16 +143,16 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_padding(&self) -> u8 {
-        self.foo.as_ref().padding
+        self.foo.padding
     }
     pub fn get_x(&self) -> &Vec<u32> {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -164,10 +163,10 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             padding: self.padding,
             x: self.x,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_dynamic_size_big_endian.rs b/tests/generated/packet_decl_array_dynamic_size_big_endian.rs
index ec48736..934b21f 100644
--- a/tests/generated/packet_decl_array_dynamic_size_big_endian.rs
+++ b/tests/generated/packet_decl_array_dynamic_size_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -54,7 +53,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -155,16 +154,16 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_padding(&self) -> u8 {
-        self.foo.as_ref().padding
+        self.foo.padding
     }
     pub fn get_x(&self) -> &Vec<u32> {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -175,10 +174,10 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             padding: self.padding,
             x: self.x,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_dynamic_size_little_endian.rs b/tests/generated/packet_decl_array_dynamic_size_little_endian.rs
index cec18ee..d56c554 100644
--- a/tests/generated/packet_decl_array_dynamic_size_little_endian.rs
+++ b/tests/generated/packet_decl_array_dynamic_size_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -54,7 +53,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -155,16 +154,16 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_padding(&self) -> u8 {
-        self.foo.as_ref().padding
+        self.foo.padding
     }
     pub fn get_x(&self) -> &Vec<u32> {
-        &self.foo.as_ref().x
+        &self.foo.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -175,10 +174,10 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             padding: self.padding,
             x: self.x,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs b/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs
index b57eb29..0ddc911 100644
--- a/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs
+++ b/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -107,7 +106,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -184,13 +183,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &Vec<Foo> {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -201,7 +200,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs b/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs
index 3fb7990..86a85e4 100644
--- a/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs
+++ b/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -107,7 +106,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -184,13 +183,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &Vec<Foo> {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -201,7 +200,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs b/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs
index ee4459e..bd67530 100644
--- a/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs
+++ b/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -107,7 +106,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -196,13 +195,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &Vec<Foo> {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -213,7 +212,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs b/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs
index a0605eb..c41a8d4 100644
--- a/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs
+++ b/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -107,7 +106,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -196,13 +195,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_x(&self) -> &Vec<Foo> {
-        &self.bar.as_ref().x
+        &self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -213,7 +212,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
+        let bar = BarData { x: self.x };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_with_padding_big_endian.rs b/tests/generated/packet_decl_array_with_padding_big_endian.rs
index 36b5571..e45dc03 100644
--- a/tests/generated/packet_decl_array_with_padding_big_endian.rs
+++ b/tests/generated/packet_decl_array_with_padding_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -107,7 +106,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -188,13 +187,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_a(&self) -> &Vec<Foo> {
-        &self.bar.as_ref().a
+        &self.bar.a
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -205,7 +204,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { a: self.a });
+        let bar = BarData { a: self.a };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_array_with_padding_little_endian.rs b/tests/generated/packet_decl_array_with_padding_little_endian.rs
index 53cec92..bd1aae0 100644
--- a/tests/generated/packet_decl_array_with_padding_little_endian.rs
+++ b/tests/generated/packet_decl_array_with_padding_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -107,7 +106,7 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -188,13 +187,13 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = BarData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(bar: Arc<BarData>) -> Result<Self> {
+    fn new(bar: BarData) -> Result<Self> {
         Ok(Self { bar })
     }
     pub fn get_a(&self) -> &Vec<Foo> {
-        &self.bar.as_ref().a
+        &self.bar.a
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -205,7 +204,7 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { a: self.a });
+        let bar = BarData { a: self.a };
         Bar::new(bar).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_child_packets_big_endian.rs b/tests/generated/packet_decl_child_packets_big_endian.rs
index e8468a7..7a000c7 100644
--- a/tests/generated/packet_decl_child_packets_big_endian.rs
+++ b/tests/generated/packet_decl_child_packets_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -98,8 +97,8 @@ impl From<Enum16> for u64 {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum FooDataChild {
-    Bar(Arc<BarData>),
-    Baz(Arc<BazData>),
+    Bar(BarData),
+    Baz(BazData),
     Payload(Bytes),
     None,
 }
@@ -132,7 +131,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -194,12 +193,12 @@ impl FooData {
             (100, _) if BarData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = BarData::parse_inner(&mut cell)?;
-                FooDataChild::Bar(Arc::new(child_data))
+                FooDataChild::Bar(child_data)
             }
             (_, Enum16::B) if BazData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = BazData::parse_inner(&mut cell)?;
-                FooDataChild::Baz(Arc::new(child_data))
+                FooDataChild::Baz(child_data)
             }
             _ if !payload.is_empty() => {
                 FooDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -260,7 +259,7 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> FooChild {
         match &self.foo.child {
@@ -270,14 +269,14 @@ impl Foo {
             FooDataChild::None => FooChild::None,
         }
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> Enum16 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -288,14 +287,14 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             b: self.b,
             child: match self.payload {
                 None => FooDataChild::None,
                 Some(bytes) => FooDataChild::Payload(bytes),
             },
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
@@ -313,9 +312,9 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -392,9 +391,9 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         let bar = match &foo.child {
             FooDataChild::Bar(value) => value.clone(),
             _ => {
@@ -407,13 +406,13 @@ impl Bar {
         Ok(Self { foo, bar })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> Enum16 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_x(&self) -> u8 {
-        self.bar.as_ref().x
+        self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -424,12 +423,12 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
-        let foo = Arc::new(FooData {
+        let bar = BarData { x: self.x };
+        let foo = FooData {
             a: 100,
             b: self.b,
             child: FooDataChild::Bar(bar),
-        });
+        };
         Bar::new(foo).unwrap()
     }
 }
@@ -452,9 +451,9 @@ pub struct BazData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Baz {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    baz: Arc<BazData>,
+    baz: BazData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -531,9 +530,9 @@ impl Baz {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         let baz = match &foo.child {
             FooDataChild::Baz(value) => value.clone(),
             _ => {
@@ -546,13 +545,13 @@ impl Baz {
         Ok(Self { foo, baz })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> Enum16 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_y(&self) -> u16 {
-        self.baz.as_ref().y
+        self.baz.y
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.baz.write_to(buffer)
@@ -563,12 +562,12 @@ impl Baz {
 }
 impl BazBuilder {
     pub fn build(self) -> Baz {
-        let baz = Arc::new(BazData { y: self.y });
-        let foo = Arc::new(FooData {
+        let baz = BazData { y: self.y };
+        let foo = FooData {
             a: self.a,
             b: Enum16::B,
             child: FooDataChild::Baz(baz),
-        });
+        };
         Baz::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_child_packets_little_endian.rs b/tests/generated/packet_decl_child_packets_little_endian.rs
index bbbb261..7fe9783 100644
--- a/tests/generated/packet_decl_child_packets_little_endian.rs
+++ b/tests/generated/packet_decl_child_packets_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -98,8 +97,8 @@ impl From<Enum16> for u64 {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum FooDataChild {
-    Bar(Arc<BarData>),
-    Baz(Arc<BazData>),
+    Bar(BarData),
+    Baz(BazData),
     Payload(Bytes),
     None,
 }
@@ -132,7 +131,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -194,12 +193,12 @@ impl FooData {
             (100, _) if BarData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = BarData::parse_inner(&mut cell)?;
-                FooDataChild::Bar(Arc::new(child_data))
+                FooDataChild::Bar(child_data)
             }
             (_, Enum16::B) if BazData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = BazData::parse_inner(&mut cell)?;
-                FooDataChild::Baz(Arc::new(child_data))
+                FooDataChild::Baz(child_data)
             }
             _ if !payload.is_empty() => {
                 FooDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -260,7 +259,7 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> FooChild {
         match &self.foo.child {
@@ -270,14 +269,14 @@ impl Foo {
             FooDataChild::None => FooChild::None,
         }
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> Enum16 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -288,14 +287,14 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             b: self.b,
             child: match self.payload {
                 None => FooDataChild::None,
                 Some(bytes) => FooDataChild::Payload(bytes),
             },
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
@@ -313,9 +312,9 @@ pub struct BarData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    bar: Arc<BarData>,
+    bar: BarData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -392,9 +391,9 @@ impl Bar {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         let bar = match &foo.child {
             FooDataChild::Bar(value) => value.clone(),
             _ => {
@@ -407,13 +406,13 @@ impl Bar {
         Ok(Self { foo, bar })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> Enum16 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_x(&self) -> u8 {
-        self.bar.as_ref().x
+        self.bar.x
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.bar.write_to(buffer)
@@ -424,12 +423,12 @@ impl Bar {
 }
 impl BarBuilder {
     pub fn build(self) -> Bar {
-        let bar = Arc::new(BarData { x: self.x });
-        let foo = Arc::new(FooData {
+        let bar = BarData { x: self.x };
+        let foo = FooData {
             a: 100,
             b: self.b,
             child: FooDataChild::Bar(bar),
-        });
+        };
         Bar::new(foo).unwrap()
     }
 }
@@ -452,9 +451,9 @@ pub struct BazData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Baz {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    baz: Arc<BazData>,
+    baz: BazData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -531,9 +530,9 @@ impl Baz {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         let baz = match &foo.child {
             FooDataChild::Baz(value) => value.clone(),
             _ => {
@@ -546,13 +545,13 @@ impl Baz {
         Ok(Self { foo, baz })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> Enum16 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_y(&self) -> u16 {
-        self.baz.as_ref().y
+        self.baz.y
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.baz.write_to(buffer)
@@ -563,12 +562,12 @@ impl Baz {
 }
 impl BazBuilder {
     pub fn build(self) -> Baz {
-        let baz = Arc::new(BazData { y: self.y });
-        let foo = Arc::new(FooData {
+        let baz = BazData { y: self.y };
+        let foo = FooData {
             a: self.a,
             b: Enum16::B,
             child: FooDataChild::Baz(baz),
-        });
+        };
         Baz::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_complex_scalars_big_endian.rs b/tests/generated/packet_decl_complex_scalars_big_endian.rs
index 688af42..be97361 100644
--- a/tests/generated/packet_decl_complex_scalars_big_endian.rs
+++ b/tests/generated/packet_decl_complex_scalars_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -58,7 +57,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -168,28 +167,28 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> u8 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_c(&self) -> u8 {
-        self.foo.as_ref().c
+        self.foo.c
     }
     pub fn get_d(&self) -> u32 {
-        self.foo.as_ref().d
+        self.foo.d
     }
     pub fn get_e(&self) -> u16 {
-        self.foo.as_ref().e
+        self.foo.e
     }
     pub fn get_f(&self) -> u8 {
-        self.foo.as_ref().f
+        self.foo.f
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -200,14 +199,14 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             b: self.b,
             c: self.c,
             d: self.d,
             e: self.e,
             f: self.f,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_complex_scalars_little_endian.rs b/tests/generated/packet_decl_complex_scalars_little_endian.rs
index 83da632..7ccee61 100644
--- a/tests/generated/packet_decl_complex_scalars_little_endian.rs
+++ b/tests/generated/packet_decl_complex_scalars_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -58,7 +57,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -168,28 +167,28 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> u8 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_c(&self) -> u8 {
-        self.foo.as_ref().c
+        self.foo.c
     }
     pub fn get_d(&self) -> u32 {
-        self.foo.as_ref().d
+        self.foo.d
     }
     pub fn get_e(&self) -> u16 {
-        self.foo.as_ref().e
+        self.foo.e
     }
     pub fn get_f(&self) -> u8 {
-        self.foo.as_ref().f
+        self.foo.f
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -200,14 +199,14 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             b: self.b,
             c: self.c,
             d: self.d,
             e: self.e,
             f: self.f,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_custom_field_big_endian.rs b/tests/generated/packet_decl_custom_field_big_endian.rs
index 72bb2c6..7b7dc9a 100644
--- a/tests/generated/packet_decl_custom_field_big_endian.rs
+++ b/tests/generated/packet_decl_custom_field_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -93,7 +92,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -154,16 +153,16 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> Bar1 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> Bar2 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -174,7 +173,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { a: self.a, b: self.b });
+        let foo = FooData { a: self.a, b: self.b };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_custom_field_little_endian.rs b/tests/generated/packet_decl_custom_field_little_endian.rs
index 600bab6..d805403 100644
--- a/tests/generated/packet_decl_custom_field_little_endian.rs
+++ b/tests/generated/packet_decl_custom_field_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -93,7 +92,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -154,16 +153,16 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> Bar1 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> Bar2 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -174,7 +173,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { a: self.a, b: self.b });
+        let foo = FooData { a: self.a, b: self.b };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_empty_big_endian.rs b/tests/generated/packet_decl_empty_big_endian.rs
index d05c2ff..eb0b173 100644
--- a/tests/generated/packet_decl_empty_big_endian.rs
+++ b/tests/generated/packet_decl_empty_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -51,7 +50,7 @@ pub struct FooData {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -104,9 +103,9 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     fn write_to(&self, buffer: &mut BytesMut) {
@@ -118,7 +117,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {});
+        let foo = FooData {};
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_empty_little_endian.rs b/tests/generated/packet_decl_empty_little_endian.rs
index d05c2ff..eb0b173 100644
--- a/tests/generated/packet_decl_empty_little_endian.rs
+++ b/tests/generated/packet_decl_empty_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -51,7 +50,7 @@ pub struct FooData {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -104,9 +103,9 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     fn write_to(&self, buffer: &mut BytesMut) {
@@ -118,7 +117,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {});
+        let foo = FooData {};
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_fixed_enum_field_big_endian.rs b/tests/generated/packet_decl_fixed_enum_field_big_endian.rs
index 8683e02..2ec6b58 100644
--- a/tests/generated/packet_decl_fixed_enum_field_big_endian.rs
+++ b/tests/generated/packet_decl_fixed_enum_field_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -119,7 +118,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -198,13 +197,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_b(&self) -> u64 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -215,7 +214,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { b: self.b });
+        let foo = FooData { b: self.b };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_fixed_enum_field_little_endian.rs b/tests/generated/packet_decl_fixed_enum_field_little_endian.rs
index f598d3e..13aecd9 100644
--- a/tests/generated/packet_decl_fixed_enum_field_little_endian.rs
+++ b/tests/generated/packet_decl_fixed_enum_field_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -119,7 +118,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -198,13 +197,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_b(&self) -> u64 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -215,7 +214,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { b: self.b });
+        let foo = FooData { b: self.b };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_fixed_scalar_field_big_endian.rs b/tests/generated/packet_decl_fixed_scalar_field_big_endian.rs
index a44732e..e047669 100644
--- a/tests/generated/packet_decl_fixed_scalar_field_big_endian.rs
+++ b/tests/generated/packet_decl_fixed_scalar_field_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -132,13 +131,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_b(&self) -> u64 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -149,7 +148,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { b: self.b });
+        let foo = FooData { b: self.b };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_fixed_scalar_field_little_endian.rs b/tests/generated/packet_decl_fixed_scalar_field_little_endian.rs
index d2c7985..39922ca 100644
--- a/tests/generated/packet_decl_fixed_scalar_field_little_endian.rs
+++ b/tests/generated/packet_decl_fixed_scalar_field_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -53,7 +52,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -132,13 +131,13 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_b(&self) -> u64 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -149,7 +148,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData { b: self.b });
+        let foo = FooData { b: self.b };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_grand_children_big_endian.rs b/tests/generated/packet_decl_grand_children_big_endian.rs
index 33432f3..896a46f 100644
--- a/tests/generated/packet_decl_grand_children_big_endian.rs
+++ b/tests/generated/packet_decl_grand_children_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -98,7 +97,7 @@ impl From<Enum16> for u64 {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ParentDataChild {
-    Child(Arc<ChildData>),
+    Child(ChildData),
     Payload(Bytes),
     None,
 }
@@ -130,7 +129,7 @@ pub struct ParentData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -213,7 +212,7 @@ impl ParentData {
             (Enum16::A) if ChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = ChildData::parse_inner(&mut cell, bar, baz)?;
-                ParentDataChild::Child(Arc::new(child_data))
+                ParentDataChild::Child(child_data)
             }
             _ if !payload.is_empty() => {
                 ParentDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -274,7 +273,7 @@ impl Parent {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> ParentChild {
         match &self.parent.child {
@@ -285,17 +284,17 @@ impl Parent {
             ParentDataChild::None => ParentChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         Ok(Self { parent })
     }
     pub fn get_bar(&self) -> Enum16 {
-        self.parent.as_ref().bar
+        self.parent.bar
     }
     pub fn get_baz(&self) -> Enum16 {
-        self.parent.as_ref().baz
+        self.parent.baz
     }
     pub fn get_foo(&self) -> Enum16 {
-        self.parent.as_ref().foo
+        self.parent.foo
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.parent.write_to(buffer)
@@ -306,7 +305,7 @@ impl Parent {
 }
 impl ParentBuilder {
     pub fn build(self) -> Parent {
-        let parent = Arc::new(ParentData {
+        let parent = ParentData {
             bar: self.bar,
             baz: self.baz,
             foo: self.foo,
@@ -314,7 +313,7 @@ impl ParentBuilder {
                 None => ParentDataChild::None,
                 Some(bytes) => ParentDataChild::Payload(bytes),
             },
-        });
+        };
         Parent::new(parent).unwrap()
     }
 }
@@ -326,7 +325,7 @@ impl From<ParentBuilder> for Parent {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ChildDataChild {
-    GrandChild(Arc<GrandChildData>),
+    GrandChild(GrandChildData),
     Payload(Bytes),
     None,
 }
@@ -356,9 +355,9 @@ pub struct ChildData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    child: Arc<ChildData>,
+    child: ChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -402,7 +401,7 @@ impl ChildData {
             (Enum16::A, Enum16::A) if GrandChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = GrandChildData::parse_inner(&mut cell, baz)?;
-                ChildDataChild::GrandChild(Arc::new(child_data))
+                ChildDataChild::GrandChild(child_data)
             }
             _ if !payload.is_empty() => {
                 ChildDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -465,7 +464,7 @@ impl Child {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> ChildChild {
         match &self.child.child {
@@ -476,7 +475,7 @@ impl Child {
             ChildDataChild::None => ChildChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let child = match &parent.child {
             ParentDataChild::Child(value) => value.clone(),
             _ => {
@@ -489,16 +488,16 @@ impl Child {
         Ok(Self { parent, child })
     }
     pub fn get_bar(&self) -> Enum16 {
-        self.parent.as_ref().bar
+        self.parent.bar
     }
     pub fn get_baz(&self) -> Enum16 {
-        self.parent.as_ref().baz
+        self.parent.baz
     }
     pub fn get_foo(&self) -> Enum16 {
-        self.parent.as_ref().foo
+        self.parent.foo
     }
     pub fn get_quux(&self) -> Enum16 {
-        self.child.as_ref().quux
+        self.child.quux
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.child.write_to(buffer)
@@ -509,19 +508,19 @@ impl Child {
 }
 impl ChildBuilder {
     pub fn build(self) -> Child {
-        let child = Arc::new(ChildData {
+        let child = ChildData {
             quux: self.quux,
             child: match self.payload {
                 None => ChildDataChild::None,
                 Some(bytes) => ChildDataChild::Payload(bytes),
             },
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             bar: self.bar,
             baz: self.baz,
             foo: Enum16::A,
             child: ParentDataChild::Child(child),
-        });
+        };
         Child::new(parent).unwrap()
     }
 }
@@ -538,7 +537,7 @@ impl From<ChildBuilder> for Child {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum GrandChildDataChild {
-    GrandGrandChild(Arc<GrandGrandChildData>),
+    GrandGrandChild(GrandGrandChildData),
     Payload(Bytes),
     None,
 }
@@ -567,11 +566,11 @@ pub struct GrandChildData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandChild {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    child: Arc<ChildData>,
+    child: ChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    grandchild: Arc<GrandChildData>,
+    grandchild: GrandChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -595,7 +594,7 @@ impl GrandChildData {
             (Enum16::A) if GrandGrandChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = GrandGrandChildData::parse_inner(&mut cell)?;
-                GrandChildDataChild::GrandGrandChild(Arc::new(child_data))
+                GrandChildDataChild::GrandGrandChild(child_data)
             }
             _ if !payload.is_empty() => {
                 GrandChildDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -662,7 +661,7 @@ impl GrandChild {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> GrandChildChild {
         match &self.grandchild.child {
@@ -677,7 +676,7 @@ impl GrandChild {
             GrandChildDataChild::None => GrandChildChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let child = match &parent.child {
             ParentDataChild::Child(value) => value.clone(),
             _ => {
@@ -699,16 +698,16 @@ impl GrandChild {
         Ok(Self { parent, child, grandchild })
     }
     pub fn get_bar(&self) -> Enum16 {
-        self.parent.as_ref().bar
+        self.parent.bar
     }
     pub fn get_baz(&self) -> Enum16 {
-        self.parent.as_ref().baz
+        self.parent.baz
     }
     pub fn get_foo(&self) -> Enum16 {
-        self.parent.as_ref().foo
+        self.parent.foo
     }
     pub fn get_quux(&self) -> Enum16 {
-        self.child.as_ref().quux
+        self.child.quux
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.grandchild.write_to(buffer)
@@ -719,22 +718,22 @@ impl GrandChild {
 }
 impl GrandChildBuilder {
     pub fn build(self) -> GrandChild {
-        let grandchild = Arc::new(GrandChildData {
+        let grandchild = GrandChildData {
             child: match self.payload {
                 None => GrandChildDataChild::None,
                 Some(bytes) => GrandChildDataChild::Payload(bytes),
             },
-        });
-        let child = Arc::new(ChildData {
+        };
+        let child = ChildData {
             quux: Enum16::A,
             child: ChildDataChild::GrandChild(grandchild),
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             bar: Enum16::A,
             baz: self.baz,
             foo: Enum16::A,
             child: ParentDataChild::Child(child),
-        });
+        };
         GrandChild::new(parent).unwrap()
     }
 }
@@ -782,13 +781,13 @@ pub struct GrandGrandChildData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandGrandChild {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    child: Arc<ChildData>,
+    child: ChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    grandchild: Arc<GrandChildData>,
+    grandchild: GrandChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    grandgrandchild: Arc<GrandGrandChildData>,
+    grandgrandchild: GrandGrandChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -877,7 +876,7 @@ impl GrandGrandChild {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> GrandGrandChildChild {
         match &self.grandgrandchild.child {
@@ -887,7 +886,7 @@ impl GrandGrandChild {
             GrandGrandChildDataChild::None => GrandGrandChildChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let child = match &parent.child {
             ParentDataChild::Child(value) => value.clone(),
             _ => {
@@ -923,16 +922,16 @@ impl GrandGrandChild {
         })
     }
     pub fn get_bar(&self) -> Enum16 {
-        self.parent.as_ref().bar
+        self.parent.bar
     }
     pub fn get_baz(&self) -> Enum16 {
-        self.parent.as_ref().baz
+        self.parent.baz
     }
     pub fn get_foo(&self) -> Enum16 {
-        self.parent.as_ref().foo
+        self.parent.foo
     }
     pub fn get_quux(&self) -> Enum16 {
-        self.child.as_ref().quux
+        self.child.quux
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.grandgrandchild.child {
@@ -949,25 +948,25 @@ impl GrandGrandChild {
 }
 impl GrandGrandChildBuilder {
     pub fn build(self) -> GrandGrandChild {
-        let grandgrandchild = Arc::new(GrandGrandChildData {
+        let grandgrandchild = GrandGrandChildData {
             child: match self.payload {
                 None => GrandGrandChildDataChild::None,
                 Some(bytes) => GrandGrandChildDataChild::Payload(bytes),
             },
-        });
-        let grandchild = Arc::new(GrandChildData {
+        };
+        let grandchild = GrandChildData {
             child: GrandChildDataChild::GrandGrandChild(grandgrandchild),
-        });
-        let child = Arc::new(ChildData {
+        };
+        let child = ChildData {
             quux: Enum16::A,
             child: ChildDataChild::GrandChild(grandchild),
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             bar: Enum16::A,
             baz: Enum16::A,
             foo: Enum16::A,
             child: ParentDataChild::Child(child),
-        });
+        };
         GrandGrandChild::new(parent).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_grand_children_little_endian.rs b/tests/generated/packet_decl_grand_children_little_endian.rs
index c223814..4a672a6 100644
--- a/tests/generated/packet_decl_grand_children_little_endian.rs
+++ b/tests/generated/packet_decl_grand_children_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -98,7 +97,7 @@ impl From<Enum16> for u64 {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ParentDataChild {
-    Child(Arc<ChildData>),
+    Child(ChildData),
     Payload(Bytes),
     None,
 }
@@ -130,7 +129,7 @@ pub struct ParentData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -213,7 +212,7 @@ impl ParentData {
             (Enum16::A) if ChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = ChildData::parse_inner(&mut cell, bar, baz)?;
-                ParentDataChild::Child(Arc::new(child_data))
+                ParentDataChild::Child(child_data)
             }
             _ if !payload.is_empty() => {
                 ParentDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -274,7 +273,7 @@ impl Parent {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> ParentChild {
         match &self.parent.child {
@@ -285,17 +284,17 @@ impl Parent {
             ParentDataChild::None => ParentChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         Ok(Self { parent })
     }
     pub fn get_bar(&self) -> Enum16 {
-        self.parent.as_ref().bar
+        self.parent.bar
     }
     pub fn get_baz(&self) -> Enum16 {
-        self.parent.as_ref().baz
+        self.parent.baz
     }
     pub fn get_foo(&self) -> Enum16 {
-        self.parent.as_ref().foo
+        self.parent.foo
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.parent.write_to(buffer)
@@ -306,7 +305,7 @@ impl Parent {
 }
 impl ParentBuilder {
     pub fn build(self) -> Parent {
-        let parent = Arc::new(ParentData {
+        let parent = ParentData {
             bar: self.bar,
             baz: self.baz,
             foo: self.foo,
@@ -314,7 +313,7 @@ impl ParentBuilder {
                 None => ParentDataChild::None,
                 Some(bytes) => ParentDataChild::Payload(bytes),
             },
-        });
+        };
         Parent::new(parent).unwrap()
     }
 }
@@ -326,7 +325,7 @@ impl From<ParentBuilder> for Parent {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ChildDataChild {
-    GrandChild(Arc<GrandChildData>),
+    GrandChild(GrandChildData),
     Payload(Bytes),
     None,
 }
@@ -356,9 +355,9 @@ pub struct ChildData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    child: Arc<ChildData>,
+    child: ChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -402,7 +401,7 @@ impl ChildData {
             (Enum16::A, Enum16::A) if GrandChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = GrandChildData::parse_inner(&mut cell, baz)?;
-                ChildDataChild::GrandChild(Arc::new(child_data))
+                ChildDataChild::GrandChild(child_data)
             }
             _ if !payload.is_empty() => {
                 ChildDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -465,7 +464,7 @@ impl Child {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> ChildChild {
         match &self.child.child {
@@ -476,7 +475,7 @@ impl Child {
             ChildDataChild::None => ChildChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let child = match &parent.child {
             ParentDataChild::Child(value) => value.clone(),
             _ => {
@@ -489,16 +488,16 @@ impl Child {
         Ok(Self { parent, child })
     }
     pub fn get_bar(&self) -> Enum16 {
-        self.parent.as_ref().bar
+        self.parent.bar
     }
     pub fn get_baz(&self) -> Enum16 {
-        self.parent.as_ref().baz
+        self.parent.baz
     }
     pub fn get_foo(&self) -> Enum16 {
-        self.parent.as_ref().foo
+        self.parent.foo
     }
     pub fn get_quux(&self) -> Enum16 {
-        self.child.as_ref().quux
+        self.child.quux
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.child.write_to(buffer)
@@ -509,19 +508,19 @@ impl Child {
 }
 impl ChildBuilder {
     pub fn build(self) -> Child {
-        let child = Arc::new(ChildData {
+        let child = ChildData {
             quux: self.quux,
             child: match self.payload {
                 None => ChildDataChild::None,
                 Some(bytes) => ChildDataChild::Payload(bytes),
             },
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             bar: self.bar,
             baz: self.baz,
             foo: Enum16::A,
             child: ParentDataChild::Child(child),
-        });
+        };
         Child::new(parent).unwrap()
     }
 }
@@ -538,7 +537,7 @@ impl From<ChildBuilder> for Child {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum GrandChildDataChild {
-    GrandGrandChild(Arc<GrandGrandChildData>),
+    GrandGrandChild(GrandGrandChildData),
     Payload(Bytes),
     None,
 }
@@ -567,11 +566,11 @@ pub struct GrandChildData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandChild {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    child: Arc<ChildData>,
+    child: ChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    grandchild: Arc<GrandChildData>,
+    grandchild: GrandChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -595,7 +594,7 @@ impl GrandChildData {
             (Enum16::A) if GrandGrandChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = GrandGrandChildData::parse_inner(&mut cell)?;
-                GrandChildDataChild::GrandGrandChild(Arc::new(child_data))
+                GrandChildDataChild::GrandGrandChild(child_data)
             }
             _ if !payload.is_empty() => {
                 GrandChildDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -662,7 +661,7 @@ impl GrandChild {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> GrandChildChild {
         match &self.grandchild.child {
@@ -677,7 +676,7 @@ impl GrandChild {
             GrandChildDataChild::None => GrandChildChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let child = match &parent.child {
             ParentDataChild::Child(value) => value.clone(),
             _ => {
@@ -699,16 +698,16 @@ impl GrandChild {
         Ok(Self { parent, child, grandchild })
     }
     pub fn get_bar(&self) -> Enum16 {
-        self.parent.as_ref().bar
+        self.parent.bar
     }
     pub fn get_baz(&self) -> Enum16 {
-        self.parent.as_ref().baz
+        self.parent.baz
     }
     pub fn get_foo(&self) -> Enum16 {
-        self.parent.as_ref().foo
+        self.parent.foo
     }
     pub fn get_quux(&self) -> Enum16 {
-        self.child.as_ref().quux
+        self.child.quux
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.grandchild.write_to(buffer)
@@ -719,22 +718,22 @@ impl GrandChild {
 }
 impl GrandChildBuilder {
     pub fn build(self) -> GrandChild {
-        let grandchild = Arc::new(GrandChildData {
+        let grandchild = GrandChildData {
             child: match self.payload {
                 None => GrandChildDataChild::None,
                 Some(bytes) => GrandChildDataChild::Payload(bytes),
             },
-        });
-        let child = Arc::new(ChildData {
+        };
+        let child = ChildData {
             quux: Enum16::A,
             child: ChildDataChild::GrandChild(grandchild),
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             bar: Enum16::A,
             baz: self.baz,
             foo: Enum16::A,
             child: ParentDataChild::Child(child),
-        });
+        };
         GrandChild::new(parent).unwrap()
     }
 }
@@ -782,13 +781,13 @@ pub struct GrandGrandChildData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandGrandChild {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    child: Arc<ChildData>,
+    child: ChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    grandchild: Arc<GrandChildData>,
+    grandchild: GrandChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    grandgrandchild: Arc<GrandGrandChildData>,
+    grandgrandchild: GrandGrandChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -877,7 +876,7 @@ impl GrandGrandChild {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> GrandGrandChildChild {
         match &self.grandgrandchild.child {
@@ -887,7 +886,7 @@ impl GrandGrandChild {
             GrandGrandChildDataChild::None => GrandGrandChildChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let child = match &parent.child {
             ParentDataChild::Child(value) => value.clone(),
             _ => {
@@ -923,16 +922,16 @@ impl GrandGrandChild {
         })
     }
     pub fn get_bar(&self) -> Enum16 {
-        self.parent.as_ref().bar
+        self.parent.bar
     }
     pub fn get_baz(&self) -> Enum16 {
-        self.parent.as_ref().baz
+        self.parent.baz
     }
     pub fn get_foo(&self) -> Enum16 {
-        self.parent.as_ref().foo
+        self.parent.foo
     }
     pub fn get_quux(&self) -> Enum16 {
-        self.child.as_ref().quux
+        self.child.quux
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.grandgrandchild.child {
@@ -949,25 +948,25 @@ impl GrandGrandChild {
 }
 impl GrandGrandChildBuilder {
     pub fn build(self) -> GrandGrandChild {
-        let grandgrandchild = Arc::new(GrandGrandChildData {
+        let grandgrandchild = GrandGrandChildData {
             child: match self.payload {
                 None => GrandGrandChildDataChild::None,
                 Some(bytes) => GrandGrandChildDataChild::Payload(bytes),
             },
-        });
-        let grandchild = Arc::new(GrandChildData {
+        };
+        let grandchild = GrandChildData {
             child: GrandChildDataChild::GrandGrandChild(grandgrandchild),
-        });
-        let child = Arc::new(ChildData {
+        };
+        let child = ChildData {
             quux: Enum16::A,
             child: ChildDataChild::GrandChild(grandchild),
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             bar: Enum16::A,
             baz: Enum16::A,
             foo: Enum16::A,
             child: ParentDataChild::Child(child),
-        });
+        };
         GrandGrandChild::new(parent).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_mask_scalar_value_big_endian.rs b/tests/generated/packet_decl_mask_scalar_value_big_endian.rs
index 581542d..47f7a70 100644
--- a/tests/generated/packet_decl_mask_scalar_value_big_endian.rs
+++ b/tests/generated/packet_decl_mask_scalar_value_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -55,7 +54,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -135,19 +134,19 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> u32 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_c(&self) -> u8 {
-        self.foo.as_ref().c
+        self.foo.c
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -158,11 +157,11 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             b: self.b,
             c: self.c,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_mask_scalar_value_little_endian.rs b/tests/generated/packet_decl_mask_scalar_value_little_endian.rs
index 9bce70a..95f6c9d 100644
--- a/tests/generated/packet_decl_mask_scalar_value_little_endian.rs
+++ b/tests/generated/packet_decl_mask_scalar_value_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -55,7 +54,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -135,19 +134,19 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> u32 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_c(&self) -> u8 {
-        self.foo.as_ref().c
+        self.foo.c
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -158,11 +157,11 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             b: self.b,
             c: self.c,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_mixed_scalars_enums_big_endian.rs b/tests/generated/packet_decl_mixed_scalars_enums_big_endian.rs
index 87d0ecf..122b202 100644
--- a/tests/generated/packet_decl_mixed_scalars_enums_big_endian.rs
+++ b/tests/generated/packet_decl_mixed_scalars_enums_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -178,7 +177,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -270,22 +269,22 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_w(&self) -> u8 {
-        self.foo.as_ref().w
+        self.foo.w
     }
     pub fn get_x(&self) -> Enum7 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     pub fn get_y(&self) -> u8 {
-        self.foo.as_ref().y
+        self.foo.y
     }
     pub fn get_z(&self) -> Enum9 {
-        self.foo.as_ref().z
+        self.foo.z
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -296,12 +295,12 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             w: self.w,
             x: self.x,
             y: self.y,
             z: self.z,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_mixed_scalars_enums_little_endian.rs b/tests/generated/packet_decl_mixed_scalars_enums_little_endian.rs
index 85297cc..0cc3d92 100644
--- a/tests/generated/packet_decl_mixed_scalars_enums_little_endian.rs
+++ b/tests/generated/packet_decl_mixed_scalars_enums_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -178,7 +177,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -270,22 +269,22 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_w(&self) -> u8 {
-        self.foo.as_ref().w
+        self.foo.w
     }
     pub fn get_x(&self) -> Enum7 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     pub fn get_y(&self) -> u8 {
-        self.foo.as_ref().y
+        self.foo.y
     }
     pub fn get_z(&self) -> Enum9 {
-        self.foo.as_ref().z
+        self.foo.z
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -296,12 +295,12 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             w: self.w,
             x: self.x,
             y: self.y,
             z: self.z,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_parent_with_alias_child_big_endian.rs b/tests/generated/packet_decl_parent_with_alias_child_big_endian.rs
index a2c69a6..8c9232d 100644
--- a/tests/generated/packet_decl_parent_with_alias_child_big_endian.rs
+++ b/tests/generated/packet_decl_parent_with_alias_child_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -111,8 +110,8 @@ impl From<Enum8> for u64 {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ParentDataChild {
-    AliasChild(Arc<AliasChildData>),
-    NormalChild(Arc<NormalChildData>),
+    AliasChild(AliasChildData),
+    NormalChild(NormalChildData),
     Payload(Bytes),
     None,
 }
@@ -144,7 +143,7 @@ pub struct ParentData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -182,12 +181,12 @@ impl ParentData {
             (Enum8::B | Enum8::C) if AliasChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = AliasChildData::parse_inner(&mut cell, v)?;
-                ParentDataChild::AliasChild(Arc::new(child_data))
+                ParentDataChild::AliasChild(child_data)
             }
             (Enum8::A) if NormalChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = NormalChildData::parse_inner(&mut cell)?;
-                ParentDataChild::NormalChild(Arc::new(child_data))
+                ParentDataChild::NormalChild(child_data)
             }
             _ if !payload.is_empty() => {
                 ParentDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -240,7 +239,7 @@ impl Parent {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> ParentChild {
         match &self.parent.child {
@@ -254,11 +253,11 @@ impl Parent {
             ParentDataChild::None => ParentChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         Ok(Self { parent })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.parent.write_to(buffer)
@@ -269,13 +268,13 @@ impl Parent {
 }
 impl ParentBuilder {
     pub fn build(self) -> Parent {
-        let parent = Arc::new(ParentData {
+        let parent = ParentData {
             v: self.v,
             child: match self.payload {
                 None => ParentDataChild::None,
                 Some(bytes) => ParentDataChild::Payload(bytes),
             },
-        });
+        };
         Parent::new(parent).unwrap()
     }
 }
@@ -287,8 +286,8 @@ impl From<ParentBuilder> for Parent {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum AliasChildDataChild {
-    NormalGrandChild1(Arc<NormalGrandChild1Data>),
-    NormalGrandChild2(Arc<NormalGrandChild2Data>),
+    NormalGrandChild1(NormalGrandChild1Data),
+    NormalGrandChild2(NormalGrandChild2Data),
     Payload(Bytes),
     None,
 }
@@ -319,9 +318,9 @@ pub struct AliasChildData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct AliasChild {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    aliaschild: Arc<AliasChildData>,
+    aliaschild: AliasChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -345,12 +344,12 @@ impl AliasChildData {
             (Enum8::B) if NormalGrandChild1Data::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = NormalGrandChild1Data::parse_inner(&mut cell)?;
-                AliasChildDataChild::NormalGrandChild1(Arc::new(child_data))
+                AliasChildDataChild::NormalGrandChild1(child_data)
             }
             (Enum8::C) if NormalGrandChild2Data::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = NormalGrandChild2Data::parse_inner(&mut cell)?;
-                AliasChildDataChild::NormalGrandChild2(Arc::new(child_data))
+                AliasChildDataChild::NormalGrandChild2(child_data)
             }
             _ if !payload.is_empty() => {
                 AliasChildDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -413,7 +412,7 @@ impl AliasChild {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> AliasChildChild {
         match &self.aliaschild.child {
@@ -433,7 +432,7 @@ impl AliasChild {
             AliasChildDataChild::None => AliasChildChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let aliaschild = match &parent.child {
             ParentDataChild::AliasChild(value) => value.clone(),
             _ => {
@@ -446,7 +445,7 @@ impl AliasChild {
         Ok(Self { parent, aliaschild })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.aliaschild.write_to(buffer)
@@ -457,16 +456,16 @@ impl AliasChild {
 }
 impl AliasChildBuilder {
     pub fn build(self) -> AliasChild {
-        let aliaschild = Arc::new(AliasChildData {
+        let aliaschild = AliasChildData {
             child: match self.payload {
                 None => AliasChildDataChild::None,
                 Some(bytes) => AliasChildDataChild::Payload(bytes),
             },
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             v: self.v,
             child: ParentDataChild::AliasChild(aliaschild),
-        });
+        };
         AliasChild::new(parent).unwrap()
     }
 }
@@ -487,9 +486,9 @@ pub struct NormalChildData {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalChild {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    normalchild: Arc<NormalChildData>,
+    normalchild: NormalChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -553,9 +552,9 @@ impl NormalChild {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let normalchild = match &parent.child {
             ParentDataChild::NormalChild(value) => value.clone(),
             _ => {
@@ -568,7 +567,7 @@ impl NormalChild {
         Ok(Self { parent, normalchild })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.normalchild.write_to(buffer)
@@ -579,11 +578,11 @@ impl NormalChild {
 }
 impl NormalChildBuilder {
     pub fn build(self) -> NormalChild {
-        let normalchild = Arc::new(NormalChildData {});
-        let parent = Arc::new(ParentData {
+        let normalchild = NormalChildData {};
+        let parent = ParentData {
             v: Enum8::A,
             child: ParentDataChild::NormalChild(normalchild),
-        });
+        };
         NormalChild::new(parent).unwrap()
     }
 }
@@ -604,11 +603,11 @@ pub struct NormalGrandChild1Data {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalGrandChild1 {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    aliaschild: Arc<AliasChildData>,
+    aliaschild: AliasChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    normalgrandchild1: Arc<NormalGrandChild1Data>,
+    normalgrandchild1: NormalGrandChild1Data,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -677,9 +676,9 @@ impl NormalGrandChild1 {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let aliaschild = match &parent.child {
             ParentDataChild::AliasChild(value) => value.clone(),
             _ => {
@@ -705,7 +704,7 @@ impl NormalGrandChild1 {
         })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.normalgrandchild1.write_to(buffer)
@@ -716,14 +715,14 @@ impl NormalGrandChild1 {
 }
 impl NormalGrandChild1Builder {
     pub fn build(self) -> NormalGrandChild1 {
-        let normalgrandchild1 = Arc::new(NormalGrandChild1Data {});
-        let aliaschild = Arc::new(AliasChildData {
+        let normalgrandchild1 = NormalGrandChild1Data {};
+        let aliaschild = AliasChildData {
             child: AliasChildDataChild::NormalGrandChild1(normalgrandchild1),
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             v: Enum8::B,
             child: ParentDataChild::AliasChild(aliaschild),
-        });
+        };
         NormalGrandChild1::new(parent).unwrap()
     }
 }
@@ -771,11 +770,11 @@ pub struct NormalGrandChild2Data {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalGrandChild2 {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    aliaschild: Arc<AliasChildData>,
+    aliaschild: AliasChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    normalgrandchild2: Arc<NormalGrandChild2Data>,
+    normalgrandchild2: NormalGrandChild2Data,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -859,7 +858,7 @@ impl NormalGrandChild2 {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> NormalGrandChild2Child {
         match &self.normalgrandchild2.child {
@@ -869,7 +868,7 @@ impl NormalGrandChild2 {
             NormalGrandChild2DataChild::None => NormalGrandChild2Child::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let aliaschild = match &parent.child {
             ParentDataChild::AliasChild(value) => value.clone(),
             _ => {
@@ -895,7 +894,7 @@ impl NormalGrandChild2 {
         })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.normalgrandchild2.child {
@@ -912,19 +911,19 @@ impl NormalGrandChild2 {
 }
 impl NormalGrandChild2Builder {
     pub fn build(self) -> NormalGrandChild2 {
-        let normalgrandchild2 = Arc::new(NormalGrandChild2Data {
+        let normalgrandchild2 = NormalGrandChild2Data {
             child: match self.payload {
                 None => NormalGrandChild2DataChild::None,
                 Some(bytes) => NormalGrandChild2DataChild::Payload(bytes),
             },
-        });
-        let aliaschild = Arc::new(AliasChildData {
+        };
+        let aliaschild = AliasChildData {
             child: AliasChildDataChild::NormalGrandChild2(normalgrandchild2),
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             v: Enum8::C,
             child: ParentDataChild::AliasChild(aliaschild),
-        });
+        };
         NormalGrandChild2::new(parent).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_parent_with_alias_child_little_endian.rs b/tests/generated/packet_decl_parent_with_alias_child_little_endian.rs
index a2c69a6..8c9232d 100644
--- a/tests/generated/packet_decl_parent_with_alias_child_little_endian.rs
+++ b/tests/generated/packet_decl_parent_with_alias_child_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -111,8 +110,8 @@ impl From<Enum8> for u64 {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ParentDataChild {
-    AliasChild(Arc<AliasChildData>),
-    NormalChild(Arc<NormalChildData>),
+    AliasChild(AliasChildData),
+    NormalChild(NormalChildData),
     Payload(Bytes),
     None,
 }
@@ -144,7 +143,7 @@ pub struct ParentData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -182,12 +181,12 @@ impl ParentData {
             (Enum8::B | Enum8::C) if AliasChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = AliasChildData::parse_inner(&mut cell, v)?;
-                ParentDataChild::AliasChild(Arc::new(child_data))
+                ParentDataChild::AliasChild(child_data)
             }
             (Enum8::A) if NormalChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = NormalChildData::parse_inner(&mut cell)?;
-                ParentDataChild::NormalChild(Arc::new(child_data))
+                ParentDataChild::NormalChild(child_data)
             }
             _ if !payload.is_empty() => {
                 ParentDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -240,7 +239,7 @@ impl Parent {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> ParentChild {
         match &self.parent.child {
@@ -254,11 +253,11 @@ impl Parent {
             ParentDataChild::None => ParentChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         Ok(Self { parent })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.parent.write_to(buffer)
@@ -269,13 +268,13 @@ impl Parent {
 }
 impl ParentBuilder {
     pub fn build(self) -> Parent {
-        let parent = Arc::new(ParentData {
+        let parent = ParentData {
             v: self.v,
             child: match self.payload {
                 None => ParentDataChild::None,
                 Some(bytes) => ParentDataChild::Payload(bytes),
             },
-        });
+        };
         Parent::new(parent).unwrap()
     }
 }
@@ -287,8 +286,8 @@ impl From<ParentBuilder> for Parent {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum AliasChildDataChild {
-    NormalGrandChild1(Arc<NormalGrandChild1Data>),
-    NormalGrandChild2(Arc<NormalGrandChild2Data>),
+    NormalGrandChild1(NormalGrandChild1Data),
+    NormalGrandChild2(NormalGrandChild2Data),
     Payload(Bytes),
     None,
 }
@@ -319,9 +318,9 @@ pub struct AliasChildData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct AliasChild {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    aliaschild: Arc<AliasChildData>,
+    aliaschild: AliasChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -345,12 +344,12 @@ impl AliasChildData {
             (Enum8::B) if NormalGrandChild1Data::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = NormalGrandChild1Data::parse_inner(&mut cell)?;
-                AliasChildDataChild::NormalGrandChild1(Arc::new(child_data))
+                AliasChildDataChild::NormalGrandChild1(child_data)
             }
             (Enum8::C) if NormalGrandChild2Data::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = NormalGrandChild2Data::parse_inner(&mut cell)?;
-                AliasChildDataChild::NormalGrandChild2(Arc::new(child_data))
+                AliasChildDataChild::NormalGrandChild2(child_data)
             }
             _ if !payload.is_empty() => {
                 AliasChildDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -413,7 +412,7 @@ impl AliasChild {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> AliasChildChild {
         match &self.aliaschild.child {
@@ -433,7 +432,7 @@ impl AliasChild {
             AliasChildDataChild::None => AliasChildChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let aliaschild = match &parent.child {
             ParentDataChild::AliasChild(value) => value.clone(),
             _ => {
@@ -446,7 +445,7 @@ impl AliasChild {
         Ok(Self { parent, aliaschild })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.aliaschild.write_to(buffer)
@@ -457,16 +456,16 @@ impl AliasChild {
 }
 impl AliasChildBuilder {
     pub fn build(self) -> AliasChild {
-        let aliaschild = Arc::new(AliasChildData {
+        let aliaschild = AliasChildData {
             child: match self.payload {
                 None => AliasChildDataChild::None,
                 Some(bytes) => AliasChildDataChild::Payload(bytes),
             },
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             v: self.v,
             child: ParentDataChild::AliasChild(aliaschild),
-        });
+        };
         AliasChild::new(parent).unwrap()
     }
 }
@@ -487,9 +486,9 @@ pub struct NormalChildData {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalChild {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    normalchild: Arc<NormalChildData>,
+    normalchild: NormalChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -553,9 +552,9 @@ impl NormalChild {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let normalchild = match &parent.child {
             ParentDataChild::NormalChild(value) => value.clone(),
             _ => {
@@ -568,7 +567,7 @@ impl NormalChild {
         Ok(Self { parent, normalchild })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.normalchild.write_to(buffer)
@@ -579,11 +578,11 @@ impl NormalChild {
 }
 impl NormalChildBuilder {
     pub fn build(self) -> NormalChild {
-        let normalchild = Arc::new(NormalChildData {});
-        let parent = Arc::new(ParentData {
+        let normalchild = NormalChildData {};
+        let parent = ParentData {
             v: Enum8::A,
             child: ParentDataChild::NormalChild(normalchild),
-        });
+        };
         NormalChild::new(parent).unwrap()
     }
 }
@@ -604,11 +603,11 @@ pub struct NormalGrandChild1Data {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalGrandChild1 {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    aliaschild: Arc<AliasChildData>,
+    aliaschild: AliasChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    normalgrandchild1: Arc<NormalGrandChild1Data>,
+    normalgrandchild1: NormalGrandChild1Data,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -677,9 +676,9 @@ impl NormalGrandChild1 {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let aliaschild = match &parent.child {
             ParentDataChild::AliasChild(value) => value.clone(),
             _ => {
@@ -705,7 +704,7 @@ impl NormalGrandChild1 {
         })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.normalgrandchild1.write_to(buffer)
@@ -716,14 +715,14 @@ impl NormalGrandChild1 {
 }
 impl NormalGrandChild1Builder {
     pub fn build(self) -> NormalGrandChild1 {
-        let normalgrandchild1 = Arc::new(NormalGrandChild1Data {});
-        let aliaschild = Arc::new(AliasChildData {
+        let normalgrandchild1 = NormalGrandChild1Data {};
+        let aliaschild = AliasChildData {
             child: AliasChildDataChild::NormalGrandChild1(normalgrandchild1),
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             v: Enum8::B,
             child: ParentDataChild::AliasChild(aliaschild),
-        });
+        };
         NormalGrandChild1::new(parent).unwrap()
     }
 }
@@ -771,11 +770,11 @@ pub struct NormalGrandChild2Data {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalGrandChild2 {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    aliaschild: Arc<AliasChildData>,
+    aliaschild: AliasChildData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    normalgrandchild2: Arc<NormalGrandChild2Data>,
+    normalgrandchild2: NormalGrandChild2Data,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -859,7 +858,7 @@ impl NormalGrandChild2 {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> NormalGrandChild2Child {
         match &self.normalgrandchild2.child {
@@ -869,7 +868,7 @@ impl NormalGrandChild2 {
             NormalGrandChild2DataChild::None => NormalGrandChild2Child::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let aliaschild = match &parent.child {
             ParentDataChild::AliasChild(value) => value.clone(),
             _ => {
@@ -895,7 +894,7 @@ impl NormalGrandChild2 {
         })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.normalgrandchild2.child {
@@ -912,19 +911,19 @@ impl NormalGrandChild2 {
 }
 impl NormalGrandChild2Builder {
     pub fn build(self) -> NormalGrandChild2 {
-        let normalgrandchild2 = Arc::new(NormalGrandChild2Data {
+        let normalgrandchild2 = NormalGrandChild2Data {
             child: match self.payload {
                 None => NormalGrandChild2DataChild::None,
                 Some(bytes) => NormalGrandChild2DataChild::Payload(bytes),
             },
-        });
-        let aliaschild = Arc::new(AliasChildData {
+        };
+        let aliaschild = AliasChildData {
             child: AliasChildDataChild::NormalGrandChild2(normalgrandchild2),
-        });
-        let parent = Arc::new(ParentData {
+        };
+        let parent = ParentData {
             v: Enum8::C,
             child: ParentDataChild::AliasChild(aliaschild),
-        });
+        };
         NormalGrandChild2::new(parent).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_parent_with_no_payload_big_endian.rs b/tests/generated/packet_decl_parent_with_no_payload_big_endian.rs
index 35c6dac..4f58e26 100644
--- a/tests/generated/packet_decl_parent_with_no_payload_big_endian.rs
+++ b/tests/generated/packet_decl_parent_with_no_payload_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -105,7 +104,7 @@ impl From<Enum8> for u64 {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ParentDataChild {
-    Child(Arc<ChildData>),
+    Child(ChildData),
     Payload(Bytes),
     None,
 }
@@ -135,7 +134,7 @@ pub struct ParentData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -172,7 +171,7 @@ impl ParentData {
             (Enum8::A) if ChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = ChildData::parse_inner(&mut cell)?;
-                ParentDataChild::Child(Arc::new(child_data))
+                ParentDataChild::Child(child_data)
             }
             _ if !payload.is_empty() => {
                 ParentDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -219,7 +218,7 @@ impl Parent {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> ParentChild {
         match &self.parent.child {
@@ -230,11 +229,11 @@ impl Parent {
             ParentDataChild::None => ParentChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         Ok(Self { parent })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.parent.write_to(buffer)
@@ -245,10 +244,10 @@ impl Parent {
 }
 impl ParentBuilder {
     pub fn build(self) -> Parent {
-        let parent = Arc::new(ParentData {
+        let parent = ParentData {
             v: self.v,
             child: ParentDataChild::None,
-        });
+        };
         Parent::new(parent).unwrap()
     }
 }
@@ -264,9 +263,9 @@ pub struct ChildData {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    child: Arc<ChildData>,
+    child: ChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -330,9 +329,9 @@ impl Child {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let child = match &parent.child {
             ParentDataChild::Child(value) => value.clone(),
             _ => {
@@ -345,7 +344,7 @@ impl Child {
         Ok(Self { parent, child })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.child.write_to(buffer)
@@ -356,11 +355,11 @@ impl Child {
 }
 impl ChildBuilder {
     pub fn build(self) -> Child {
-        let child = Arc::new(ChildData {});
-        let parent = Arc::new(ParentData {
+        let child = ChildData {};
+        let parent = ParentData {
             v: Enum8::A,
             child: ParentDataChild::None,
-        });
+        };
         Child::new(parent).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_parent_with_no_payload_little_endian.rs b/tests/generated/packet_decl_parent_with_no_payload_little_endian.rs
index 35c6dac..4f58e26 100644
--- a/tests/generated/packet_decl_parent_with_no_payload_little_endian.rs
+++ b/tests/generated/packet_decl_parent_with_no_payload_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -105,7 +104,7 @@ impl From<Enum8> for u64 {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ParentDataChild {
-    Child(Arc<ChildData>),
+    Child(ChildData),
     Payload(Bytes),
     None,
 }
@@ -135,7 +134,7 @@ pub struct ParentData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -172,7 +171,7 @@ impl ParentData {
             (Enum8::A) if ChildData::conforms(&payload) => {
                 let mut cell = Cell::new(payload);
                 let child_data = ChildData::parse_inner(&mut cell)?;
-                ParentDataChild::Child(Arc::new(child_data))
+                ParentDataChild::Child(child_data)
             }
             _ if !payload.is_empty() => {
                 ParentDataChild::Payload(Bytes::copy_from_slice(payload))
@@ -219,7 +218,7 @@ impl Parent {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> ParentChild {
         match &self.parent.child {
@@ -230,11 +229,11 @@ impl Parent {
             ParentDataChild::None => ParentChild::None,
         }
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         Ok(Self { parent })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.parent.write_to(buffer)
@@ -245,10 +244,10 @@ impl Parent {
 }
 impl ParentBuilder {
     pub fn build(self) -> Parent {
-        let parent = Arc::new(ParentData {
+        let parent = ParentData {
             v: self.v,
             child: ParentDataChild::None,
-        });
+        };
         Parent::new(parent).unwrap()
     }
 }
@@ -264,9 +263,9 @@ pub struct ChildData {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    parent: Arc<ParentData>,
+    parent: ParentData,
     #[cfg_attr(feature = "serde", serde(flatten))]
-    child: Arc<ChildData>,
+    child: ChildData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -330,9 +329,9 @@ impl Child {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = ParentData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(parent: Arc<ParentData>) -> Result<Self> {
+    fn new(parent: ParentData) -> Result<Self> {
         let child = match &parent.child {
             ParentDataChild::Child(value) => value.clone(),
             _ => {
@@ -345,7 +344,7 @@ impl Child {
         Ok(Self { parent, child })
     }
     pub fn get_v(&self) -> Enum8 {
-        self.parent.as_ref().v
+        self.parent.v
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.child.write_to(buffer)
@@ -356,11 +355,11 @@ impl Child {
 }
 impl ChildBuilder {
     pub fn build(self) -> Child {
-        let child = Arc::new(ChildData {});
-        let parent = Arc::new(ParentData {
+        let child = ChildData {};
+        let parent = ParentData {
             v: Enum8::A,
             child: ParentDataChild::None,
-        });
+        };
         Child::new(parent).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_payload_field_unknown_size_big_endian.rs b/tests/generated/packet_decl_payload_field_unknown_size_big_endian.rs
index 452c365..be55b05 100644
--- a/tests/generated/packet_decl_payload_field_unknown_size_big_endian.rs
+++ b/tests/generated/packet_decl_payload_field_unknown_size_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -74,7 +73,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -155,7 +154,7 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> FooChild {
         match &self.foo.child {
@@ -163,11 +162,11 @@ impl Foo {
             FooDataChild::None => FooChild::None,
         }
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u32 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.foo.child {
@@ -184,13 +183,13 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             child: match self.payload {
                 None => FooDataChild::None,
                 Some(bytes) => FooDataChild::Payload(bytes),
             },
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_payload_field_unknown_size_little_endian.rs b/tests/generated/packet_decl_payload_field_unknown_size_little_endian.rs
index 99c06b9..bc20979 100644
--- a/tests/generated/packet_decl_payload_field_unknown_size_little_endian.rs
+++ b/tests/generated/packet_decl_payload_field_unknown_size_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -74,7 +73,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -155,7 +154,7 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> FooChild {
         match &self.foo.child {
@@ -163,11 +162,11 @@ impl Foo {
             FooDataChild::None => FooChild::None,
         }
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u32 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.foo.child {
@@ -184,13 +183,13 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             child: match self.payload {
                 None => FooDataChild::None,
                 Some(bytes) => FooDataChild::Payload(bytes),
             },
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_payload_field_unknown_size_terminal_big_endian.rs b/tests/generated/packet_decl_payload_field_unknown_size_terminal_big_endian.rs
index f54477a..a8af260 100644
--- a/tests/generated/packet_decl_payload_field_unknown_size_terminal_big_endian.rs
+++ b/tests/generated/packet_decl_payload_field_unknown_size_terminal_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -74,7 +73,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -162,7 +161,7 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> FooChild {
         match &self.foo.child {
@@ -170,11 +169,11 @@ impl Foo {
             FooDataChild::None => FooChild::None,
         }
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u32 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.foo.child {
@@ -191,13 +190,13 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             child: match self.payload {
                 None => FooDataChild::None,
                 Some(bytes) => FooDataChild::Payload(bytes),
             },
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_payload_field_unknown_size_terminal_little_endian.rs b/tests/generated/packet_decl_payload_field_unknown_size_terminal_little_endian.rs
index 616c87f..c615757 100644
--- a/tests/generated/packet_decl_payload_field_unknown_size_terminal_little_endian.rs
+++ b/tests/generated/packet_decl_payload_field_unknown_size_terminal_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -74,7 +73,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -162,7 +161,7 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> FooChild {
         match &self.foo.child {
@@ -170,11 +169,11 @@ impl Foo {
             FooDataChild::None => FooChild::None,
         }
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u32 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.foo.child {
@@ -191,13 +190,13 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             child: match self.payload {
                 None => FooDataChild::None,
                 Some(bytes) => FooDataChild::Payload(bytes),
             },
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_payload_field_variable_size_big_endian.rs b/tests/generated/packet_decl_payload_field_variable_size_big_endian.rs
index fd2a3c1..ea6f7bf 100644
--- a/tests/generated/packet_decl_payload_field_variable_size_big_endian.rs
+++ b/tests/generated/packet_decl_payload_field_variable_size_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -75,7 +74,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -185,7 +184,7 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> FooChild {
         match &self.foo.child {
@@ -193,14 +192,14 @@ impl Foo {
             FooDataChild::None => FooChild::None,
         }
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> u16 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.foo.child {
@@ -217,14 +216,14 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             b: self.b,
             child: match self.payload {
                 None => FooDataChild::None,
                 Some(bytes) => FooDataChild::Payload(bytes),
             },
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_payload_field_variable_size_little_endian.rs b/tests/generated/packet_decl_payload_field_variable_size_little_endian.rs
index 65f1809..f2932f0 100644
--- a/tests/generated/packet_decl_payload_field_variable_size_little_endian.rs
+++ b/tests/generated/packet_decl_payload_field_variable_size_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -75,7 +74,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -185,7 +184,7 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
     pub fn specialize(&self) -> FooChild {
         match &self.foo.child {
@@ -193,14 +192,14 @@ impl Foo {
             FooDataChild::None => FooChild::None,
         }
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_a(&self) -> u8 {
-        self.foo.as_ref().a
+        self.foo.a
     }
     pub fn get_b(&self) -> u16 {
-        self.foo.as_ref().b
+        self.foo.b
     }
     pub fn get_payload(&self) -> &[u8] {
         match &self.foo.child {
@@ -217,14 +216,14 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             a: self.a,
             b: self.b,
             child: match self.payload {
                 None => FooDataChild::None,
                 Some(bytes) => FooDataChild::Payload(bytes),
             },
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_reserved_field_big_endian.rs b/tests/generated/packet_decl_reserved_field_big_endian.rs
index f03c7bf..6d2a01e 100644
--- a/tests/generated/packet_decl_reserved_field_big_endian.rs
+++ b/tests/generated/packet_decl_reserved_field_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -51,7 +50,7 @@ pub struct FooData {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -114,9 +113,9 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     fn write_to(&self, buffer: &mut BytesMut) {
@@ -128,7 +127,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {});
+        let foo = FooData {};
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_reserved_field_little_endian.rs b/tests/generated/packet_decl_reserved_field_little_endian.rs
index f03c7bf..6d2a01e 100644
--- a/tests/generated/packet_decl_reserved_field_little_endian.rs
+++ b/tests/generated/packet_decl_reserved_field_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -51,7 +50,7 @@ pub struct FooData {}
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -114,9 +113,9 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     fn write_to(&self, buffer: &mut BytesMut) {
@@ -128,7 +127,7 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {});
+        let foo = FooData {};
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_simple_scalars_big_endian.rs b/tests/generated/packet_decl_simple_scalars_big_endian.rs
index 303a785..f2048d9 100644
--- a/tests/generated/packet_decl_simple_scalars_big_endian.rs
+++ b/tests/generated/packet_decl_simple_scalars_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -55,7 +54,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -143,19 +142,19 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> u8 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     pub fn get_y(&self) -> u16 {
-        self.foo.as_ref().y
+        self.foo.y
     }
     pub fn get_z(&self) -> u32 {
-        self.foo.as_ref().z
+        self.foo.z
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -166,11 +165,11 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             x: self.x,
             y: self.y,
             z: self.z,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/packet_decl_simple_scalars_little_endian.rs b/tests/generated/packet_decl_simple_scalars_little_endian.rs
index 043a72f..16f01f7 100644
--- a/tests/generated/packet_decl_simple_scalars_little_endian.rs
+++ b/tests/generated/packet_decl_simple_scalars_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
@@ -55,7 +54,7 @@ pub struct FooData {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     #[cfg_attr(feature = "serde", serde(flatten))]
-    foo: Arc<FooData>,
+    foo: FooData,
 }
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -143,19 +142,19 @@ impl Foo {
     }
     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self> {
         let data = FooData::parse_inner(&mut bytes)?;
-        Self::new(Arc::new(data))
+        Self::new(data)
     }
-    fn new(foo: Arc<FooData>) -> Result<Self> {
+    fn new(foo: FooData) -> Result<Self> {
         Ok(Self { foo })
     }
     pub fn get_x(&self) -> u8 {
-        self.foo.as_ref().x
+        self.foo.x
     }
     pub fn get_y(&self) -> u16 {
-        self.foo.as_ref().y
+        self.foo.y
     }
     pub fn get_z(&self) -> u32 {
-        self.foo.as_ref().z
+        self.foo.z
     }
     fn write_to(&self, buffer: &mut BytesMut) {
         self.foo.write_to(buffer)
@@ -166,11 +165,11 @@ impl Foo {
 }
 impl FooBuilder {
     pub fn build(self) -> Foo {
-        let foo = Arc::new(FooData {
+        let foo = FooData {
             x: self.x,
             y: self.y,
             z: self.z,
-        });
+        };
         Foo::new(foo).unwrap()
     }
 }
diff --git a/tests/generated/preamble.rs b/tests/generated/preamble.rs
index e200e6d..e3e9772 100644
--- a/tests/generated/preamble.rs
+++ b/tests/generated/preamble.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
diff --git a/tests/generated/struct_decl_complex_scalars_big_endian.rs b/tests/generated/struct_decl_complex_scalars_big_endian.rs
index 8ea2bb9..a8de9c9 100644
--- a/tests/generated/struct_decl_complex_scalars_big_endian.rs
+++ b/tests/generated/struct_decl_complex_scalars_big_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values
diff --git a/tests/generated/struct_decl_complex_scalars_little_endian.rs b/tests/generated/struct_decl_complex_scalars_little_endian.rs
index 0ec2c38..e0741f7 100644
--- a/tests/generated/struct_decl_complex_scalars_little_endian.rs
+++ b/tests/generated/struct_decl_complex_scalars_little_endian.rs
@@ -4,7 +4,6 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
 use std::convert::{TryFrom, TryInto};
 use std::cell::Cell;
 use std::fmt;
-use std::sync::Arc;
 use thiserror::Error;
 type Result<T> = std::result::Result<T, Error>;
 /// Private prevents users from creating arbitrary scalar values