From 8bf4219c53ac59fbb5fed6519bf091dd912863f1 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Mon, 23 Oct 2023 17:26:40 -0700
Subject: [PATCH 01/24] remove num_enum

---
 Cargo.lock                        | 58 -------------------------------
 rust/candid/Cargo.toml            |  1 -
 rust/candid/src/types/internal.rs |  3 +-
 3 files changed, 1 insertion(+), 61 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8b07d2e9..780cbfe3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -271,7 +271,6 @@ dependencies = [
  "leb128",
  "num-bigint",
  "num-traits",
- "num_enum",
  "paste",
  "pretty 0.12.3",
  "rand",
@@ -1104,27 +1103,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "num_enum"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a015b430d3c108a207fd776d2e2196aaf8b1cf8cf93253e3a097ff3085076a1"
-dependencies = [
- "num_enum_derive",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96667db765a921f7b295ffee8b60472b686a51d4f21c2ee4ffdb94c7013b65a6"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2 1.0.69",
- "quote 1.0.33",
- "syn 2.0.38",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.18.0"
@@ -1345,16 +1323,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc5c99d529f0d30937f6f4b8a86d988047327bb88d04d2c4afc356de74722131"
 
-[[package]]
-name = "proc-macro-crate"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
-dependencies = [
- "once_cell",
- "toml_edit",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "0.4.30"
@@ -1890,23 +1858,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
-[[package]]
-name = "toml_datetime"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
-
-[[package]]
-name = "toml_edit"
-version = "0.19.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
-dependencies = [
- "indexmap 2.0.2",
- "toml_datetime",
- "winnow",
-]
-
 [[package]]
 name = "typed-arena"
 version = "2.0.2"
@@ -2241,12 +2192,3 @@ name = "windows_x86_64_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
-[[package]]
-name = "winnow"
-version = "0.5.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3b801d0e0a6726477cc207f60162da452f3a95adb368399bef20a946e06f65c"
-dependencies = [
- "memchr",
-]
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index ffb2a6b8..4dc2483a 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -20,7 +20,6 @@ codespan-reporting = "0.11"
 hex = "0.4.2"
 ic_principal = { path = "../ic_principal", version = "0.1.0" }
 leb128 = "0.2.4"
-num_enum = "0.6.1"
 num-bigint = { version = "0.4.2", features = ["serde"] }
 num-traits = "0.2.12"
 paste = "1.0.0"
diff --git a/rust/candid/src/types/internal.rs b/rust/candid/src/types/internal.rs
index 9c296d36..13eb0f91 100644
--- a/rust/candid/src/types/internal.rs
+++ b/rust/candid/src/types/internal.rs
@@ -1,6 +1,5 @@
 use super::CandidType;
 use crate::idl_hash;
-use num_enum::TryFromPrimitive;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt;
@@ -518,7 +517,7 @@ macro_rules! service {
     }}
 }
 
-#[derive(Debug, PartialEq, TryFromPrimitive)]
+#[derive(Debug, PartialEq)]
 #[repr(i64)]
 pub enum Opcode {
     Null = -1,

From b5bee343ab4c574a7bd4917e6d94024b2be040d0 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Mon, 23 Oct 2023 18:10:10 -0700
Subject: [PATCH 02/24] clean up parser dependencies

---
 Cargo.lock                    |  3 ---
 Cargo.toml                    |  8 ++++++++
 rust/candid/Cargo.toml        | 18 +++++++++---------
 rust/candid_parser/Cargo.toml | 20 ++++++++------------
 4 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 780cbfe3..b1e3032e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -312,10 +312,7 @@ dependencies = [
  "pretty 0.12.3",
  "rand",
  "serde",
- "serde_bytes",
  "serde_dhall",
- "sha2 0.10.8",
- "stacker",
  "test-generator",
  "thiserror",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index eecbc858..6465cf43 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,3 +8,11 @@ members = [
 ]
 resolver = "2"
 
+[workspace.dependencies]
+hex = "0.4.2"
+num-bigint = { version = "0.4.2", features = ["serde"] }
+num-traits = "0.2.12"
+pretty = "0.12.0"
+serde = { version = "1.0.118", features = ["derive"] }
+thiserror = "1.0.20"
+anyhow = "1.0"
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index 4dc2483a..a6824561 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -14,20 +14,20 @@ keywords = ["internet-computer", "idl", "candid", "dfinity"]
 include = ["src", "Cargo.toml", "LICENSE", "README.md"]
 
 [dependencies]
-byteorder = "1.4.3"
 candid_derive = { path = "../candid_derive", version = "=0.6.4" }
-codespan-reporting = "0.11"
-hex = "0.4.2"
 ic_principal = { path = "../ic_principal", version = "0.1.0" }
+byteorder = "1.4.3"
+codespan-reporting = "0.11"
+hex.workspace = true
 leb128 = "0.2.4"
-num-bigint = { version = "0.4.2", features = ["serde"] }
-num-traits = "0.2.12"
+num-bigint.workspace = true
+num-traits.workspace = true
 paste = "1.0.0"
-pretty = "0.12.0"
-serde = { version = "1.0.118", features = ["derive"] }
+pretty.workspace = true
+serde.workspace = true
 serde_bytes = "0.11"
-thiserror = "1.0.20"
-anyhow = "1.0"
+thiserror.workspace = true
+anyhow.workspace = true
 binread = { version = "2.1", features = ["debug_template"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
diff --git a/rust/candid_parser/Cargo.toml b/rust/candid_parser/Cargo.toml
index eac40b32..f58a7485 100644
--- a/rust/candid_parser/Cargo.toml
+++ b/rust/candid_parser/Cargo.toml
@@ -20,15 +20,11 @@ lalrpop = "0.20.0"
 [dependencies]
 candid = { path = "../candid", version = "0.10" }
 codespan-reporting = "0.11"
-hex = "0.4.2"
-num-bigint = { version = "0.4.2", features = ["serde"] }
-num-traits = "0.2.12"
-pretty = "0.12.0"
-serde = { version = "1.0.118", features = ["derive"] }
-serde_bytes = "0.11"
-sha2 = "0.10.1"
-thiserror = "1.0.20"
-anyhow = "1.0"
+hex.workspace = true
+num-bigint.workspace = true
+pretty.workspace = true
+thiserror.workspace = true
+anyhow.workspace = true
 
 lalrpop-util = "0.20.0"
 logos = "0.13"
@@ -39,9 +35,9 @@ arbitrary = { version = "1.0", optional = true }
 serde_dhall = { version = "0.11", default-features = false, optional = true }
 fake = { version = "2.4", optional = true }
 rand = { version = "0.8", optional = true }
+num-traits = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
 
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-stacker = "0.1"
 
 [dev-dependencies]
 goldenfile = "1.1.0"
@@ -50,7 +46,7 @@ rand = "0.8"
 
 [features]
 configs = ["serde_dhall"]
-random = ["configs", "arbitrary", "fake", "rand"]
+random = ["configs", "arbitrary", "fake", "rand", "num-traits", "serde"]
 all = ["random"]
 
 # docs.rs-specific configuration

From de8d5223c293ed6a3710228307bd277c2173f4f4 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Mon, 23 Oct 2023 18:37:35 -0700
Subject: [PATCH 03/24] checkpoint

---
 Cargo.toml                     |  1 +
 rust/candid/Cargo.toml         | 13 +++++++++----
 rust/candid/src/types/impls.rs |  2 ++
 rust/candid/src/types/mod.rs   |  2 ++
 rust/candid_parser/Cargo.toml  |  2 +-
 5 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 6465cf43..807f349d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,3 +16,4 @@ pretty = "0.12.0"
 serde = { version = "1.0.118", features = ["derive"] }
 thiserror = "1.0.20"
 anyhow = "1.0"
+rand = "0.8"
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index a6824561..de536cd6 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -20,21 +20,22 @@ byteorder = "1.4.3"
 codespan-reporting = "0.11"
 hex.workspace = true
 leb128 = "0.2.4"
-num-bigint.workspace = true
-num-traits.workspace = true
 paste = "1.0.0"
 pretty.workspace = true
 serde.workspace = true
-serde_bytes = "0.11"
 thiserror.workspace = true
 anyhow.workspace = true
 binread = { version = "2.1", features = ["debug_template"] }
 
+serde_bytes = { version = "0.11", optional = true }
+num-bigint = { workspace = true }
+num-traits= { workspace = true }
+
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 stacker = "0.1"
 
 [dev-dependencies]
-rand = "0.8"
+rand.workspace = true
 criterion = "0.4"
 serde_cbor = "0.11.2"
 serde_json = "1.0.74"
@@ -47,3 +48,7 @@ path = "benches/benchmark.rs"
 
 [features]
 mute_warnings = []
+#bignum = ["num-bigint", "num-traits"]
+#value = ["bignum"]
+default = ["serde_bytes"]
+
diff --git a/rust/candid/src/types/impls.rs b/rust/candid/src/types/impls.rs
index 3caf1077..bd9156d1 100644
--- a/rust/candid/src/types/impls.rs
+++ b/rust/candid/src/types/impls.rs
@@ -140,6 +140,7 @@ where
         Ok(())
     }
 }
+#[cfg(feature = "serde_bytes")]
 impl CandidType for serde_bytes::ByteBuf {
     fn _ty() -> Type {
         TypeInner::Vec(TypeInner::Nat8.into()).into()
@@ -151,6 +152,7 @@ impl CandidType for serde_bytes::ByteBuf {
         serializer.serialize_blob(self.as_slice())
     }
 }
+#[cfg(feature = "serde_bytes")]
 impl CandidType for serde_bytes::Bytes {
     fn _ty() -> Type {
         TypeInner::Vec(TypeInner::Nat8.into()).into()
diff --git a/rust/candid/src/types/mod.rs b/rust/candid/src/types/mod.rs
index edcc3a09..c962d657 100644
--- a/rust/candid/src/types/mod.rs
+++ b/rust/candid/src/types/mod.rs
@@ -10,6 +10,7 @@ mod impls;
 pub mod internal;
 pub mod subtype;
 pub mod type_env;
+//#[cfg(feature = "value")]
 pub mod value;
 
 pub use self::internal::{
@@ -17,6 +18,7 @@ pub use self::internal::{
 };
 pub use type_env::TypeEnv;
 
+//#[cfg(feature = "bignum")]
 pub mod number;
 pub mod principal;
 pub mod reference;
diff --git a/rust/candid_parser/Cargo.toml b/rust/candid_parser/Cargo.toml
index f58a7485..de51ab64 100644
--- a/rust/candid_parser/Cargo.toml
+++ b/rust/candid_parser/Cargo.toml
@@ -42,7 +42,7 @@ serde = { workspace = true, optional = true }
 [dev-dependencies]
 goldenfile = "1.1.0"
 test-generator = "0.3.0"
-rand = "0.8"
+rand.workspace = true
 
 [features]
 configs = ["serde_dhall"]

From a740ed9fbe4d546c6f7519b75e0afe8e2cc639f3 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Mon, 23 Oct 2023 21:51:12 -0700
Subject: [PATCH 04/24] value feature

---
 Changelog.md                      |  3 ++-
 rust/candid/Cargo.toml            | 14 +++++++++++++-
 rust/candid/src/de.rs             | 10 ++++++++--
 rust/candid/src/lib.rs            |  5 +++--
 rust/candid/src/pretty_printer.rs | 20 ++++++++++++++++++--
 rust/candid/src/ser.rs            |  3 +++
 rust/candid/src/types/internal.rs |  2 +-
 rust/candid/src/types/mod.rs      |  3 +--
 rust/candid/src/types/number.rs   | 16 +---------------
 rust/candid_parser/Cargo.toml     |  2 +-
 10 files changed, 51 insertions(+), 27 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index 1d02bc51..d4e75840 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -5,7 +5,8 @@
 
 * The original `candid` crate is split into three crates:
   * `candid`: mainly for Candid data (de-)serialization.
-    + `candid::bindings::candid` becomes `candid::pretty_printer`.
+    + `candid::bindings::candid` moves to `candid::pretty_printer`.
+    + `candid::types::number::pp_num_str` moves to `candid::pretty_printer::pp_num_str`.
   * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
     + Remove `FromStr` trait for `IDLArgs` and `IDLValue`. Use `parse_idl_args` and `parse_idl_value` respectively instead.
     + `TypeEnv.ast_to_type` becomes `candid_parser::typing::ast_to_type`.
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index de536cd6..9b6d8fe4 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -49,6 +49,18 @@ path = "benches/benchmark.rs"
 [features]
 mute_warnings = []
 #bignum = ["num-bigint", "num-traits"]
-#value = ["bignum"]
+value = []
 default = ["serde_bytes"]
+all = ["default", "value"]
 
+[[test]]
+name = "types"
+path = "tests/types.rs"
+required-features = ["value"]
+
+# docs.rs-specific configuration
+# To test locally: RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --features all
+[package.metadata.docs.rs]
+features = ["all"]
+# defines the configuration attribute `docsrs`
+rustdoc-args = ["--cfg", "docsrs"]
diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index 036440c6..ea512270 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -56,6 +56,7 @@ impl<'de> IDLDeserialize<'de> {
         self.de.is_untyped = false;
         self.deserialize_with_type(T::ty())
     }
+    #[cfg(feature = "value")]
     pub fn get_value_with_type(
         &mut self,
         env: &TypeEnv,
@@ -449,14 +450,19 @@ impl<'de> Deserializer<'de> {
     {
         use de::Deserializer;
         let tid = type_of(&visitor);
-        if tid != TypeId::of::<crate::types::value::IDLValueVisitor>() // derive Copy
-            && tid != TypeId::of::<de::IgnoredAny>() // derive Copy
+        if tid != TypeId::of::<de::IgnoredAny>() // derive Copy
         // OptionVisitor doesn't derive Copy, but has only PhantomData.
         // OptionVisitor is private and we cannot get TypeId of OptionVisitor<T>,
         // we also cannot downcast V to concrete type, because of 'de
         // The only option left seems to be type_name, but it is not guaranteed to be stable, so there is risk here.
             && !tid.name.starts_with("serde::de::impls::OptionVisitor<")
         {
+            #[cfg(feature = "value")]
+            if tid != TypeId::of::<crate::types::value::IDLValueVisitor>() {
+                // derive Copy
+                panic!("Not a valid visitor: {tid:?}");
+            }
+            #[cfg(not(feature = "value"))]
             panic!("Not a valid visitor: {tid:?}");
         }
         // This is safe, because the visitor either impl Copy or is zero sized
diff --git a/rust/candid/src/lib.rs b/rust/candid/src/lib.rs
index c4d5217a..55b557e4 100644
--- a/rust/candid/src/lib.rs
+++ b/rust/candid/src/lib.rs
@@ -229,15 +229,16 @@ pub mod error;
 pub use error::{Error, Result};
 
 pub mod types;
+pub use types::number::{Int, Nat};
+#[cfg(feature = "value")]
+pub use types::value::{IDLArgs, IDLValue};
 pub use types::CandidType;
 pub use types::{
     arc,
-    number::{Int, Nat},
     principal::Principal,
     rc,
     reference::{Func, Service},
     reserved::{Empty, Reserved},
-    value::{IDLArgs, IDLValue},
     TypeEnv,
 };
 
diff --git a/rust/candid/src/pretty_printer.rs b/rust/candid/src/pretty_printer.rs
index fd513436..b440f8a9 100644
--- a/rust/candid/src/pretty_printer.rs
+++ b/rust/candid/src/pretty_printer.rs
@@ -210,15 +210,31 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
     }
 }
 
+pub fn pp_num_str(s: &str) -> String {
+    let mut groups = Vec::new();
+    for chunk in s.as_bytes().rchunks(3) {
+        let str = String::from_utf8_lossy(chunk);
+        groups.push(str);
+    }
+    groups.reverse();
+    if "-" == groups.first().unwrap() {
+        "-".to_string() + &groups[1..].join("_")
+    } else {
+        groups.join("_")
+    }
+}
+
+#[cfg(feature = "value")]
 pub mod value {
-    use super::{ident_string, pp_text};
+    use super::{ident_string, pp_num_str, pp_text};
     use crate::pretty::*;
     use crate::types::value::{IDLArgs, IDLField, IDLValue};
-    use crate::types::{number::pp_num_str, Label};
+    use crate::types::Label;
     use std::fmt;
 
     use ::pretty::RcDoc;
 
+    // TODO config this
     const MAX_ELEMENTS_FOR_PRETTY_PRINT: usize = 10;
 
     impl fmt::Display for IDLArgs {
diff --git a/rust/candid/src/ser.rs b/rust/candid/src/ser.rs
index e36e7032..3c96b780 100644
--- a/rust/candid/src/ser.rs
+++ b/rust/candid/src/ser.rs
@@ -2,6 +2,7 @@
 
 use super::error::{Error, Result};
 use super::types;
+#[cfg(feature = "value")]
 use super::types::value::IDLValue;
 use super::types::{internal::Opcode, Field, Type, TypeEnv, TypeInner};
 use byteorder::{LittleEndian, WriteBytesExt};
@@ -33,12 +34,14 @@ impl IDLBuilder {
         value.idl_serialize(&mut self.value_ser)?;
         Ok(self)
     }
+    #[cfg(feature = "value")]
     pub fn value_arg<'a>(&'a mut self, value: &IDLValue) -> Result<&'a mut Self> {
         use super::CandidType;
         self.type_ser.push_type(&value.value_ty())?;
         value.idl_serialize(&mut self.value_ser)?;
         Ok(self)
     }
+    #[cfg(feature = "value")]
     /// Annotate IDLValue with (TypeEnv, Type). Note that the TypeEnv will be added to the serializer state.
     /// If the Type can already be resolved by previous TypeEnvs, you don't need to pass TypeEnv again.
     pub fn value_arg_with_type<'a>(
diff --git a/rust/candid/src/types/internal.rs b/rust/candid/src/types/internal.rs
index 13eb0f91..2bc6488c 100644
--- a/rust/candid/src/types/internal.rs
+++ b/rust/candid/src/types/internal.rs
@@ -374,7 +374,7 @@ impl std::fmt::Display for Label {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Label::Id(n) | Label::Unnamed(n) => {
-                write!(f, "{}", super::number::pp_num_str(&n.to_string()))
+                write!(f, "{}", crate::pretty_printer::pp_num_str(&n.to_string()))
             }
             Label::Named(id) => write!(f, "{id}"),
         }
diff --git a/rust/candid/src/types/mod.rs b/rust/candid/src/types/mod.rs
index c962d657..094a15c7 100644
--- a/rust/candid/src/types/mod.rs
+++ b/rust/candid/src/types/mod.rs
@@ -10,7 +10,7 @@ mod impls;
 pub mod internal;
 pub mod subtype;
 pub mod type_env;
-//#[cfg(feature = "value")]
+#[cfg(feature = "value")]
 pub mod value;
 
 pub use self::internal::{
@@ -18,7 +18,6 @@ pub use self::internal::{
 };
 pub use type_env::TypeEnv;
 
-//#[cfg(feature = "bignum")]
 pub mod number;
 pub mod principal;
 pub mod reference;
diff --git a/rust/candid/src/types/number.rs b/rust/candid/src/types/number.rs
index 75ca3de3..9cbe9a24 100644
--- a/rust/candid/src/types/number.rs
+++ b/rust/candid/src/types/number.rs
@@ -1,7 +1,7 @@
 //! Data structure for Candid type Int, Nat, supporting big integer with LEB128 encoding.
 
 use super::{CandidType, Serializer, Type, TypeInner};
-use crate::Error;
+use crate::{pretty_printer::pp_num_str, Error};
 use num_bigint::{BigInt, BigUint};
 use serde::{
     de::{self, Deserialize, SeqAccess, Visitor},
@@ -88,20 +88,6 @@ impl std::str::FromStr for Nat {
     }
 }
 
-pub fn pp_num_str(s: &str) -> String {
-    let mut groups = Vec::new();
-    for chunk in s.as_bytes().rchunks(3) {
-        let str = String::from_utf8_lossy(chunk);
-        groups.push(str);
-    }
-    groups.reverse();
-    if "-" == groups.first().unwrap() {
-        "-".to_string() + &groups[1..].join("_")
-    } else {
-        groups.join("_")
-    }
-}
-
 impl fmt::Display for Int {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = self.0.to_str_radix(10);
diff --git a/rust/candid_parser/Cargo.toml b/rust/candid_parser/Cargo.toml
index de51ab64..14cbd798 100644
--- a/rust/candid_parser/Cargo.toml
+++ b/rust/candid_parser/Cargo.toml
@@ -18,7 +18,7 @@ build = "build.rs"
 lalrpop = "0.20.0"
 
 [dependencies]
-candid = { path = "../candid", version = "0.10" }
+candid = { path = "../candid", version = "0.10", features = ["all"] }
 codespan-reporting = "0.11"
 hex.workspace = true
 num-bigint.workspace = true

From e6f5413d123c495e217d82eb9a7bc576312055c2 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 09:15:33 -0700
Subject: [PATCH 05/24] remove codespan

---
 Cargo.lock               |  1 -
 rust/candid/Cargo.toml   |  1 -
 rust/candid/src/error.rs | 41 +++++++++++++++++++++++++++++++---------
 rust/candid/src/lib.rs   |  5 ++++-
 4 files changed, 36 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b1e3032e..1a3f6128 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -264,7 +264,6 @@ dependencies = [
  "binread",
  "byteorder",
  "candid_derive",
- "codespan-reporting",
  "criterion",
  "hex",
  "ic_principal",
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index 9b6d8fe4..59fefe7a 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -17,7 +17,6 @@ include = ["src", "Cargo.toml", "LICENSE", "README.md"]
 candid_derive = { path = "../candid_derive", version = "=0.6.4" }
 ic_principal = { path = "../ic_principal", version = "0.1.0" }
 byteorder = "1.4.3"
-codespan-reporting = "0.11"
 hex.workspace = true
 leb128 = "0.2.4"
 paste = "1.0.0"
diff --git a/rust/candid/src/error.rs b/rust/candid/src/error.rs
index 095b8208..db663896 100644
--- a/rust/candid/src/error.rs
+++ b/rust/candid/src/error.rs
@@ -1,16 +1,21 @@
 //! `candid::Result<T> = Result<T, candid::Error>>`
 
-use codespan_reporting::diagnostic::Label;
 use serde::{de, ser};
 use std::{io, num::ParseIntError};
 use thiserror::Error;
 
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
+#[derive(Debug)]
+pub struct Label {
+    range: std::ops::Range<usize>,
+    message: String,
+}
+
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("binary parser error: {}", .0.get(0).map(|f| format!("{} at byte offset {}", f.message, f.range.start/2)).unwrap_or_else(|| "io error".to_string()))]
-    Binread(Vec<Label<()>>),
+    Binread(Vec<Label>),
 
     #[error("Subtyping error: {0}")]
     Subtype(String),
@@ -28,19 +33,25 @@ impl Error {
     }
 }
 
-fn get_binread_labels(e: &binread::Error) -> Vec<Label<()>> {
+fn get_binread_labels(e: &binread::Error) -> Vec<Label> {
     use binread::Error::*;
     match e {
         BadMagic { pos, .. } => {
             let pos = (pos * 2) as usize;
-            vec![Label::primary((), pos..pos + 2).with_message("Unexpected bytes")]
+            vec![Label {
+                range: pos..pos + 2,
+                message: "Unexpected bytes".to_string(),
+            }]
         }
         Custom { pos, err } => {
             let pos = (pos * 2) as usize;
             let err = err
                 .downcast_ref::<&str>()
                 .unwrap_or(&"unknown error (there's a bug in error reporting)");
-            vec![Label::primary((), pos..pos + 2).with_message(err.to_string())]
+            vec![Label {
+                range: pos..pos + 2,
+                message: err.to_string(),
+            }]
         }
         EnumErrors {
             pos,
@@ -52,21 +63,33 @@ fn get_binread_labels(e: &binread::Error) -> Vec<Label<()>> {
                 .find(|(_, e)| !matches!(e, BadMagic { .. }));
             // Should have at most one non-magic error
             match variant {
-                None => vec![Label::primary((), pos..pos + 2).with_message("Unknown opcode")],
+                None => vec![Label {
+                    range: pos..pos + 2,
+                    message: "Unknown opcode".to_string(),
+                }],
                 Some((id, e)) => {
                     let mut labels = get_binread_labels(e);
-                    labels.push(Label::secondary((), pos..pos + 2).with_message(id.to_string()));
+                    labels.push(Label {
+                        range: pos..pos + 2,
+                        message: id.to_string(),
+                    });
                     labels
                 }
             }
         }
         NoVariantMatch { pos } => {
             let pos = (pos * 2) as usize;
-            vec![Label::primary((), pos..pos + 2).with_message("No variant match")]
+            vec![Label {
+                range: pos..pos + 2,
+                message: "No variant match".to_string(),
+            }]
         }
         AssertFail { pos, message } => {
             let pos = (pos * 2) as usize;
-            vec![Label::primary((), pos..pos + 2).with_message(message)]
+            vec![Label {
+                range: pos..pos + 2,
+                message: message.to_string(),
+            }]
         }
         Io(_) => vec![],
         _ => unreachable!(),
diff --git a/rust/candid/src/lib.rs b/rust/candid/src/lib.rs
index 55b557e4..8d4d363b 100644
--- a/rust/candid/src/lib.rs
+++ b/rust/candid/src/lib.rs
@@ -151,6 +151,8 @@
 //! The use of Rust value and `IDLValue` can be intermixed.
 //!
 //! ```
+//! #[cfg(feature = "value")]
+//! # fn f() -> Result<(), candid::Error> {
 //! use candid::types::value::IDLValue;
 //! // Serialize Rust value Some(42u8) and IDLValue "hello"
 //! let bytes = candid::ser::IDLBuilder::new()
@@ -167,7 +169,8 @@
 //!
 //! assert_eq!(x, IDLValue::Opt(Box::new(IDLValue::Nat8(42))));
 //! assert_eq!(y, "hello");
-//! # Ok::<(), candid::Error>(())
+//! # Ok(())
+//! # }
 //! ```
 //!
 //! ## Building the library as a JS/Wasm package

From 014ff136ef08a2a9b006fc4a733159be31c7df3f Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 09:46:15 -0700
Subject: [PATCH 06/24] fix

---
 Changelog.md           | 1 +
 rust/candid/Cargo.toml | 8 ++++----
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index d4e75840..bcfeb6ac 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -7,6 +7,7 @@
   * `candid`: mainly for Candid data (de-)serialization.
     + `candid::bindings::candid` moves to `candid::pretty_printer`.
     + `candid::types::number::pp_num_str` moves to `candid::pretty_printer::pp_num_str`.
+    + `candid::types::value` module is only availble under feature flag `value`.
   * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
     + Remove `FromStr` trait for `IDLArgs` and `IDLValue`. Use `parse_idl_args` and `parse_idl_value` respectively instead.
     + `TypeEnv.ast_to_type` becomes `candid_parser::typing::ast_to_type`.
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index 59fefe7a..a9f5c03e 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -16,19 +16,19 @@ include = ["src", "Cargo.toml", "LICENSE", "README.md"]
 [dependencies]
 candid_derive = { path = "../candid_derive", version = "=0.6.4" }
 ic_principal = { path = "../ic_principal", version = "0.1.0" }
+binread = { version = "2.1", features = ["debug_template"] }
 byteorder = "1.4.3"
-hex.workspace = true
 leb128 = "0.2.4"
 paste = "1.0.0"
+num-bigint = { workspace = true }
+num-traits= { workspace = true }
+hex.workspace = true
 pretty.workspace = true
 serde.workspace = true
 thiserror.workspace = true
 anyhow.workspace = true
-binread = { version = "2.1", features = ["debug_template"] }
 
 serde_bytes = { version = "0.11", optional = true }
-num-bigint = { workspace = true }
-num-traits= { workspace = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 stacker = "0.1"

From f2dfcc300df4defaa3e304c08e69ad854fa55997 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 11:46:56 -0700
Subject: [PATCH 07/24] fix

---
 Changelog.md                      |  2 +-
 rust/candid/src/pretty_printer.rs | 28 ++++++++++------------------
 rust/candid/src/types/internal.rs | 11 +----------
 rust/candid/src/types/number.rs   |  2 +-
 rust/candid/src/utils.rs          | 14 ++++++++++++++
 5 files changed, 27 insertions(+), 30 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index bcfeb6ac..72b67714 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -6,7 +6,7 @@
 * The original `candid` crate is split into three crates:
   * `candid`: mainly for Candid data (de-)serialization.
     + `candid::bindings::candid` moves to `candid::pretty_printer`.
-    + `candid::types::number::pp_num_str` moves to `candid::pretty_printer::pp_num_str`.
+    + `candid::types::number::pp_num_str` moves to `candid::utils::pp_num_str`.
     + `candid::types::value` module is only availble under feature flag `value`.
   * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
     + Remove `FromStr` trait for `IDLArgs` and `IDLValue`. Use `parse_idl_args` and `parse_idl_value` respectively instead.
diff --git a/rust/candid/src/pretty_printer.rs b/rust/candid/src/pretty_printer.rs
index b440f8a9..c0386911 100644
--- a/rust/candid/src/pretty_printer.rs
+++ b/rust/candid/src/pretty_printer.rs
@@ -1,5 +1,5 @@
 use crate::pretty::*;
-use crate::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
+use crate::types::{Field, FuncMode, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 
 static KEYWORDS: [&str; 30] = [
@@ -160,9 +160,15 @@ pub fn pp_args(args: &[Type]) -> RcDoc {
     let doc = concat(args.iter().map(pp_ty), ",");
     enclose("(", doc, ")")
 }
-
-pub fn pp_modes(modes: &[crate::types::FuncMode]) -> RcDoc {
-    RcDoc::concat(modes.iter().map(|m| RcDoc::space().append(m.to_doc())))
+fn pp_mode(mode: &FuncMode) -> RcDoc {
+    match mode {
+        FuncMode::Oneway => RcDoc::text("oneway"),
+        FuncMode::Query => RcDoc::text("query"),
+        FuncMode::CompositeQuery => RcDoc::text("composite_query"),
+    }
+}
+pub fn pp_modes(modes: &[FuncMode]) -> RcDoc {
+    RcDoc::concat(modes.iter().map(|m| RcDoc::space().append(pp_mode(m))))
 }
 
 fn pp_service(serv: &[(String, Type)]) -> RcDoc {
@@ -210,20 +216,6 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
     }
 }
 
-pub fn pp_num_str(s: &str) -> String {
-    let mut groups = Vec::new();
-    for chunk in s.as_bytes().rchunks(3) {
-        let str = String::from_utf8_lossy(chunk);
-        groups.push(str);
-    }
-    groups.reverse();
-    if "-" == groups.first().unwrap() {
-        "-".to_string() + &groups[1..].join("_")
-    } else {
-        groups.join("_")
-    }
-}
-
 #[cfg(feature = "value")]
 pub mod value {
     use super::{ident_string, pp_num_str, pp_text};
diff --git a/rust/candid/src/types/internal.rs b/rust/candid/src/types/internal.rs
index 2bc6488c..ea4cdea7 100644
--- a/rust/candid/src/types/internal.rs
+++ b/rust/candid/src/types/internal.rs
@@ -374,7 +374,7 @@ impl std::fmt::Display for Label {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Label::Id(n) | Label::Unnamed(n) => {
-                write!(f, "{}", crate::pretty_printer::pp_num_str(&n.to_string()))
+                write!(f, "{}", crate::utils::pp_num_str(&n.to_string()))
             }
             Label::Named(id) => write!(f, "{id}"),
         }
@@ -456,15 +456,6 @@ pub enum FuncMode {
     Query,
     CompositeQuery,
 }
-impl FuncMode {
-    pub fn to_doc(&self) -> pretty::RcDoc {
-        match self {
-            FuncMode::Oneway => pretty::RcDoc::text("oneway"),
-            FuncMode::Query => pretty::RcDoc::text("query"),
-            FuncMode::CompositeQuery => pretty::RcDoc::text("composite_query"),
-        }
-    }
-}
 #[derive(Debug, PartialEq, Hash, Eq, Clone)]
 pub struct Function {
     pub modes: Vec<FuncMode>,
diff --git a/rust/candid/src/types/number.rs b/rust/candid/src/types/number.rs
index 9cbe9a24..9b55e018 100644
--- a/rust/candid/src/types/number.rs
+++ b/rust/candid/src/types/number.rs
@@ -1,7 +1,7 @@
 //! Data structure for Candid type Int, Nat, supporting big integer with LEB128 encoding.
 
 use super::{CandidType, Serializer, Type, TypeInner};
-use crate::{pretty_printer::pp_num_str, Error};
+use crate::{utils::pp_num_str, Error};
 use num_bigint::{BigInt, BigUint};
 use serde::{
     de::{self, Deserialize, SeqAccess, Visitor},
diff --git a/rust/candid/src/utils.rs b/rust/candid/src/utils.rs
index be57f900..4889783f 100644
--- a/rust/candid/src/utils.rs
+++ b/rust/candid/src/utils.rs
@@ -22,6 +22,20 @@ where
     Ok(())
 }
 
+pub fn pp_num_str(s: &str) -> String {
+    let mut groups = Vec::new();
+    for chunk in s.as_bytes().rchunks(3) {
+        let str = String::from_utf8_lossy(chunk);
+        groups.push(str);
+    }
+    groups.reverse();
+    if "-" == groups.first().unwrap() {
+        "-".to_string() + &groups[1..].join("_")
+    } else {
+        groups.join("_")
+    }
+}
+
 /// Encode sequence of Rust values into Candid message of type `candid::Result<Vec<u8>>`.
 #[macro_export]
 macro_rules! Encode {

From 0cb125954031f3ddeb6f2e8b474b3c4c40691fc0 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 14:02:48 -0700
Subject: [PATCH 08/24] pretty

---
 .github/workflows/rust.yml        |  8 ++++++--
 rust/candid/Cargo.toml            |  5 +++--
 rust/candid/src/lib.rs            |  9 +++++++--
 rust/candid/src/pretty_printer.rs |  3 ++-
 rust/candid/src/types/arc.rs      |  3 +--
 rust/candid/src/types/internal.rs | 29 +++++++++++++++++++++++++++++
 rust/candid/src/types/rc.rs       |  3 +--
 rust/candid/src/types/subtype.rs  | 21 ++++++++++++++++++---
 rust/candid/tests/serde.rs        |  2 ++
 9 files changed, 69 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index b50037a8..9f21e218 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -26,9 +26,13 @@ jobs:
           target
         key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
     - name: Build
-      run: cargo build
+      run: |
+        cargo build
     - name: Run tests
-      run: cargo test --features all
+      run: |
+        cargo test --no-default-features
+        cargo test
+        cargo test --features all
     - name: fmt
       run: cargo fmt -v -- --check
     - name: lint
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index a9f5c03e..38442bf7 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -23,12 +23,12 @@ paste = "1.0.0"
 num-bigint = { workspace = true }
 num-traits= { workspace = true }
 hex.workspace = true
-pretty.workspace = true
 serde.workspace = true
 thiserror.workspace = true
 anyhow.workspace = true
 
 serde_bytes = { version = "0.11", optional = true }
+pretty = { workspace = true, optional = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 stacker = "0.1"
@@ -49,7 +49,8 @@ path = "benches/benchmark.rs"
 mute_warnings = []
 #bignum = ["num-bigint", "num-traits"]
 value = []
-default = ["serde_bytes"]
+printer = ["pretty"]
+default = ["serde_bytes", "printer"]
 all = ["default", "value"]
 
 [[test]]
diff --git a/rust/candid/src/lib.rs b/rust/candid/src/lib.rs
index 8d4d363b..b2bbe709 100644
--- a/rust/candid/src/lib.rs
+++ b/rust/candid/src/lib.rs
@@ -79,6 +79,8 @@
 //! This is difficult to achieve in `Serialize`, especially for enum types. Besides serialization, [`CandidType`](types/trait.CandidType.html)
 //! trait also converts Rust type to Candid type defined as [`candid::types::Type`](types/internal/enum.Type.html).
 //! ```
+//! #[cfg(feature = "serde_bytes")]
+//! # fn f() -> Result<(), candid::Error> {
 //! use candid::{Encode, Decode, CandidType, Deserialize};
 //! #[derive(CandidType, Deserialize)]
 //! # #[derive(Debug, PartialEq)]
@@ -94,7 +96,8 @@
 //! let bytes = Encode!(&list)?;
 //! let res = Decode!(&bytes, List)?;
 //! assert_eq!(res, list);
-//! # Ok::<(), candid::Error>(())
+//! # Ok(())
+//! # }
 //! ```
 //! We support serde's rename attributes for each field, namely `#[serde(rename = "foo")]`
 //! and `#[serde(rename(serialize = "foo", deserialize = "foo"))]`.
@@ -252,8 +255,10 @@ pub mod ser;
 
 pub mod utils;
 pub use utils::{decode_args, decode_one, encode_args, encode_one, write_args};
-pub mod pretty;
 
+#[cfg(feature = "printer")]
+pub mod pretty;
+#[cfg(feature = "printer")]
 pub mod pretty_printer;
 
 // Candid hash function comes from
diff --git a/rust/candid/src/pretty_printer.rs b/rust/candid/src/pretty_printer.rs
index c0386911..a686505c 100644
--- a/rust/candid/src/pretty_printer.rs
+++ b/rust/candid/src/pretty_printer.rs
@@ -218,10 +218,11 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
 
 #[cfg(feature = "value")]
 pub mod value {
-    use super::{ident_string, pp_num_str, pp_text};
+    use super::{ident_string, pp_text};
     use crate::pretty::*;
     use crate::types::value::{IDLArgs, IDLField, IDLValue};
     use crate::types::Label;
+    use crate::utils::pp_num_str;
     use std::fmt;
 
     use ::pretty::RcDoc;
diff --git a/rust/candid/src/types/arc.rs b/rust/candid/src/types/arc.rs
index 3d8214d9..b2a682e0 100644
--- a/rust/candid/src/types/arc.rs
+++ b/rust/candid/src/types/arc.rs
@@ -5,11 +5,10 @@
 //!
 //! ```
 //! use candid::{CandidType, Deserialize};
-//! use serde_bytes::ByteBuf;
 //! use std::sync::Arc;
 //!
 //! #[derive(CandidType, Deserialize, PartialEq)]
-//! struct ArcBytes(#[serde(with = "candid::arc")] Arc<ByteBuf>);
+//! struct ArcString(#[serde(with = "candid::arc")] Arc<String>);
 //! ```
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::sync::Arc;
diff --git a/rust/candid/src/types/internal.rs b/rust/candid/src/types/internal.rs
index ea4cdea7..8aa89593 100644
--- a/rust/candid/src/types/internal.rs
+++ b/rust/candid/src/types/internal.rs
@@ -280,16 +280,30 @@ impl Type {
         .into()
     }
 }
+#[cfg(feature = "printer")]
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", crate::pretty_printer::pp_ty(self).pretty(80))
     }
 }
+#[cfg(feature = "printer")]
 impl fmt::Display for TypeInner {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", crate::pretty_printer::pp_ty_inner(self).pretty(80))
     }
 }
+#[cfg(not(feature = "printer"))]
+impl fmt::Display for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+#[cfg(not(feature = "printer"))]
+impl fmt::Display for TypeInner {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
 pub(crate) fn text_size(t: &Type, limit: i32) -> Result<i32, ()> {
     use TypeInner::*;
     if limit <= 1 {
@@ -400,6 +414,7 @@ pub struct Field {
     pub id: SharedLabel,
     pub ty: Type,
 }
+#[cfg(feature = "printer")]
 impl fmt::Display for Field {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
@@ -409,6 +424,13 @@ impl fmt::Display for Field {
         )
     }
 }
+#[cfg(not(feature = "printer"))]
+impl fmt::Display for Field {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 #[macro_export]
 /// Construct a field type, which can be used in `TypeInner::Record` and `TypeInner::Variant`.
 ///
@@ -462,11 +484,18 @@ pub struct Function {
     pub args: Vec<Type>,
     pub rets: Vec<Type>,
 }
+#[cfg(feature = "printer")]
 impl fmt::Display for Function {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", crate::pretty_printer::pp_function(self).pretty(80))
     }
 }
+#[cfg(not(feature = "printer"))]
+impl fmt::Display for Function {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
 impl Function {
     /// Check a function is a query or composite_query method
     pub fn is_query(&self) -> bool {
diff --git a/rust/candid/src/types/rc.rs b/rust/candid/src/types/rc.rs
index 70d48970..e2a7bf4c 100644
--- a/rust/candid/src/types/rc.rs
+++ b/rust/candid/src/types/rc.rs
@@ -5,11 +5,10 @@
 //!
 //! ```
 //! use candid::{CandidType, Deserialize};
-//! use serde_bytes::ByteBuf;
 //! use std::rc::Rc;
 //!
 //! #[derive(CandidType, Deserialize, PartialEq)]
-//! struct RcBytes(#[serde(with = "candid::rc")] Rc<ByteBuf>);
+//! struct RcString(#[serde(with = "candid::rc")] Rc<String>);
 //! ```
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
diff --git a/rust/candid/src/types/subtype.rs b/rust/candid/src/types/subtype.rs
index 85c6e334..92aa9932 100644
--- a/rust/candid/src/types/subtype.rs
+++ b/rust/candid/src/types/subtype.rs
@@ -1,5 +1,4 @@
 use super::internal::{find_type, Field, Label, Type, TypeInner};
-use crate::pretty_printer::pp_args;
 use crate::types::TypeEnv;
 use crate::{Error, Result};
 use anyhow::Context;
@@ -192,8 +191,8 @@ pub fn equal(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<(
             let init_2 = to_tuple(init2);
             equal(gamma, env, &init_1, &init_2).context(format!(
                 "Mismatch in init args: {} and {}",
-                pp_args(init1).pretty(80),
-                pp_args(init2).pretty(80)
+                pp_args(init1),
+                pp_args(init2)
             ))?;
             equal(gamma, env, ty1, ty2)
         }
@@ -242,3 +241,19 @@ fn to_tuple(args: &[Type]) -> Type {
     )
     .into()
 }
+#[cfg(not(feature = "printer"))]
+fn pp_args(args: &[crate::types::Type]) -> String {
+    use std::fmt::Write;
+    let mut s = String::new();
+    write!(&mut s, "(").unwrap();
+    for arg in args.iter() {
+        write!(&mut s, "{:?}, ", arg).unwrap();
+    }
+    write!(&mut s, ")").unwrap();
+    s
+}
+#[cfg(feature = "printer")]
+fn pp_args(args: &[crate::types::Type]) -> String {
+    use crate::pretty_printer::pp_args;
+    pp_args(args).pretty(80).to_string()
+}
diff --git a/rust/candid/tests/serde.rs b/rust/candid/tests/serde.rs
index 5fb612e8..b85dd6f3 100644
--- a/rust/candid/tests/serde.rs
+++ b/rust/candid/tests/serde.rs
@@ -417,6 +417,7 @@ fn test_newtype() {
 }
 
 #[test]
+#[cfg(feature = "serde_bytes")]
 fn test_serde_bytes() {
     use serde_bytes::ByteBuf;
     all_check(
@@ -439,6 +440,7 @@ fn test_serde_bytes() {
 }
 
 #[test]
+#[cfg(feature = "serde_bytes")]
 fn test_rc_bytes() {
     use serde_bytes::ByteBuf;
     use std::rc::Rc;

From a9c3309c6fc616a6561e186e124b18aa2a5b6dd7 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 15:27:57 -0700
Subject: [PATCH 09/24] remove mute_warning

---
 Changelog.md                     |  8 +++-
 rust/candid/Cargo.toml           |  1 -
 rust/candid/src/types/subtype.rs | 68 +++++++++++++++++++++++---------
 3 files changed, 57 insertions(+), 20 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index 72b67714..e6e8874b 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -3,9 +3,11 @@
 
 ## Rust 0.10.0
 
+### Breaking changes
+
 * The original `candid` crate is split into three crates:
   * `candid`: mainly for Candid data (de-)serialization.
-    + `candid::bindings::candid` moves to `candid::pretty_printer`.
+    + `candid::bindings::candid` moves to `candid::pretty_printer`, and is only available under feature flag `printer` (enabled by default).
     + `candid::types::number::pp_num_str` moves to `candid::utils::pp_num_str`.
     + `candid::types::value` module is only availble under feature flag `value`.
   * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
@@ -13,6 +15,10 @@
     + `TypeEnv.ast_to_type` becomes `candid_parser::typing::ast_to_type`.
   * `ic_principal`: only for `Principal` and `PrincipalError`.
 
+### Non-breaking changes
+
+* Add `candid::types::subtype_with_config` to control the error reporting level of special opt rule.
+
 ## Rust 0.9.9 -- 0.9.11
 
 * Set different config values for `full_error_message` and `zero_sized_values` for Wasm and non-Wasm target.
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index 38442bf7..da84ecea 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -46,7 +46,6 @@ harness = false
 path = "benches/benchmark.rs"
 
 [features]
-mute_warnings = []
 #bignum = ["num-bigint", "num-traits"]
 value = []
 printer = ["pretty"]
diff --git a/rust/candid/src/types/subtype.rs b/rust/candid/src/types/subtype.rs
index 92aa9932..9c5462e9 100644
--- a/rust/candid/src/types/subtype.rs
+++ b/rust/candid/src/types/subtype.rs
@@ -6,8 +6,35 @@ use std::collections::{HashMap, HashSet};
 
 pub type Gamma = HashSet<(Type, Type)>;
 
+/// Error reporting style for the special opt rule
+#[derive(Debug, Copy, Clone)]
+pub enum OptReport {
+    Slience,
+    Warning,
+    Error,
+}
 /// Check if t1 <: t2
 pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<()> {
+    subtype_(OptReport::Warning, gamma, env, t1, t2)
+}
+/// Check if t1 <: t2, and report the special opt rule as `Slience`, `Warning` or `Error`.
+pub fn subtype_with_config(
+    report: OptReport,
+    gamma: &mut Gamma,
+    env: &TypeEnv,
+    t1: &Type,
+    t2: &Type,
+) -> Result<()> {
+    subtype_(report, gamma, env, t1, t2)
+}
+
+fn subtype_(
+    report: OptReport,
+    gamma: &mut Gamma,
+    env: &TypeEnv,
+    t1: &Type,
+    t2: &Type,
+) -> Result<()> {
     use TypeInner::*;
     if t1 == t2 {
         return Ok(());
@@ -17,10 +44,10 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
             return Ok(());
         }
         let res = match (t1.as_ref(), t2.as_ref()) {
-            (Var(id), _) => subtype(gamma, env, env.rec_find_type(id).unwrap(), t2),
-            (_, Var(id)) => subtype(gamma, env, t1, env.rec_find_type(id).unwrap()),
-            (Knot(id), _) => subtype(gamma, env, &find_type(id).unwrap(), t2),
-            (_, Knot(id)) => subtype(gamma, env, t1, &find_type(id).unwrap()),
+            (Var(id), _) => subtype_(report, gamma, env, env.rec_find_type(id).unwrap(), t2),
+            (_, Var(id)) => subtype_(report, gamma, env, t1, env.rec_find_type(id).unwrap()),
+            (Knot(id), _) => subtype_(report, gamma, env, &find_type(id).unwrap(), t2),
+            (_, Knot(id)) => subtype_(report, gamma, env, t1, &find_type(id).unwrap()),
             (_, _) => unreachable!(),
         };
         if res.is_err() {
@@ -32,25 +59,28 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
         (_, Reserved) => Ok(()),
         (Empty, _) => Ok(()),
         (Nat, Int) => Ok(()),
-        (Vec(ty1), Vec(ty2)) => subtype(gamma, env, ty1, ty2),
+        (Vec(ty1), Vec(ty2)) => subtype_(report, gamma, env, ty1, ty2),
         (Null, Opt(_)) => Ok(()),
-        (Opt(ty1), Opt(ty2)) if subtype(gamma, env, ty1, ty2).is_ok() => Ok(()),
+        (Opt(ty1), Opt(ty2)) if subtype_(report, gamma, env, ty1, ty2).is_ok() => Ok(()),
         (_, Opt(ty2))
-            if subtype(gamma, env, t1, ty2).is_ok()
+            if subtype_(report, gamma, env, t1, ty2).is_ok()
                 && !matches!(env.trace_type(ty2)?.as_ref(), Null | Reserved | Opt(_)) =>
         {
             Ok(())
         }
         (_, Opt(_)) => {
-            #[cfg(not(feature = "mute_warnings"))]
-            eprintln!("FIX ME! {t1} <: {t2} via special opt rule.\nThis means the sender and receiver type has diverged, and can cause data loss.");
-            Ok(())
+            let msg = format!("FIX ME! {t1} <: {t2} via special opt rule.\nThis means the sender and receiver type has diverged, and can cause data loss.");
+            Ok(match report {
+                OptReport::Slience => (),
+                OptReport::Warning => eprintln!("{msg}"),
+                OptReport::Error => return Err(Error::msg(msg)),
+            })
         }
         (Record(fs1), Record(fs2)) => {
             let fields: HashMap<_, _> = fs1.iter().map(|Field { id, ty }| (id, ty)).collect();
             for Field { id, ty: ty2 } in fs2.iter() {
                 match fields.get(id) {
-                    Some(ty1) => subtype(gamma, env, ty1, ty2).with_context(|| {
+                    Some(ty1) => subtype_(report, gamma, env, ty1, ty2).with_context(|| {
                         format!("Record field {id}: {ty1} is not a subtype of {ty2}")
                     })?,
                     None => {
@@ -66,8 +96,8 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
             let fields: HashMap<_, _> = fs2.iter().map(|Field { id, ty }| (id, ty)).collect();
             for Field { id, ty: ty1 } in fs1.iter() {
                 match fields.get(id) {
-                    Some(ty2) => subtype(gamma, env, ty1, ty2).with_context(|| {
-                        format!("Variant field {id}: {ty1} is not a subtype of {ty2}")
+                    Some(ty2) => subtype_(report, gamma, env, ty1, ty2).with_context(|| {
+                        format!("Variant field {id}: {ty1} is not a subtype_ of {ty2}")
                     })?,
                     None => {
                         return Err(Error::msg(format!(
@@ -82,7 +112,7 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
             let meths: HashMap<_, _> = ms1.iter().map(|(name, ty)| (name, ty)).collect();
             for (name, ty2) in ms2.iter() {
                 match meths.get(name) {
-                    Some(ty1) => subtype(gamma, env, ty1, ty2).with_context(|| {
+                    Some(ty1) => subtype_(report, gamma, env, ty1, ty2).with_context(|| {
                         format!("Method {name}: {ty1} is not a subtype of {ty2}")
                     })?,
                     None => {
@@ -102,13 +132,15 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
             let args2 = to_tuple(&f2.args);
             let rets1 = to_tuple(&f1.rets);
             let rets2 = to_tuple(&f2.rets);
-            subtype(gamma, env, &args2, &args1).context("Subtype fails at function input type")?;
-            subtype(gamma, env, &rets1, &rets2).context("Subtype fails at function return type")?;
+            subtype_(report, gamma, env, &args2, &args1)
+                .context("Subtype fails at function input type")?;
+            subtype_(report, gamma, env, &rets1, &rets2)
+                .context("Subtype fails at function return type")?;
             Ok(())
         }
         // This only works in the first order case, but service constructor only appears at the top level according to the spec.
-        (Class(_, t), _) => subtype(gamma, env, t, t2),
-        (_, Class(_, t)) => subtype(gamma, env, t1, t),
+        (Class(_, t), _) => subtype_(report, gamma, env, t, t2),
+        (_, Class(_, t)) => subtype_(report, gamma, env, t1, t),
         (Unknown, _) => unreachable!(),
         (_, Unknown) => unreachable!(),
         (_, _) => Err(Error::msg(format!("{t1} is not a subtype of {t2}"))),

From 9d7372e5778530584b761fdc7aae182c76d62395 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 15:36:11 -0700
Subject: [PATCH 10/24] fix

---
 rust/candid/src/pretty_printer.rs             | 2 +-
 rust/candid_parser/src/bindings/javascript.rs | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/rust/candid/src/pretty_printer.rs b/rust/candid/src/pretty_printer.rs
index a686505c..827ccddd 100644
--- a/rust/candid/src/pretty_printer.rs
+++ b/rust/candid/src/pretty_printer.rs
@@ -160,7 +160,7 @@ pub fn pp_args(args: &[Type]) -> RcDoc {
     let doc = concat(args.iter().map(pp_ty), ",");
     enclose("(", doc, ")")
 }
-fn pp_mode(mode: &FuncMode) -> RcDoc {
+pub fn pp_mode(mode: &FuncMode) -> RcDoc {
     match mode {
         FuncMode::Oneway => RcDoc::text("oneway"),
         FuncMode::Query => RcDoc::text("query"),
diff --git a/rust/candid_parser/src/bindings/javascript.rs b/rust/candid_parser/src/bindings/javascript.rs
index 6b3ecf74..d414647d 100644
--- a/rust/candid_parser/src/bindings/javascript.rs
+++ b/rust/candid_parser/src/bindings/javascript.rs
@@ -1,5 +1,6 @@
 use super::analysis::{chase_actor, chase_types, infer_rec};
 use candid::pretty::*;
+use candid::pretty_printer::pp_mode;
 use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 use std::collections::BTreeSet;
@@ -174,7 +175,7 @@ fn pp_modes(modes: &[candid::types::FuncMode]) -> RcDoc {
     let doc = concat(
         modes
             .iter()
-            .map(|m| str("'").append(m.to_doc()).append("'")),
+            .map(|m| str("'").append(pp_mode(m)).append("'")),
         ",",
     );
     enclose("[", doc, "]")

From 38a7fb02c938a8e6a4bb5a716628d46d97b54a3f Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 15:58:52 -0700
Subject: [PATCH 11/24] pretty refactor

---
 Changelog.md                                            | 2 +-
 rust/candid/src/lib.rs                                  | 6 ++----
 rust/candid/src/{pretty_printer.rs => pretty/candid.rs} | 4 ++--
 rust/candid/src/pretty/mod.rs                           | 4 ++++
 rust/candid/src/{pretty.rs => pretty/utils.rs}          | 0
 rust/candid/src/types/internal.rs                       | 8 ++++----
 rust/candid/src/types/subtype.rs                        | 2 +-
 7 files changed, 14 insertions(+), 12 deletions(-)
 rename rust/candid/src/{pretty_printer.rs => pretty/candid.rs} (99%)
 create mode 100644 rust/candid/src/pretty/mod.rs
 rename rust/candid/src/{pretty.rs => pretty/utils.rs} (100%)

diff --git a/Changelog.md b/Changelog.md
index e6e8874b..96d2f694 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -7,7 +7,7 @@
 
 * The original `candid` crate is split into three crates:
   * `candid`: mainly for Candid data (de-)serialization.
-    + `candid::bindings::candid` moves to `candid::pretty_printer`, and is only available under feature flag `printer` (enabled by default).
+    + `candid::bindings::candid` moves to `candid::pretty::candid`. `candid::pretty` moves to `candid::pretty::utils`. These modules are only available under feature flag `printer` (enabled by default).
     + `candid::types::number::pp_num_str` moves to `candid::utils::pp_num_str`.
     + `candid::types::value` module is only availble under feature flag `value`.
   * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
diff --git a/rust/candid/src/lib.rs b/rust/candid/src/lib.rs
index b2bbe709..4f80539a 100644
--- a/rust/candid/src/lib.rs
+++ b/rust/candid/src/lib.rs
@@ -236,8 +236,6 @@ pub use error::{Error, Result};
 
 pub mod types;
 pub use types::number::{Int, Nat};
-#[cfg(feature = "value")]
-pub use types::value::{IDLArgs, IDLValue};
 pub use types::CandidType;
 pub use types::{
     arc,
@@ -256,10 +254,10 @@ pub mod ser;
 pub mod utils;
 pub use utils::{decode_args, decode_one, encode_args, encode_one, write_args};
 
+#[cfg(feature = "value")]
+pub use types::value::{IDLArgs, IDLValue};
 #[cfg(feature = "printer")]
 pub mod pretty;
-#[cfg(feature = "printer")]
-pub mod pretty_printer;
 
 // Candid hash function comes from
 // https://caml.inria.fr/pub/papers/garrigue-polymorphic_variants-ml98.pdf
diff --git a/rust/candid/src/pretty_printer.rs b/rust/candid/src/pretty/candid.rs
similarity index 99%
rename from rust/candid/src/pretty_printer.rs
rename to rust/candid/src/pretty/candid.rs
index 827ccddd..4bed0ad9 100644
--- a/rust/candid/src/pretty_printer.rs
+++ b/rust/candid/src/pretty/candid.rs
@@ -1,4 +1,4 @@
-use crate::pretty::*;
+use crate::pretty::utils::*;
 use crate::types::{Field, FuncMode, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 
@@ -219,7 +219,7 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
 #[cfg(feature = "value")]
 pub mod value {
     use super::{ident_string, pp_text};
-    use crate::pretty::*;
+    use crate::pretty::utils::*;
     use crate::types::value::{IDLArgs, IDLField, IDLValue};
     use crate::types::Label;
     use crate::utils::pp_num_str;
diff --git a/rust/candid/src/pretty/mod.rs b/rust/candid/src/pretty/mod.rs
new file mode 100644
index 00000000..7797e8dc
--- /dev/null
+++ b/rust/candid/src/pretty/mod.rs
@@ -0,0 +1,4 @@
+//! pretty printer for Candid type and value
+
+pub mod candid;
+pub mod utils;
diff --git a/rust/candid/src/pretty.rs b/rust/candid/src/pretty/utils.rs
similarity index 100%
rename from rust/candid/src/pretty.rs
rename to rust/candid/src/pretty/utils.rs
diff --git a/rust/candid/src/types/internal.rs b/rust/candid/src/types/internal.rs
index 8aa89593..d0f5a90a 100644
--- a/rust/candid/src/types/internal.rs
+++ b/rust/candid/src/types/internal.rs
@@ -283,13 +283,13 @@ impl Type {
 #[cfg(feature = "printer")]
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", crate::pretty_printer::pp_ty(self).pretty(80))
+        write!(f, "{}", crate::pretty::candid::pp_ty(self).pretty(80))
     }
 }
 #[cfg(feature = "printer")]
 impl fmt::Display for TypeInner {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", crate::pretty_printer::pp_ty_inner(self).pretty(80))
+        write!(f, "{}", crate::pretty::candid::pp_ty_inner(self).pretty(80))
     }
 }
 #[cfg(not(feature = "printer"))]
@@ -420,7 +420,7 @@ impl fmt::Display for Field {
         write!(
             f,
             "{}",
-            crate::pretty_printer::pp_field(self, false).pretty(80)
+            crate::pretty::candid::pp_field(self, false).pretty(80)
         )
     }
 }
@@ -487,7 +487,7 @@ pub struct Function {
 #[cfg(feature = "printer")]
 impl fmt::Display for Function {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", crate::pretty_printer::pp_function(self).pretty(80))
+        write!(f, "{}", crate::pretty::candid::pp_function(self).pretty(80))
     }
 }
 #[cfg(not(feature = "printer"))]
diff --git a/rust/candid/src/types/subtype.rs b/rust/candid/src/types/subtype.rs
index 9c5462e9..2b236eb1 100644
--- a/rust/candid/src/types/subtype.rs
+++ b/rust/candid/src/types/subtype.rs
@@ -286,6 +286,6 @@ fn pp_args(args: &[crate::types::Type]) -> String {
 }
 #[cfg(feature = "printer")]
 fn pp_args(args: &[crate::types::Type]) -> String {
-    use crate::pretty_printer::pp_args;
+    use crate::pretty::candid::pp_args;
     pp_args(args).pretty(80).to_string()
 }

From b1186cc091a7bb5b2232c7bf3c96efb95d06b46d Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 16:04:43 -0700
Subject: [PATCH 12/24] fix

---
 rust/candid_parser/src/bindings/javascript.rs | 10 +++++-----
 rust/candid_parser/src/bindings/motoko.rs     |  4 ++--
 rust/candid_parser/src/bindings/rust.rs       |  4 ++--
 rust/candid_parser/src/bindings/typescript.rs |  2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/rust/candid_parser/src/bindings/javascript.rs b/rust/candid_parser/src/bindings/javascript.rs
index d414647d..ae441da1 100644
--- a/rust/candid_parser/src/bindings/javascript.rs
+++ b/rust/candid_parser/src/bindings/javascript.rs
@@ -1,6 +1,6 @@
 use super::analysis::{chase_actor, chase_types, infer_rec};
-use candid::pretty::*;
-use candid::pretty_printer::pp_mode;
+use candid::pretty::candid::pp_mode;
+use candid::pretty::utils::*;
 use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 use std::collections::BTreeSet;
@@ -268,8 +268,8 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
 }
 
 pub mod value {
-    use candid::pretty::*;
-    use candid::pretty_printer::value::number_to_string;
+    use candid::pretty::candid::value::number_to_string;
+    use candid::pretty::utils::*;
     use candid::types::value::{IDLArgs, IDLField, IDLValue};
     use candid::types::Label;
     use pretty::RcDoc;
@@ -359,7 +359,7 @@ pub mod value {
 pub mod test {
     use super::value;
     use crate::test::{HostAssert, HostTest, Test};
-    use candid::pretty::*;
+    use candid::pretty::utils::*;
     use candid::TypeEnv;
     use pretty::RcDoc;
 
diff --git a/rust/candid_parser/src/bindings/motoko.rs b/rust/candid_parser/src/bindings/motoko.rs
index ef4079b5..5e8a718d 100644
--- a/rust/candid_parser/src/bindings/motoko.rs
+++ b/rust/candid_parser/src/bindings/motoko.rs
@@ -1,8 +1,8 @@
 // This module implements the Candid to Motoko binding as specified in
 // https://github.com/dfinity/motoko/blob/master/design/IDL-Motoko.md
 
-use candid::pretty::*;
-use candid::pretty_printer::is_valid_as_id;
+use candid::pretty::candid::is_valid_as_id;
+use candid::pretty::utils::*;
 use candid::types::FuncMode;
 use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
diff --git a/rust/candid_parser/src/bindings/rust.rs b/rust/candid_parser/src/bindings/rust.rs
index 256d2ef8..5bc14215 100644
--- a/rust/candid_parser/src/bindings/rust.rs
+++ b/rust/candid_parser/src/bindings/rust.rs
@@ -1,5 +1,5 @@
 use super::analysis::{chase_actor, infer_rec};
-use candid::pretty::*;
+use candid::pretty::utils::*;
 use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use convert_case::{Case, Casing};
 use pretty::RcDoc;
@@ -269,7 +269,7 @@ fn pp_args(args: &[Type]) -> RcDoc {
 fn pp_ty_func(f: &Function) -> RcDoc {
     let args = pp_args(&f.args);
     let rets = pp_args(&f.rets);
-    let modes = candid::pretty_printer::pp_modes(&f.modes);
+    let modes = candid::pretty::candid::pp_modes(&f.modes);
     args.append(" ->")
         .append(RcDoc::space())
         .append(rets.append(modes))
diff --git a/rust/candid_parser/src/bindings/typescript.rs b/rust/candid_parser/src/bindings/typescript.rs
index ddb4451b..594944cc 100644
--- a/rust/candid_parser/src/bindings/typescript.rs
+++ b/rust/candid_parser/src/bindings/typescript.rs
@@ -1,5 +1,5 @@
 use super::javascript::{ident, is_tuple};
-use candid::pretty::*;
+use candid::pretty::utils::*;
 use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 

From 17bcc6c7d8a46b496846c8197bd1c912666b20de Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 16:50:55 -0700
Subject: [PATCH 13/24] reexport candid in parser

---
 rust/candid/src/de.rs            | 1 +
 rust/candid/src/lib.rs           | 2 ++
 rust/candid/src/pretty/candid.rs | 1 +
 rust/candid/src/ser.rs           | 2 ++
 rust/candid/src/types/impls.rs   | 2 ++
 rust/candid/src/types/mod.rs     | 1 +
 rust/candid_parser/src/lib.rs    | 4 ++++
 7 files changed, 13 insertions(+)

diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index ea512270..7633c2d1 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -56,6 +56,7 @@ impl<'de> IDLDeserialize<'de> {
         self.de.is_untyped = false;
         self.deserialize_with_type(T::ty())
     }
+    #[cfg_attr(docsrs, doc(cfg(feature = "value")))]
     #[cfg(feature = "value")]
     pub fn get_value_with_type(
         &mut self,
diff --git a/rust/candid/src/lib.rs b/rust/candid/src/lib.rs
index 4f80539a..4f619f2b 100644
--- a/rust/candid/src/lib.rs
+++ b/rust/candid/src/lib.rs
@@ -254,8 +254,10 @@ pub mod ser;
 pub mod utils;
 pub use utils::{decode_args, decode_one, encode_args, encode_one, write_args};
 
+#[cfg_attr(docsrs, doc(cfg(feature = "value")))]
 #[cfg(feature = "value")]
 pub use types::value::{IDLArgs, IDLValue};
+#[cfg_attr(docsrs, doc(cfg(feature = "printer")))]
 #[cfg(feature = "printer")]
 pub mod pretty;
 
diff --git a/rust/candid/src/pretty/candid.rs b/rust/candid/src/pretty/candid.rs
index 4bed0ad9..09897385 100644
--- a/rust/candid/src/pretty/candid.rs
+++ b/rust/candid/src/pretty/candid.rs
@@ -216,6 +216,7 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
     }
 }
 
+#[cfg_attr(docsrs, doc(cfg(feature = "value")))]
 #[cfg(feature = "value")]
 pub mod value {
     use super::{ident_string, pp_text};
diff --git a/rust/candid/src/ser.rs b/rust/candid/src/ser.rs
index 3c96b780..01fb0502 100644
--- a/rust/candid/src/ser.rs
+++ b/rust/candid/src/ser.rs
@@ -34,6 +34,7 @@ impl IDLBuilder {
         value.idl_serialize(&mut self.value_ser)?;
         Ok(self)
     }
+    #[cfg_attr(docsrs, doc(cfg(feature = "value")))]
     #[cfg(feature = "value")]
     pub fn value_arg<'a>(&'a mut self, value: &IDLValue) -> Result<&'a mut Self> {
         use super::CandidType;
@@ -41,6 +42,7 @@ impl IDLBuilder {
         value.idl_serialize(&mut self.value_ser)?;
         Ok(self)
     }
+    #[cfg_attr(docsrs, doc(cfg(feature = "value")))]
     #[cfg(feature = "value")]
     /// Annotate IDLValue with (TypeEnv, Type). Note that the TypeEnv will be added to the serializer state.
     /// If the Type can already be resolved by previous TypeEnvs, you don't need to pass TypeEnv again.
diff --git a/rust/candid/src/types/impls.rs b/rust/candid/src/types/impls.rs
index bd9156d1..807c1054 100644
--- a/rust/candid/src/types/impls.rs
+++ b/rust/candid/src/types/impls.rs
@@ -140,6 +140,7 @@ where
         Ok(())
     }
 }
+#[cfg_attr(docsrs, doc(cfg(feature = "serde_bytes")))]
 #[cfg(feature = "serde_bytes")]
 impl CandidType for serde_bytes::ByteBuf {
     fn _ty() -> Type {
@@ -152,6 +153,7 @@ impl CandidType for serde_bytes::ByteBuf {
         serializer.serialize_blob(self.as_slice())
     }
 }
+#[cfg_attr(docsrs, doc(cfg(feature = "serde_bytes")))]
 #[cfg(feature = "serde_bytes")]
 impl CandidType for serde_bytes::Bytes {
     fn _ty() -> Type {
diff --git a/rust/candid/src/types/mod.rs b/rust/candid/src/types/mod.rs
index 094a15c7..e289af87 100644
--- a/rust/candid/src/types/mod.rs
+++ b/rust/candid/src/types/mod.rs
@@ -10,6 +10,7 @@ mod impls;
 pub mod internal;
 pub mod subtype;
 pub mod type_env;
+#[cfg_attr(docsrs, doc(cfg(feature = "value")))]
 #[cfg(feature = "value")]
 pub mod value;
 
diff --git a/rust/candid_parser/src/lib.rs b/rust/candid_parser/src/lib.rs
index 1cbc0e46..cf1e249a 100644
--- a/rust/candid_parser/src/lib.rs
+++ b/rust/candid_parser/src/lib.rs
@@ -1,5 +1,7 @@
 //! # Candid Parser
 //!
+//! Everything from `candid` crate is re-exported here. Users don't have to add `candid` as their dependency in `Cargo.toml`.
+//!
 //! Provides parser for Candid type and value.
 //!  * `str.parse::<IDLProg>()` parses the Candid signature file to Candid AST.
 //!  * `parse_idl_args()` parses the Candid value in text format to a struct `IDLArg` that can be used for serialization and deserialization between Candid and an enum type `IDLValue` in Rust.
@@ -128,6 +130,8 @@ pub use types::IDLProg;
 pub mod typing;
 pub use typing::{check_file, check_prog, pretty_check_file};
 
+pub use candid::*;
+
 #[cfg_attr(docsrs, doc(cfg(feature = "configs")))]
 #[cfg(feature = "configs")]
 pub mod configs;

From f84c02d6571947be7073ac7ba7611268cde13a16 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 17:11:41 -0700
Subject: [PATCH 14/24] fix

---
 Cargo.lock                             |  1 -
 rust/candid_parser/src/lib.rs          |  1 +
 rust/candid_parser/tests/parse_type.rs |  2 +-
 tools/didc/Cargo.toml                  |  1 -
 tools/didc/src/main.rs                 | 17 ++++++++---------
 5 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1a3f6128..8f69e848 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -612,7 +612,6 @@ name = "didc"
 version = "0.3.5"
 dependencies = [
  "anyhow",
- "candid",
  "candid_parser",
  "clap 4.4.6",
  "hex",
diff --git a/rust/candid_parser/src/lib.rs b/rust/candid_parser/src/lib.rs
index cf1e249a..3953e582 100644
--- a/rust/candid_parser/src/lib.rs
+++ b/rust/candid_parser/src/lib.rs
@@ -130,6 +130,7 @@ pub use types::IDLProg;
 pub mod typing;
 pub use typing::{check_file, check_prog, pretty_check_file};
 
+pub use candid;
 pub use candid::*;
 
 #[cfg_attr(docsrs, doc(cfg(feature = "configs")))]
diff --git a/rust/candid_parser/tests/parse_type.rs b/rust/candid_parser/tests/parse_type.rs
index 8608ced7..779c3496 100644
--- a/rust/candid_parser/tests/parse_type.rs
+++ b/rust/candid_parser/tests/parse_type.rs
@@ -1,4 +1,4 @@
-use candid::pretty_printer::compile;
+use candid::pretty::candid::compile;
 use candid::types::TypeEnv;
 use candid_parser::bindings::{javascript, motoko, rust, typescript};
 use candid_parser::types::IDLProg;
diff --git a/tools/didc/Cargo.toml b/tools/didc/Cargo.toml
index ff4399fd..bf9af2a3 100644
--- a/tools/didc/Cargo.toml
+++ b/tools/didc/Cargo.toml
@@ -5,7 +5,6 @@ authors = ["DFINITY Team"]
 edition = "2021"
 
 [dependencies]
-candid = { path = "../../rust/candid" }
 candid_parser = { path = "../../rust/candid_parser", features = ["all"] }
 clap = { version = "4.3", features = ["derive"] }
 pretty-hex = "0.2.1"
diff --git a/tools/didc/src/main.rs b/tools/didc/src/main.rs
index a13d341d..09673193 100644
--- a/tools/didc/src/main.rs
+++ b/tools/didc/src/main.rs
@@ -1,11 +1,11 @@
 use anyhow::{bail, Result};
-use candid::{types::Type, IDLArgs, TypeEnv};
+use candid_parser::candid::types::{subtype, Type};
 use candid_parser::{
     error::pretty_diagnose,
     parse_idl_args, parse_idl_value, pretty_check_file, pretty_parse,
     types::{IDLType, IDLTypes},
     typing::ast_to_type,
-    Error,
+    Error, IDLArgs, IDLValue, TypeEnv,
 };
 use clap::Parser;
 use std::collections::HashSet;
@@ -172,9 +172,9 @@ fn main() -> Result<()> {
                         let mut gamma = HashSet::new();
                         let t2 = env.merge_type(env2, t2);
                         if strict {
-                            candid::types::subtype::equal(&mut gamma, &env, &t1, &t2)?;
+                            subtype::equal(&mut gamma, &env, &t1, &t2)?;
                         } else {
-                            candid::types::subtype::subtype(&mut gamma, &env, &t1, &t2)?;
+                            subtype::subtype(&mut gamma, &env, &t1, &t2)?;
                         }
                     }
                     _ => {
@@ -191,14 +191,14 @@ fn main() -> Result<()> {
             };
             let ty1 = ast_to_type(&env, &ty1)?;
             let ty2 = ast_to_type(&env, &ty2)?;
-            candid::types::subtype::subtype(&mut HashSet::new(), &env, &ty1, &ty2)?;
+            subtype::subtype(&mut HashSet::new(), &env, &ty1, &ty2)?;
         }
         Command::Bind { input, target } => {
             let (env, actor) = pretty_check_file(&input)?;
             let content = match target.as_str() {
                 "js" => candid_parser::bindings::javascript::compile(&env, &actor),
                 "ts" => candid_parser::bindings::typescript::compile(&env, &actor),
-                "did" => candid::pretty_printer::compile(&env, &actor),
+                "did" => candid_parser::pretty::candid::compile(&env, &actor),
                 "mo" => candid_parser::bindings::motoko::compile(&env, &actor),
                 "rs" => {
                     let config = candid_parser::bindings::rust::Config::new();
@@ -228,7 +228,7 @@ fn main() -> Result<()> {
             println!("{content}");
         }
         Command::Hash { input } => {
-            println!("{}", candid::idl_hash(&input));
+            println!("{}", candid_parser::idl_hash(&input));
         }
         Command::Encode {
             args,
@@ -254,7 +254,7 @@ fn main() -> Result<()> {
                 "blob" => {
                     let mut res = String::new();
                     for ch in bytes.iter() {
-                        res.push_str(&candid::pretty_printer::value::pp_char(*ch));
+                        res.push_str(&candid_parser::pretty::candid::value::pp_char(*ch));
                     }
                     format!("blob \"{res}\"")
                 }
@@ -278,7 +278,6 @@ fn main() -> Result<()> {
                         .collect::<String>(),
                 )?,
                 "blob" => {
-                    use candid::types::value::IDLValue;
                     match parse_idl_value(&blob).map_err(|e| {
                         let _ = pretty_diagnose("blob", &blob, &e);
                         e

From 948faf9402c21f2552507ad5a8cd1002c0acc1d2 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 17:32:02 -0700
Subject: [PATCH 15/24] fix

---
 rust/candid_derive/src/func.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/candid_derive/src/func.rs b/rust/candid_derive/src/func.rs
index dfbde3dd..5ff9d323 100644
--- a/rust/candid_derive/src/func.rs
+++ b/rust/candid_derive/src/func.rs
@@ -135,7 +135,7 @@ pub(crate) fn export_service(path: Option<TokenStream>) -> TokenStream {
             fn __export_service() -> String {
                 #service
                 #actor
-                let result = #candid::pretty_printer::compile(&env.env, &actor);
+                let result = #candid::pretty::candid::compile(&env.env, &actor);
                 format!("{}", result)
             }
         };

From f04c23570dc16893b3d9dfe4c772e6cddc9078d1 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Tue, 24 Oct 2023 17:39:43 -0700
Subject: [PATCH 16/24] fix

---
 Changelog.md                     | 3 +++
 rust/candid/src/types/subtype.rs | 5 +++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index 96d2f694..135529f3 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -10,9 +10,12 @@
     + `candid::bindings::candid` moves to `candid::pretty::candid`. `candid::pretty` moves to `candid::pretty::utils`. These modules are only available under feature flag `printer` (enabled by default).
     + `candid::types::number::pp_num_str` moves to `candid::utils::pp_num_str`.
     + `candid::types::value` module is only availble under feature flag `value`.
+    + `mute_warning` feature flag is removed.
   * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
     + Remove `FromStr` trait for `IDLArgs` and `IDLValue`. Use `parse_idl_args` and `parse_idl_value` respectively instead.
     + `TypeEnv.ast_to_type` becomes `candid_parser::typing::ast_to_type`.
+    + `candid` is re-exported in `candid_parser::candid`.
+    + `candid::*` is re-exported in `candid_parser`.
   * `ic_principal`: only for `Principal` and `PrincipalError`.
 
 ### Non-breaking changes
diff --git a/rust/candid/src/types/subtype.rs b/rust/candid/src/types/subtype.rs
index 2b236eb1..141b9d0e 100644
--- a/rust/candid/src/types/subtype.rs
+++ b/rust/candid/src/types/subtype.rs
@@ -70,11 +70,12 @@ fn subtype_(
         }
         (_, Opt(_)) => {
             let msg = format!("FIX ME! {t1} <: {t2} via special opt rule.\nThis means the sender and receiver type has diverged, and can cause data loss.");
-            Ok(match report {
+            match report {
                 OptReport::Slience => (),
                 OptReport::Warning => eprintln!("{msg}"),
                 OptReport::Error => return Err(Error::msg(msg)),
-            })
+            };
+            Ok(())
         }
         (Record(fs1), Record(fs2)) => {
             let fields: HashMap<_, _> = fs1.iter().map(|Field { id, ty }| (id, ty)).collect();

From 683f46cc355018e88b9af4a54ae594ea860ab590 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Wed, 25 Oct 2023 18:18:00 -0700
Subject: [PATCH 17/24] bignum feature

---
 rust/candid/Cargo.toml          | 18 ++++--
 rust/candid/src/de.rs           | 38 ++++++-------
 rust/candid/src/lib.rs          | 11 +++-
 rust/candid/src/ser.rs          |  8 +++
 rust/candid/src/types/impls.rs  |  4 +-
 rust/candid/src/types/leb128.rs | 97 +++++++++++++++++++++++++++++++++
 rust/candid/src/types/mod.rs    |  8 +++
 rust/candid/tests/number.rs     | 13 +++++
 8 files changed, 168 insertions(+), 29 deletions(-)
 create mode 100644 rust/candid/src/types/leb128.rs

diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index da84ecea..94ad9cc1 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -20,8 +20,6 @@ binread = { version = "2.1", features = ["debug_template"] }
 byteorder = "1.4.3"
 leb128 = "0.2.4"
 paste = "1.0.0"
-num-bigint = { workspace = true }
-num-traits= { workspace = true }
 hex.workspace = true
 serde.workspace = true
 thiserror.workspace = true
@@ -29,6 +27,8 @@ anyhow.workspace = true
 
 serde_bytes = { version = "0.11", optional = true }
 pretty = { workspace = true, optional = true }
+num-bigint = { workspace = true, optional = true }
+num-traits = { workspace = true, optional = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 stacker = "0.1"
@@ -46,16 +46,24 @@ harness = false
 path = "benches/benchmark.rs"
 
 [features]
-#bignum = ["num-bigint", "num-traits"]
-value = []
+bignum = ["num-bigint", "num-traits"]
+value = ["bignum"]
 printer = ["pretty"]
-default = ["serde_bytes", "printer"]
+default = ["serde_bytes", "printer", "bignum"]
 all = ["default", "value"]
 
 [[test]]
 name = "types"
 path = "tests/types.rs"
 required-features = ["value"]
+[[test]]
+name = "serde"
+path = "tests/serde.rs"
+required-features = ["bignum"]
+[[test]]
+name = "number"
+path = "tests/number.rs"
+required-features = ["bignum"]
 
 # docs.rs-specific configuration
 # To test locally: RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --features all
diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index 7633c2d1..67e4d941 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -4,8 +4,10 @@ use super::{
     error::{Error, Result},
     types::internal::{text_size, type_of, TypeId},
     types::{Field, Label, SharedLabel, Type, TypeEnv, TypeInner},
-    CandidType, Int, Nat,
+    CandidType,
 };
+#[cfg(feature = "bignum")]
+use super::{Int, Nat};
 use crate::{
     binary_parser::{BoolValue, Header, Len, PrincipalBytes},
     types::subtype::{subtype, Gamma},
@@ -337,6 +339,8 @@ impl<'de> Deserializer<'de> {
     // int(0), nat(1), principal(2), reserved(3), service(4), function(5)
     // This is necessary for deserializing IDLValue because
     // it has only one visitor and we need a way to know who called the visitor.
+    #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
+    #[cfg(feature = "bignum")]
     fn deserialize_int<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
@@ -356,6 +360,8 @@ impl<'de> Deserializer<'de> {
         bytes.extend_from_slice(&int.0.to_signed_bytes_le());
         visitor.visit_byte_buf(bytes)
     }
+    #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
+    #[cfg(feature = "bignum")]
     fn deserialize_nat<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
@@ -508,8 +514,14 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         }
         self.unroll_type()?;
         match self.expect_type.as_ref() {
+            #[cfg(feature = "bignum")]
             TypeInner::Int => self.deserialize_int(visitor),
+            #[cfg(not(feature = "bignum"))]
+            TypeInner::Int => self.deserialize_i128(visitor),
+            #[cfg(feature = "bignum")]
             TypeInner::Nat => self.deserialize_nat(visitor),
+            #[cfg(not(feature = "bignum"))]
+            TypeInner::Nat => self.deserialize_u128(visitor),
             TypeInner::Nat8 => self.deserialize_u8(visitor),
             TypeInner::Nat16 => self.deserialize_u16(visitor),
             TypeInner::Nat32 => self.deserialize_u32(visitor),
@@ -571,22 +583,13 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        use num_traits::ToPrimitive;
+        use crate::types::leb128::{decode_int, decode_nat};
         self.unroll_type()?;
         assert!(*self.expect_type == TypeInner::Int);
         let value: i128 = match self.wire_type.as_ref() {
-            TypeInner::Int => {
-                let int = Int::decode(&mut self.input).map_err(Error::msg)?;
-                int.0
-                    .to_i128()
-                    .ok_or_else(|| Error::msg("Cannot convert int to i128"))?
-            }
-            TypeInner::Nat => {
-                let nat = Nat::decode(&mut self.input).map_err(Error::msg)?;
-                nat.0
-                    .to_i128()
-                    .ok_or_else(|| Error::msg("Cannot convert nat to i128"))?
-            }
+            TypeInner::Int => decode_int(&mut self.input)?,
+            TypeInner::Nat => i128::try_from(decode_nat(&mut self.input)?)
+                .map_err(|_| Error::msg("Cannot convert nat to i128"))?,
             t => return Err(Error::subtype(format!("{t} cannot be deserialized to int"))),
         };
         visitor.visit_i128(value)
@@ -595,17 +598,12 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        use num_traits::ToPrimitive;
         self.unroll_type()?;
         check!(
             *self.expect_type == TypeInner::Nat && *self.wire_type == TypeInner::Nat,
             "nat"
         );
-        let nat = Nat::decode(&mut self.input).map_err(Error::msg)?;
-        let value = nat
-            .0
-            .to_u128()
-            .ok_or_else(|| Error::msg("Cannot convert nat to u128"))?;
+        let value = crate::types::leb128::decode_nat(&mut self.input)?;
         visitor.visit_u128(value)
     }
     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
diff --git a/rust/candid/src/lib.rs b/rust/candid/src/lib.rs
index 4f619f2b..aa40f50f 100644
--- a/rust/candid/src/lib.rs
+++ b/rust/candid/src/lib.rs
@@ -116,6 +116,8 @@
 //! You can also use `i128` and `u128` to represent Candid `int` and `nat` types respectively (decoding will fail if
 //! the number is more than 128 bits).
 //! ```
+//! #[cfg(feature = "bignum")]
+//! # fn f() -> Result<(), candid::Error> {
 //! use candid::{Int, Nat, Encode, Decode};
 //! let x = "-10000000000000000000".parse::<Int>()?;
 //! let bytes = Encode!(&Nat::from(1024), &x)?;
@@ -123,7 +125,8 @@
 //! let (c, d) = Decode!(&bytes, u128, i128)?;
 //! assert_eq!(a + 1, 1025);
 //! assert_eq!(b, Int::parse(b"-10000000000000000000")?);
-//! # Ok::<(), candid::Error>(())
+//! # Ok(())
+//! # }
 //! ```
 //!
 //! ## Operating on reference types
@@ -132,6 +135,8 @@
 //! instead of the Candid types.
 //!
 //! ```
+//! #[cfg(feature = "bignum")]
+//! # fn f() -> Result<(), candid::Error> {
 //! use candid::{define_function, define_service, func, Encode, Decode, Principal};
 //! let principal = Principal::from_text("aaaaa-aa").unwrap();
 //!
@@ -145,7 +150,8 @@
 //! });
 //! let serv = MyService::new(principal);
 //! assert_eq!(serv, Decode!(&Encode!(&serv)?, MyService)?);
-//! # Ok::<(), candid::Error>(())
+//! # Ok(())
+//! # }
 //! ```
 //!
 //! ## Operating on untyped Candid values
@@ -235,6 +241,7 @@ pub mod error;
 pub use error::{Error, Result};
 
 pub mod types;
+#[cfg(feature = "bignum")]
 pub use types::number::{Int, Nat};
 pub use types::CandidType;
 pub use types::{
diff --git a/rust/candid/src/ser.rs b/rust/candid/src/ser.rs
index 01fb0502..994efe91 100644
--- a/rust/candid/src/ser.rs
+++ b/rust/candid/src/ser.rs
@@ -119,12 +119,20 @@ impl<'a> types::Serializer for &'a mut ValueSerializer {
         self.write(&[v as u8])?;
         Ok(())
     }
+    #[cfg(feature = "bignum")]
     fn serialize_int(self, v: &crate::Int) -> Result<()> {
         v.encode(&mut self.value)
     }
+    #[cfg(feature = "bignum")]
     fn serialize_nat(self, v: &crate::Nat) -> Result<()> {
         v.encode(&mut self.value)
     }
+    fn serialize_i128(self, v: i128) -> Result<()> {
+        crate::types::leb128::encode_int(&mut self.value, v)
+    }
+    fn serialize_u128(self, v: u128) -> Result<()> {
+        crate::types::leb128::encode_nat(&mut self.value, v)
+    }
     serialize_num!(nat8, u8, write_u8);
     serialize_num!(nat16, u16, write_u16::<LittleEndian>);
     serialize_num!(nat32, u32, write_u32::<LittleEndian>);
diff --git a/rust/candid/src/types/impls.rs b/rust/candid/src/types/impls.rs
index 807c1054..6d2cb5b6 100644
--- a/rust/candid/src/types/impls.rs
+++ b/rust/candid/src/types/impls.rs
@@ -41,7 +41,7 @@ impl CandidType for i128 {
     where
         S: Serializer,
     {
-        serializer.serialize_int(&crate::Int::from(*self))
+        serializer.serialize_i128(*self)
     }
 }
 impl CandidType for u128 {
@@ -52,7 +52,7 @@ impl CandidType for u128 {
     where
         S: Serializer,
     {
-        serializer.serialize_nat(&crate::Nat::from(*self))
+        serializer.serialize_u128(*self)
     }
 }
 
diff --git a/rust/candid/src/types/leb128.rs b/rust/candid/src/types/leb128.rs
new file mode 100644
index 00000000..5a6b76c5
--- /dev/null
+++ b/rust/candid/src/types/leb128.rs
@@ -0,0 +1,97 @@
+use crate::error::{Error, Result};
+use std::io;
+
+const CONTINUATION_BIT: u8 = 1 << 7;
+const SIGN_BIT: u8 = 1 << 6;
+
+pub fn encode_nat<W>(w: &mut W, mut val: u128) -> Result<()>
+where
+    W: io::Write + ?Sized,
+{
+    loop {
+        let mut byte = (val & 0x7fu128) as u8;
+        val >>= 7;
+        if val != 0 {
+            byte |= CONTINUATION_BIT;
+        }
+        let buf = [byte];
+        w.write_all(&buf)?;
+        if val == 0 {
+            return Ok(());
+        }
+    }
+}
+pub fn encode_int<W>(w: &mut W, mut val: i128) -> Result<()>
+where
+    W: io::Write + ?Sized,
+{
+    loop {
+        let mut byte = val as u8;
+        val >>= 6;
+        let done = val == 0 || val == -1;
+        if done {
+            byte &= !CONTINUATION_BIT;
+        } else {
+            val >>= 1;
+            byte |= CONTINUATION_BIT;
+        }
+        let buf = [byte];
+        w.write_all(&buf)?;
+        if done {
+            return Ok(());
+        }
+    }
+}
+pub fn decode_nat<R>(r: &mut R) -> Result<u128>
+where
+    R: io::Read + ?Sized,
+{
+    let mut result = 0;
+    let mut shift = 0;
+    loop {
+        let mut buf = [0];
+        r.read_exact(&mut buf)?;
+        if shift == 127 && buf[0] != 0x00 && buf[0] != 0x01 {
+            while buf[0] & CONTINUATION_BIT != 0 {
+                r.read_exact(&mut buf)?;
+            }
+            return Err(Error::msg("nat overflow"));
+        }
+        let low_bits = (buf[0] & !CONTINUATION_BIT) as u128;
+        result |= low_bits << shift;
+        if buf[0] & CONTINUATION_BIT == 0 {
+            return Ok(result);
+        }
+        shift += 7;
+    }
+}
+pub fn decode_int<R>(r: &mut R) -> Result<i128>
+where
+    R: io::Read + ?Sized,
+{
+    let mut result = 0;
+    let mut shift = 0;
+    let size = 128;
+    let mut byte;
+    loop {
+        let mut buf = [0];
+        r.read_exact(&mut buf)?;
+        byte = buf[0];
+        if shift == 127 && byte != 0x00 && byte != 0x7f {
+            while buf[0] & CONTINUATION_BIT != 0 {
+                r.read_exact(&mut buf)?;
+            }
+            return Err(Error::msg("int overflow"));
+        }
+        let low_bits = (byte & !CONTINUATION_BIT) as i128;
+        result |= low_bits << shift;
+        shift += 7;
+        if byte & CONTINUATION_BIT == 0 {
+            break;
+        }
+    }
+    if shift < size && (byte & SIGN_BIT) == SIGN_BIT {
+        result |= !0 << shift;
+    }
+    Ok(result)
+}
diff --git a/rust/candid/src/types/mod.rs b/rust/candid/src/types/mod.rs
index e289af87..f844ab72 100644
--- a/rust/candid/src/types/mod.rs
+++ b/rust/candid/src/types/mod.rs
@@ -19,6 +19,8 @@ pub use self::internal::{
 };
 pub use type_env::TypeEnv;
 
+pub mod leb128;
+#[cfg(feature = "bignum")]
 pub mod number;
 pub mod principal;
 pub mod reference;
@@ -58,8 +60,14 @@ pub trait Serializer: Sized {
     type Error: Error;
     type Compound: Compound<Error = Self::Error>;
     fn serialize_bool(self, v: bool) -> Result<(), Self::Error>;
+    #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
+    #[cfg(feature = "bignum")]
     fn serialize_int(self, v: &crate::Int) -> Result<(), Self::Error>;
+    fn serialize_i128(self, v: i128) -> Result<(), Self::Error>;
+    #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
+    #[cfg(feature = "bignum")]
     fn serialize_nat(self, v: &crate::Nat) -> Result<(), Self::Error>;
+    fn serialize_u128(self, v: u128) -> Result<(), Self::Error>;
     fn serialize_nat8(self, v: u8) -> Result<(), Self::Error>;
     fn serialize_nat16(self, v: u16) -> Result<(), Self::Error>;
     fn serialize_nat32(self, v: u32) -> Result<(), Self::Error>;
diff --git a/rust/candid/tests/number.rs b/rust/candid/tests/number.rs
index ecaf1b03..48baffa5 100644
--- a/rust/candid/tests/number.rs
+++ b/rust/candid/tests/number.rs
@@ -1,3 +1,4 @@
+use candid::types::leb128::*;
 use candid::{Int, Nat};
 use num_traits::cast::ToPrimitive;
 
@@ -51,10 +52,16 @@ fn random_i64() {
             let mut encoded = Vec::new();
             Int::from(x).encode(&mut encoded).unwrap();
             assert_eq!(expected, encoded);
+            encoded.clear();
+            encode_int(&mut encoded, x.into()).unwrap();
+            assert_eq!(expected, encoded);
         }
         let mut readable = &expected[..];
         let decoded = Int::decode(&mut readable).unwrap();
         assert_eq!(decoded.0.to_i64().unwrap(), x);
+        readable = &expected[..];
+        let decoded = decode_int(&mut readable).unwrap();
+        assert_eq!(decoded as i64, x);
     }
 }
 
@@ -70,10 +77,16 @@ fn random_u64() {
             let mut encoded = Vec::new();
             Nat::from(x).encode(&mut encoded).unwrap();
             assert_eq!(expected, encoded);
+            encoded.clear();
+            encode_nat(&mut encoded, x.into()).unwrap();
+            assert_eq!(expected, encoded);
         }
         let mut readable = &expected[..];
         let decoded = Nat::decode(&mut readable).unwrap();
         assert_eq!(decoded.0.to_u64().unwrap(), x);
+        readable = &expected[..];
+        let decoded = decode_nat(&mut readable).unwrap();
+        assert_eq!(decoded as u64, x);
     }
 }
 

From 2a7896e6929dda83767529e1a846f668e8b99df8 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Wed, 25 Oct 2023 19:19:48 -0700
Subject: [PATCH 18/24] bump candid_derive

---
 Cargo.lock                    | 113 ++++++++++++++++++----------------
 Cargo.toml                    |  12 ++--
 rust/candid/Cargo.toml        |   8 +--
 rust/candid_derive/Cargo.toml |   2 +-
 4 files changed, 70 insertions(+), 65 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8f69e848..9a9cfa8d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -138,7 +138,7 @@ version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.1.19",
  "libc",
  "winapi",
 ]
@@ -283,7 +283,7 @@ dependencies = [
 
 [[package]]
 name = "candid_derive"
-version = "0.6.4"
+version = "0.6.5"
 dependencies = [
  "lazy_static",
  "proc-macro2 1.0.69",
@@ -378,9 +378,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.6"
+version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d04704f56c2cde07f43e8e2c154b43f216dc5c92fc98ada720177362f953b956"
+checksum = "ac495e00dcec98c83465d5ad66c5c4fabd652fd6686e7c6269b117e729a6f17b"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -388,21 +388,21 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.6"
+version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e231faeaca65ebd1ea3c737966bf858971cd38c3849107aa3ea7de90a804e45"
+checksum = "c77ed9a32a62e6ca27175d00d29d05ca32e396ea1eb5fb01d8256b669cec7663"
 dependencies = [
  "anstream",
  "anstyle",
- "clap_lex 0.5.1",
+ "clap_lex 0.6.0",
  "strsim",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "4.4.2"
+version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0862016ff20d69b84ef8247369fabf5c008a7417002411897d40ee1f4532b873"
+checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
 dependencies = [
  "heck",
  "proc-macro2 1.0.69",
@@ -421,9 +421,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd7cc57abe963c6d3b9d8be5b06ba7c8957a930305ca90304f24ef040aa6f961"
+checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
 
 [[package]]
 name = "codespan-reporting"
@@ -571,6 +571,12 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"
 
+[[package]]
+name = "deunicode"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a1abaf4d861455be59f64fd2b55606cb151fce304ede7165f410243ce96bde6"
+
 [[package]]
 name = "dhall"
 version = "0.11.1"
@@ -613,12 +619,18 @@ version = "0.3.5"
 dependencies = [
  "anyhow",
  "candid_parser",
- "clap 4.4.6",
+ "clap 4.4.7",
  "hex",
  "pretty-hex",
  "rand",
 ]
 
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
 [[package]]
 name = "digest"
 version = "0.9.0"
@@ -713,12 +725,12 @@ dependencies = [
 
 [[package]]
 name = "fake"
-version = "2.8.0"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9af7b0c58ac9d03169e27f080616ce9f64004edca3d2ef4147a811c21b23b319"
+checksum = "26221445034074d46b276e13eb97a265ebdb8ed8da705c4dddd3dd20b66b45d2"
 dependencies = [
+ "deunicode",
  "rand",
- "unidecode",
 ]
 
 [[package]]
@@ -818,6 +830,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "hermit-abi"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7"
+
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -887,28 +905,30 @@ dependencies = [
 ]
 
 [[package]]
-name = "itertools"
-version = "0.9.0"
+name = "is-terminal"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
+checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b"
 dependencies = [
- "either",
+ "hermit-abi 0.3.3",
+ "rustix",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "itertools"
-version = "0.10.5"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "itertools"
-version = "0.11.0"
+version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
 dependencies = [
  "either",
 ]
@@ -930,14 +950,16 @@ dependencies = [
 
 [[package]]
 name = "lalrpop"
-version = "0.20.1"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83be602e051ada38d90c7841092adabeb585197afe9dabb20e4f8375cc87846e"
+checksum = "da4081d44f4611b66c6dd725e6de3169f9f63905421e8626fcb86b6a898998b8"
 dependencies = [
  "ascii-canvas",
  "bit-set",
+ "diff",
  "ena",
- "itertools 0.11.0",
+ "is-terminal",
+ "itertools 0.10.5",
  "lalrpop-util",
  "petgraph",
  "pico-args",
@@ -951,11 +973,11 @@ dependencies = [
 
 [[package]]
 name = "lalrpop-util"
-version = "0.20.1"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "365d88f9d803538a06641e6736f21d95ecf9226dc1693421212e62c405cdd199"
+checksum = "3f35c735096c0293d313e8f2a641627472b83d01b937177fe76e5e2708d31e0d"
 dependencies = [
- "regex-automata 0.3.9",
+ "regex",
 ]
 
 [[package]]
@@ -1159,9 +1181,9 @@ checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
 
 [[package]]
 name = "pest"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c022f1e7b65d6a24c0dbbd5fb344c66881bc01f3e5ae74a1c8100f2f985d98a4"
+checksum = "ae9cee2a55a544be8b89dc6848072af97a20f2422603c10865be2a42b580fff5"
 dependencies = [
  "memchr",
  "thiserror",
@@ -1192,9 +1214,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35513f630d46400a977c4cb58f78e1bfbe01434316e60c37d27b9ad6139c66d8"
+checksum = "81d78524685f5ef2a3b3bd1cafbc9fcabb036253d9b1463e726a91cd16e2dfc2"
 dependencies = [
  "pest",
  "pest_generator",
@@ -1202,9 +1224,9 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc9fc1b9e7057baba189b5c626e2d6f40681ae5b6eb064dc7c7834101ec8123a"
+checksum = "68bd1206e71118b5356dae5ddc61c8b11e28b09ef6a31acbd15ea48a28e0c227"
 dependencies = [
  "pest",
  "pest_meta",
@@ -1215,9 +1237,9 @@ dependencies = [
 
 [[package]]
 name = "pest_meta"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1df74e9e7ec4053ceb980e7c0c8bd3594e977fde1af91daba9c928e8e8c6708d"
+checksum = "7c747191d4ad9e4a4ab9c8798f1e82a39affe7ef9648390b7e5548d18e099de6"
 dependencies = [
  "once_cell",
  "pest",
@@ -1469,17 +1491,6 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 
-[[package]]
-name = "regex-automata"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax 0.7.5",
-]
-
 [[package]]
 name = "regex-automata"
 version = "0.4.3"
@@ -1916,12 +1927,6 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
-[[package]]
-name = "unidecode"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "402bb19d8e03f1d1a7450e2bd613980869438e0666331be3e073089124aa1adc"
-
 [[package]]
 name = "url"
 version = "2.4.1"
diff --git a/Cargo.toml b/Cargo.toml
index 807f349d..10bfdee8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,11 +9,11 @@ members = [
 resolver = "2"
 
 [workspace.dependencies]
-hex = "0.4.2"
-num-bigint = { version = "0.4.2", features = ["serde"] }
-num-traits = "0.2.12"
-pretty = "0.12.0"
-serde = { version = "1.0.118", features = ["derive"] }
-thiserror = "1.0.20"
+hex = "0.4.3"
+num-bigint = { version = "0.4", features = ["serde"] }
+num-traits = "0.2"
+pretty = "0.12"
+serde = { version = "1.0", features = ["derive"] }
+thiserror = "1.0"
 anyhow = "1.0"
 rand = "0.8"
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index 94ad9cc1..3f8571d8 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -14,12 +14,12 @@ keywords = ["internet-computer", "idl", "candid", "dfinity"]
 include = ["src", "Cargo.toml", "LICENSE", "README.md"]
 
 [dependencies]
-candid_derive = { path = "../candid_derive", version = "=0.6.4" }
+candid_derive = { path = "../candid_derive", version = "=0.6.5" }
 ic_principal = { path = "../ic_principal", version = "0.1.0" }
 binread = { version = "2.1", features = ["debug_template"] }
-byteorder = "1.4.3"
-leb128 = "0.2.4"
-paste = "1.0.0"
+byteorder = "1.5.0"
+leb128 = "0.2.5"
+paste = "1.0"
 hex.workspace = true
 serde.workspace = true
 thiserror.workspace = true
diff --git a/rust/candid_derive/Cargo.toml b/rust/candid_derive/Cargo.toml
index 60866ad5..691c4bcb 100644
--- a/rust/candid_derive/Cargo.toml
+++ b/rust/candid_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "candid_derive"
-version = "0.6.4"
+version = "0.6.5"
 edition = "2021"
 authors = ["DFINITY Team"]
 description = "Macros implementation of #[derive(CandidType)] for the Candid."

From ffb04a3e59478f6b5eb732d77343e7376648b7c9 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Thu, 26 Oct 2023 10:39:09 -0700
Subject: [PATCH 19/24] silence subtyping in decoder

---
 Changelog.md                     | 3 ++-
 rust/candid/src/de.rs            | 5 +++--
 rust/candid/src/types/subtype.rs | 4 ++--
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index 135529f3..ce4da643 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -8,9 +8,10 @@
 * The original `candid` crate is split into three crates:
   * `candid`: mainly for Candid data (de-)serialization.
     + `candid::bindings::candid` moves to `candid::pretty::candid`. `candid::pretty` moves to `candid::pretty::utils`. These modules are only available under feature flag `printer` (enabled by default).
+    + `candid::{Int, Nat}` is only available under feature flag `bignum` (enabled by default). If this feature is not enabled, you can use `i128/u128` for `int/nat` type.
     + `candid::types::number::pp_num_str` moves to `candid::utils::pp_num_str`.
     + `candid::types::value` module is only availble under feature flag `value`.
-    + `mute_warning` feature flag is removed.
+    + `mute_warning` feature flag is removed, use `candid::types::subtype_with_config` instead.
   * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
     + Remove `FromStr` trait for `IDLArgs` and `IDLValue`. Use `parse_idl_args` and `parse_idl_value` respectively instead.
     + `TypeEnv.ast_to_type` becomes `candid_parser::typing::ast_to_type`.
diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index 67e4d941..f33751bf 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -10,7 +10,7 @@ use super::{
 use super::{Int, Nat};
 use crate::{
     binary_parser::{BoolValue, Header, Len, PrincipalBytes},
-    types::subtype::{subtype, Gamma},
+    types::subtype::{subtype_with_config, Gamma, OptReport},
 };
 use anyhow::{anyhow, Context};
 use binread::BinRead;
@@ -277,7 +277,8 @@ impl<'de> Deserializer<'de> {
         Ok(res)
     }
     fn check_subtype(&mut self) -> Result<()> {
-        subtype(
+        subtype_with_config(
+            OptReport::Silence,
             &mut self.gamma,
             &self.table,
             &self.wire_type,
diff --git a/rust/candid/src/types/subtype.rs b/rust/candid/src/types/subtype.rs
index 141b9d0e..49d0cd05 100644
--- a/rust/candid/src/types/subtype.rs
+++ b/rust/candid/src/types/subtype.rs
@@ -9,7 +9,7 @@ pub type Gamma = HashSet<(Type, Type)>;
 /// Error reporting style for the special opt rule
 #[derive(Debug, Copy, Clone)]
 pub enum OptReport {
-    Slience,
+    Silence,
     Warning,
     Error,
 }
@@ -71,7 +71,7 @@ fn subtype_(
         (_, Opt(_)) => {
             let msg = format!("FIX ME! {t1} <: {t2} via special opt rule.\nThis means the sender and receiver type has diverged, and can cause data loss.");
             match report {
-                OptReport::Slience => (),
+                OptReport::Silence => (),
                 OptReport::Warning => eprintln!("{msg}"),
                 OptReport::Error => return Err(Error::msg(msg)),
             };

From 782c43753e896ebd228cc9a1a1ad7c19498d2fff Mon Sep 17 00:00:00 2001
From: Yan Chen <48968912+chenyan-dfinity@users.noreply.github.com>
Date: Thu, 26 Oct 2023 11:15:19 -0700
Subject: [PATCH 20/24] fix service_equal error reporting (#486)

---
 rust/candid/src/types/subtype.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/rust/candid/src/types/subtype.rs b/rust/candid/src/types/subtype.rs
index 552c9b85..4101cdbc 100644
--- a/rust/candid/src/types/subtype.rs
+++ b/rust/candid/src/types/subtype.rs
@@ -143,7 +143,8 @@ pub fn equal(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<(
         (Opt(ty1), Opt(ty2)) => equal(gamma, env, ty1, ty2),
         (Vec(ty1), Vec(ty2)) => equal(gamma, env, ty1, ty2),
         (Record(fs1), Record(fs2)) | (Variant(fs1), Variant(fs2)) => {
-            assert_length(fs1, fs2, |x| x.to_string()).context("Different field length")?;
+            assert_length(fs1, fs2, |x| x.id.clone(), |x| x.to_string())
+                .context("Different field length")?;
             for (f1, f2) in fs1.iter().zip(fs2.iter()) {
                 if f1.id != f2.id {
                     return Err(Error::msg(format!(
@@ -159,7 +160,7 @@ pub fn equal(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<(
             Ok(())
         }
         (Service(ms1), Service(ms2)) => {
-            assert_length(ms1, ms2, |x| format!("method {} : {}", x.0, x.1))
+            assert_length(ms1, ms2, |x| x.0.clone(), |x| format!("method {x}"))
                 .context("Different method length")?;
             for (m1, m2) in ms1.iter().zip(ms2.iter()) {
                 if m1.0 != m2.0 {
@@ -203,18 +204,19 @@ pub fn equal(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<(
     }
 }
 
-fn assert_length<I, F>(left: &[I], right: &[I], display: F) -> Result<()>
+fn assert_length<I, F, K, D>(left: &[I], right: &[I], get_key: F, display: D) -> Result<()>
 where
-    F: Fn(&I) -> String,
-    I: Clone + std::hash::Hash + std::cmp::Eq,
+    F: Fn(&I) -> K + Clone,
+    K: std::hash::Hash + std::cmp::Eq,
+    D: Fn(&K) -> String,
 {
     let l = left.len();
     let r = right.len();
     if l == r {
         return Ok(());
     }
-    let left: HashSet<_> = left.iter().cloned().collect();
-    let right: HashSet<_> = right.iter().cloned().collect();
+    let left: HashSet<_> = left.iter().map(get_key.clone()).collect();
+    let right: HashSet<_> = right.iter().map(get_key).collect();
     if l < r {
         let mut diff = right.difference(&left);
         Err(Error::msg(format!(

From 35008a3db52160eb1be49c61258687b9ffcdd2a5 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Thu, 26 Oct 2023 19:30:33 -0700
Subject: [PATCH 21/24] add IDLValue::Blob

---
 .github/workflows/bench.yml                   |  2 +-
 Changelog.md                                  |  1 +
 rust/candid/src/de.rs                         | 22 ++++++++++++++++++-
 rust/candid/src/pretty/candid.rs              |  7 ++++++
 rust/candid/src/types/internal.rs             | 15 +++++++++++++
 rust/candid/src/types/value.rs                | 19 ++++++++++++++--
 rust/candid_parser/src/bindings/javascript.rs |  4 ++++
 rust/candid_parser/src/grammar.lalrpop        |  5 +----
 8 files changed, 67 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index ea2101ec..c9b3bb0e 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -2,7 +2,7 @@ name: Rust Bench
 on:
   pull_request:
     paths:
-    - 'rust/**'
+    - 'rust/candid/**'
 jobs:
   runBenchMark:
     name: run benchmark
diff --git a/Changelog.md b/Changelog.md
index ce4da643..1662b37b 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -9,6 +9,7 @@
   * `candid`: mainly for Candid data (de-)serialization.
     + `candid::bindings::candid` moves to `candid::pretty::candid`. `candid::pretty` moves to `candid::pretty::utils`. These modules are only available under feature flag `printer` (enabled by default).
     + `candid::{Int, Nat}` is only available under feature flag `bignum` (enabled by default). If this feature is not enabled, you can use `i128/u128` for `int/nat` type.
+    + Add `IDLValue::Blob(Vec<u8>)` enum for efficient handling of blob value.
     + `candid::types::number::pp_num_str` moves to `candid::utils::pp_num_str`.
     + `candid::types::value` module is only availble under feature flag `value`.
     + `mute_warning` feature flag is removed, use `candid::types::subtype_with_config` instead.
diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index f33751bf..ddcc45de 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -337,7 +337,7 @@ impl<'de> Deserializer<'de> {
     // Customize deserailization methods
     // Several deserialize functions will call visit_byte_buf.
     // We reserve the first byte to be a tag to distinguish between different callers:
-    // int(0), nat(1), principal(2), reserved(3), service(4), function(5)
+    // int(0), nat(1), principal(2), reserved(3), service(4), function(5), blob(6)
     // This is necessary for deserializing IDLValue because
     // it has only one visitor and we need a way to know who called the visitor.
     #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
@@ -428,6 +428,22 @@ impl<'de> Deserializer<'de> {
         bytes.extend_from_slice(&id);
         visitor.visit_byte_buf(bytes)
     }
+    fn deserialize_blob<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.unroll_type()?;
+        check!(
+            self.expect_type.is_blob(&self.table) && self.wire_type.is_blob(&self.table),
+            "blob"
+        );
+        let len = Len::read(&mut self.input)?.0;
+        let blob = self.borrow_bytes(len)?;
+        let mut bytes = Vec::with_capacity(len + 1);
+        bytes.push(6u8);
+        bytes.extend_from_slice(blob);
+        visitor.visit_byte_buf(bytes)
+    }
     fn deserialize_empty<'a, V>(&'a mut self, _visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
@@ -546,6 +562,10 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             TypeInner::Principal => self.deserialize_principal(visitor),
             // construct types
             TypeInner::Opt(_) => self.deserialize_option(visitor),
+            // This is an optimization for blob, mostly likely used by IDLValue, but it won't help the native Vec<u8>
+            TypeInner::Vec(_) if self.expect_type.is_blob(&self.table) => {
+                self.deserialize_blob(visitor)
+            }
             TypeInner::Vec(_) => self.deserialize_seq(visitor),
             TypeInner::Record(_) => self.deserialize_struct("_", &[], visitor),
             TypeInner::Variant(_) => self.deserialize_enum("_", &[], visitor),
diff --git a/rust/candid/src/pretty/candid.rs b/rust/candid/src/pretty/candid.rs
index 09897385..e143b22c 100644
--- a/rust/candid/src/pretty/candid.rs
+++ b/rust/candid/src/pretty/candid.rs
@@ -338,6 +338,13 @@ pub mod value {
                 Func(id, meth) => write!(f, "func \"{}\".{}", id, ident_string(meth)),
                 Opt(v) if has_type_annotation(v) => write!(f, "opt ({v:?})"),
                 Opt(v) => write!(f, "opt {v:?}"),
+                Blob(b) => {
+                    write!(f, "blob \"")?;
+                    for v in b.iter() {
+                        write!(f, "{}", &pp_char(*v))?;
+                    }
+                    write!(f, "\"")
+                }
                 Vec(vs) => {
                     if let Some(Nat8(_)) = vs.first() {
                         write!(f, "blob \"")?;
diff --git a/rust/candid/src/types/internal.rs b/rust/candid/src/types/internal.rs
index d0f5a90a..8bc7cf63 100644
--- a/rust/candid/src/types/internal.rs
+++ b/rust/candid/src/types/internal.rs
@@ -231,11 +231,26 @@ impl TypeInner {
             _ => false,
         }
     }
+    pub fn is_blob(&self, env: &crate::TypeEnv) -> bool {
+        match self {
+            TypeInner::Vec(t) => {
+                let t = match env.trace_type(t) {
+                    Ok(t) => t,
+                    Err(_) => return false,
+                };
+                matches!(*t, TypeInner::Nat8)
+            }
+            _ => false,
+        }
+    }
 }
 impl Type {
     pub fn is_tuple(&self) -> bool {
         self.as_ref().is_tuple()
     }
+    pub fn is_blob(&self, env: &crate::TypeEnv) -> bool {
+        self.as_ref().is_blob(env)
+    }
     pub fn subst(&self, tau: &std::collections::BTreeMap<String, String>) -> Self {
         use TypeInner::*;
         match self.as_ref() {
diff --git a/rust/candid/src/types/value.rs b/rust/candid/src/types/value.rs
index ebfb0f5c..8c6cef0b 100644
--- a/rust/candid/src/types/value.rs
+++ b/rust/candid/src/types/value.rs
@@ -18,6 +18,7 @@ pub enum IDLValue {
     Vec(Vec<IDLValue>),
     Record(Vec<IDLField>),
     Variant(VariantValue),
+    Blob(Vec<u8>),
     Principal(crate::Principal),
     Service(crate::Principal),
     Func(crate::Principal, String),
@@ -189,6 +190,17 @@ impl IDLValue {
             }
             // fallback
             (_, TypeInner::Opt(_)) if !from_parser => IDLValue::None,
+            (IDLValue::Blob(blob), ty) if ty.is_blob(env) => IDLValue::Blob(blob.to_vec()),
+            (IDLValue::Vec(vec), ty) if ty.is_blob(env) => {
+                let blob = vec
+                    .iter()
+                    .filter_map(|x| match *x {
+                        IDLValue::Nat8(n) => Some(n),
+                        _ => None,
+                    })
+                    .collect();
+                IDLValue::Blob(blob)
+            }
             (IDLValue::Vec(vec), TypeInner::Vec(ty)) => {
                 let mut res = Vec::new();
                 for e in vec.iter() {
@@ -284,6 +296,7 @@ impl IDLValue {
                 let t = v.deref().value_ty();
                 TypeInner::Opt(t)
             }
+            IDLValue::Blob(_) => TypeInner::Vec(TypeInner::Nat8.into()),
             IDLValue::Vec(ref vec) => {
                 let t = if vec.is_empty() {
                     TypeInner::Empty.into()
@@ -368,6 +381,7 @@ impl crate::CandidType for IDLValue {
                 }
                 Ok(())
             }
+            IDLValue::Blob(ref blob) => serializer.serialize_blob(blob),
             IDLValue::Record(ref vec) => {
                 let mut ser = serializer.serialize_struct()?;
                 for f in vec.iter() {
@@ -420,7 +434,7 @@ impl<'de> Visitor<'de> for IDLValueVisitor {
     visit_prim!(Int64, i64);
     visit_prim!(Float32, f32);
     visit_prim!(Float64, f64);
-    // Deserialize Candid specific types: Bignumber, principal, reversed, service, function
+    // Deserialize Candid specific types: Bignumber, principal, reversed, service, function, blob
     fn visit_byte_buf<E: de::Error>(self, value: Vec<u8>) -> DResult<E> {
         let (tag, mut bytes) = value.split_at(1);
         match tag[0] {
@@ -436,6 +450,7 @@ impl<'de> Visitor<'de> for IDLValueVisitor {
                 let v = crate::Principal::try_from(bytes).map_err(E::custom)?;
                 Ok(IDLValue::Principal(v))
             }
+            3u8 => Ok(IDLValue::Reserved),
             4u8 => {
                 let v = crate::Principal::try_from(bytes).map_err(E::custom)?;
                 Ok(IDLValue::Service(v))
@@ -449,7 +464,7 @@ impl<'de> Visitor<'de> for IDLValueVisitor {
                 let id = crate::Principal::try_from(bytes).map_err(E::custom)?;
                 Ok(IDLValue::Func(id, meth))
             }
-            3u8 => Ok(IDLValue::Reserved),
+            6u8 => Ok(IDLValue::Blob(bytes.to_vec())),
             _ => Err(de::Error::custom("unknown tag in visit_byte_buf")),
         }
     }
diff --git a/rust/candid_parser/src/bindings/javascript.rs b/rust/candid_parser/src/bindings/javascript.rs
index ae441da1..02476638 100644
--- a/rust/candid_parser/src/bindings/javascript.rs
+++ b/rust/candid_parser/src/bindings/javascript.rs
@@ -334,6 +334,10 @@ pub mod value {
             Text(s) => RcDoc::text(format!("'{}'", s.escape_debug())),
             None => RcDoc::text("[]"),
             Opt(v) => enclose_space("[", pp_value(v), "]"),
+            Blob(blob) => {
+                let body = concat(blob.iter().map(RcDoc::as_string), ",");
+                enclose_space("[", body, "]")
+            }
             Vec(vs) => {
                 let body = concat(vs.iter().map(pp_value), ",");
                 enclose_space("[", body, "]")
diff --git a/rust/candid_parser/src/grammar.lalrpop b/rust/candid_parser/src/grammar.lalrpop
index 153924f0..0951556c 100644
--- a/rust/candid_parser/src/grammar.lalrpop
+++ b/rust/candid_parser/src/grammar.lalrpop
@@ -57,10 +57,7 @@ pub Arg: IDLValue = {
     "bool" => IDLValue::Bool(<>),
     NumLiteral => <>,
     Text => IDLValue::Text(<>),
-    Bytes => {
-        let values: Vec<_> = <>.into_iter().map(|v| IDLValue::Nat8(v)).collect();
-        IDLValue::Vec(values)
-    },
+    Bytes => IDLValue::Blob(<>),
     "null" => IDLValue::Null,
     "opt" <Arg> => IDLValue::Opt(Box::new(<>)),
     "vec" "{" <SepBy<AnnVal, ";">> "}" => IDLValue::Vec(<>),

From d243b33474f73eb6271a0076531160d6b124ebe3 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Fri, 27 Oct 2023 14:09:54 -0700
Subject: [PATCH 22/24] builder for config

---
 Changelog.md                            |  2 ++
 rust/candid/src/de.rs                   | 20 +++++++++++++++--
 rust/candid/src/types/leb128.rs         |  3 +++
 rust/candid_parser/src/bindings/rust.rs | 30 ++++++++++++++++++++-----
 rust/candid_parser/tests/parse_type.rs  |  4 ++--
 tools/didc/src/main.rs                  |  2 +-
 6 files changed, 51 insertions(+), 10 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index 1662b37b..cc7b8b34 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -16,6 +16,7 @@
   * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
     + Remove `FromStr` trait for `IDLArgs` and `IDLValue`. Use `parse_idl_args` and `parse_idl_value` respectively instead.
     + `TypeEnv.ast_to_type` becomes `candid_parser::typing::ast_to_type`.
+    + `bindings::rust::Config` uses builder pattern.
     + `candid` is re-exported in `candid_parser::candid`.
     + `candid::*` is re-exported in `candid_parser`.
   * `ic_principal`: only for `Principal` and `PrincipalError`.
@@ -23,6 +24,7 @@
 ### Non-breaking changes
 
 * Add `candid::types::subtype_with_config` to control the error reporting level of special opt rule.
+* Add `Type.is_blob(env)` method to check if a type is a blob type.
 
 ## Rust 0.9.9 -- 0.9.11
 
diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index ddcc45de..173746f1 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -140,8 +140,24 @@ impl<'de> IDLDeserialize<'de> {
 }
 
 pub struct Config {
-    pub zero_sized_values: usize,
-    pub full_error_message: bool,
+    zero_sized_values: usize,
+    full_error_message: bool,
+}
+impl Config {
+    pub fn new() -> Self {
+        Self {
+            zero_sized_values: 2_000_000,
+            full_error_message: true,
+        }
+    }
+    pub fn set_zero_sized_values(&mut self, n: usize) -> &mut Self {
+        self.zero_sized_values = n;
+        self
+    }
+    pub fn set_full_error_message(&mut self, n: bool) -> &mut Self {
+        self.full_error_message = n;
+        self
+    }
 }
 
 macro_rules! assert {
diff --git a/rust/candid/src/types/leb128.rs b/rust/candid/src/types/leb128.rs
index 5a6b76c5..a250a031 100644
--- a/rust/candid/src/types/leb128.rs
+++ b/rust/candid/src/types/leb128.rs
@@ -1,6 +1,9 @@
 use crate::error::{Error, Result};
 use std::io;
 
+// Code copied from https://github.com/gimli-rs/leb128/blob/master/src/lib.rs.
+// Changing the type from i64 to i128
+
 const CONTINUATION_BIT: u8 = 1 << 7;
 const SIGN_BIT: u8 = 1 << 6;
 
diff --git a/rust/candid_parser/src/bindings/rust.rs b/rust/candid_parser/src/bindings/rust.rs
index 5bc14215..745cf140 100644
--- a/rust/candid_parser/src/bindings/rust.rs
+++ b/rust/candid_parser/src/bindings/rust.rs
@@ -14,14 +14,14 @@ pub enum Target {
 
 #[derive(Clone)]
 pub struct Config {
-    pub candid_crate: String,
+    candid_crate: String,
     /// Applies to all types for now
-    pub type_attributes: String,
+    type_attributes: String,
     /// Only generates SERVICE struct if canister_id is not provided
-    pub canister_id: Option<candid::Principal>,
+    canister_id: Option<candid::Principal>,
     /// Service name when canister id is provided
-    pub service_name: String,
-    pub target: Target,
+    service_name: String,
+    target: Target,
 }
 impl Config {
     pub fn new() -> Self {
@@ -33,6 +33,26 @@ impl Config {
             target: Target::CanisterCall,
         }
     }
+    pub fn set_candid_crate(&mut self, name: String) -> &mut Self {
+        self.candid_crate = name;
+        self
+    }
+    pub fn set_type_attributes(&mut self, attr: String) -> &mut Self {
+        self.type_attributes = attr;
+        self
+    }
+    pub fn set_canister_id(&mut self, id: candid::Principal) -> &mut Self {
+        self.canister_id = Some(id);
+        self
+    }
+    pub fn set_service_name(&mut self, name: String) -> &mut Self {
+        self.service_name = name;
+        self
+    }
+    pub fn set_target(&mut self, name: Target) -> &mut Self {
+        self.target = name;
+        self
+    }
 }
 impl Default for Config {
     fn default() -> Self {
diff --git a/rust/candid_parser/tests/parse_type.rs b/rust/candid_parser/tests/parse_type.rs
index 779c3496..7dfb2fb6 100644
--- a/rust/candid_parser/tests/parse_type.rs
+++ b/rust/candid_parser/tests/parse_type.rs
@@ -63,9 +63,9 @@ fn compiler_test(resource: &str) {
             }
             {
                 let mut config = rust::Config::new();
-                config.canister_id = Some(candid::Principal::from_text("aaaaa-aa").unwrap());
+                config.set_canister_id(candid::Principal::from_text("aaaaa-aa").unwrap());
                 if filename.file_name().unwrap().to_str().unwrap() == "management.did" {
-                    config.target = rust::Target::Agent;
+                    config.set_target(rust::Target::Agent);
                 }
                 let mut output = mint.new_goldenfile(filename.with_extension("rs")).unwrap();
                 let content = rust::compile(&config, &env, &actor);
diff --git a/tools/didc/src/main.rs b/tools/didc/src/main.rs
index 09673193..b3f8d385 100644
--- a/tools/didc/src/main.rs
+++ b/tools/didc/src/main.rs
@@ -206,7 +206,7 @@ fn main() -> Result<()> {
                 }
                 "rs-agent" => {
                     let mut config = candid_parser::bindings::rust::Config::new();
-                    config.target = candid_parser::bindings::rust::Target::Agent;
+                    config.set_target(candid_parser::bindings::rust::Target::Agent);
                     candid_parser::bindings::rust::compile(&config, &env, &actor)
                 }
                 _ => unreachable!(),

From 41925c67107e5ae9e393cfa819cec3d16ecaa854 Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Fri, 27 Oct 2023 15:58:43 -0700
Subject: [PATCH 23/24] fix

---
 rust/candid_parser/src/bindings/rust.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/rust/candid_parser/src/bindings/rust.rs b/rust/candid_parser/src/bindings/rust.rs
index 745cf140..ee1b1b8c 100644
--- a/rust/candid_parser/src/bindings/rust.rs
+++ b/rust/candid_parser/src/bindings/rust.rs
@@ -15,11 +15,8 @@ pub enum Target {
 #[derive(Clone)]
 pub struct Config {
     candid_crate: String,
-    /// Applies to all types for now
     type_attributes: String,
-    /// Only generates SERVICE struct if canister_id is not provided
     canister_id: Option<candid::Principal>,
-    /// Service name when canister id is provided
     service_name: String,
     target: Target,
 }
@@ -37,14 +34,17 @@ impl Config {
         self.candid_crate = name;
         self
     }
+    /// Applies to all types for now
     pub fn set_type_attributes(&mut self, attr: String) -> &mut Self {
         self.type_attributes = attr;
         self
     }
+    /// Only generates SERVICE struct if canister_id is not provided
     pub fn set_canister_id(&mut self, id: candid::Principal) -> &mut Self {
         self.canister_id = Some(id);
         self
     }
+    /// Service name when canister id is provided
     pub fn set_service_name(&mut self, name: String) -> &mut Self {
         self.service_name = name;
         self

From bbe3d7af46f8eb7255e88d66390997cef6e17abb Mon Sep 17 00:00:00 2001
From: Yan Chen <yan.chen@dfinity.org>
Date: Fri, 27 Oct 2023 16:29:47 -0700
Subject: [PATCH 24/24] fix

---
 rust/candid/src/de.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index 173746f1..1df200e0 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -159,6 +159,11 @@ impl Config {
         self
     }
 }
+impl Default for Config {
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
 macro_rules! assert {
     ( false ) => {{