feat: support line comments

rust/candid/src/binary_parser.rs

@@ -188,6 +188,7 @@ impl ConsType {
                     let field = Field {
                         id: Label::Id(f.id).into(),
                         ty: f.index.to_type(len)?,
+                        comment: None,
                     };
                     res.push(field);
                 }

rust/candid/src/de.rs

@@ -923,8 +923,8 @@ impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
                     (TypeInner::Record(ref e), TypeInner::Record(ref w)) => {
                         match (&e[..], &w[..]) {
                             (
-                                [Field { id: e_id0, ty: ek }, Field { id: e_id1, ty: ev }],
-                                [Field { id: w_id0, ty: wk }, Field { id: w_id1, ty: wv }],
+                                [Field { id: e_id0, ty: ek, .. }, Field { id: e_id1, ty: ev, .. }],
+                                [Field { id: w_id0, ty: wk, .. }, Field { id: w_id1, ty: wv, .. }],
                             ) if **e_id0 == Label::Id(0)
                                 && **e_id1 == Label::Id(1)
                                 && **w_id0 == Label::Id(0)

rust/candid/src/pretty/candid.rs

@@ -74,10 +74,10 @@ pub(crate) fn pp_text(id: &str) -> RcDoc {
 }
 
 pub fn pp_ty(ty: &Type) -> RcDoc {
-    pp_ty_inner(ty.as_ref())
+    pp_ty_inner(ty.as_ref(), ty.comment())
 }
 
-pub fn pp_ty_inner(ty: &TypeInner) -> RcDoc {
+pub fn pp_ty_inner<'a>(ty: &'a TypeInner, comment: Option<&[String]>) -> RcDoc<'a> {
     use TypeInner::*;
     match ty {
         Null => str("null"),
@@ -103,7 +103,7 @@ pub fn pp_ty_inner(ty: &TypeInner) -> RcDoc {
         Vec(ref t) if matches!(t.as_ref(), Nat8) => str("blob"),
         Vec(ref t) => kwd("vec").append(pp_ty(t)),
         Record(ref fs) => {
-            let t = Type(ty.clone().into());
+            let t = Type::from((ty.clone(), comment));
             if t.is_tuple() {
                 let tuple = concat(fs.iter().map(|f| pp_ty(&f.ty)), ";");
                 kwd("record").append(enclose_space("{", tuple, "}"))
@@ -141,7 +141,9 @@ pub(crate) fn pp_field(field: &Field, is_variant: bool) -> RcDoc {
     } else {
         kwd(" :").append(pp_ty(&field.ty))
     };
-    pp_label(&field.id).append(ty_doc)
+    pp_comment(field.comment())
+        .append(pp_label(&field.id))
+        .append(ty_doc)
 }
 
 fn pp_fields(fs: &[Field], is_variant: bool) -> RcDoc {
@@ -195,7 +197,10 @@ fn pp_service(serv: &[(String, Type)]) -> RcDoc {
                 TypeInner::Var(_) => pp_ty(func),
                 _ => unreachable!(),
             };
-            pp_text(id).append(kwd(" :")).append(func_doc)
+            pp_comment(func.comment())
+                .append(pp_text(id))
+                .append(kwd(" :"))
+                .append(func_doc)
         }),
         ";",
     );
@@ -204,7 +209,8 @@ fn pp_service(serv: &[(String, Type)]) -> RcDoc {
 
 fn pp_defs(env: &TypeEnv) -> RcDoc {
     lines(env.0.iter().map(|(id, ty)| {
-        kwd("type")
+        pp_comment(ty.comment())
+            .append(kwd("type"))
             .append(ident(id))
             .append(kwd("="))
             .append(pp_ty(ty))
@@ -220,6 +226,17 @@ fn pp_actor(ty: &Type) -> RcDoc {
     }
 }
 
+fn pp_comment(comment_lines: Option<&[String]>) -> RcDoc {
+    let mut comment_doc = RcDoc::nil();
+    if let Some(comment_lines) = comment_lines {
+        for line in comment_lines {
+            comment_doc =
+                comment_doc.append(RcDoc::text("// ").append(line).append(RcDoc::hardline()));
+        }
+    }
+    comment_doc
+}
+
 pub fn pp_init_args<'a>(env: &'a TypeEnv, args: &'a [ArgType]) -> RcDoc<'a> {
     pp_defs(env).append(pp_args(args))
 }
@@ -228,7 +245,9 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
         None => pp_defs(env).pretty(LINE_WIDTH).to_string(),
         Some(actor) => {
             let defs = pp_defs(env);
-            let actor = kwd("service :").append(pp_actor(actor));
+            let actor = pp_comment(actor.comment())
+                .append(kwd("service :"))
+                .append(pp_actor(actor));
             let doc = defs.append(actor);
             doc.pretty(LINE_WIDTH).to_string()
         }

rust/candid/src/pretty/utils.rs

@@ -54,9 +54,8 @@ pub fn concat<'a, D>(docs: D, sep: &'a str) -> RcDoc<'a>
 where
     D: Iterator<Item = RcDoc<'a>> + Clone,
 {
-    RcDoc::intersperse(docs.clone().map(|d| d.append(sep)), RcDoc::line()).flat_alt(
-        RcDoc::intersperse(docs, RcDoc::text(sep).append(RcDoc::line())),
-    )
+    RcDoc::intersperse(docs.clone().map(|d| d.append(sep)), RcDoc::line())
+        .flat_alt(strict_concat(docs, sep))
 }
 
 pub fn lines<'a, D>(docs: D) -> RcDoc<'a>

rust/candid/src/ser.rs

@@ -304,7 +304,7 @@ impl TypeSerialize {
 
                 sleb128_encode(&mut buf, Opcode::Record as i64)?;
                 leb128_encode(&mut buf, fs.len() as u64)?;
-                for Field { id, ty } in fs {
+                for Field { id, ty, .. } in fs {
                     leb128_encode(&mut buf, u64::from(id.get_id()))?;
                     self.encode(&mut buf, ty)?;
                 }
@@ -316,7 +316,7 @@ impl TypeSerialize {
 
                 sleb128_encode(&mut buf, Opcode::Variant as i64)?;
                 leb128_encode(&mut buf, fs.len() as u64)?;
-                for Field { id, ty } in fs {
+                for Field { id, ty, .. } in fs {
                     leb128_encode(&mut buf, u64::from(id.get_id()))?;
                     self.encode(&mut buf, ty)?;
                 }

rust/candid/src/types/impls.rs

@@ -193,10 +193,12 @@ macro_rules! map_impl {
                     Field {
                         id: Label::Id(0).into(),
                         ty: K::ty(),
+                        comment: None,
                     },
                     Field {
                         id: Label::Id(1).into(),
                         ty: V::ty(),
+                        comment: None,
                     },
                 ]).into();
                 TypeInner::Vec(tuple).into()
@@ -276,10 +278,12 @@ where
             Field {
                 id: Label::Named("Ok".to_owned()).into(),
                 ty: T::ty(),
+                comment: None,
             },
             Field {
                 id: Label::Named("Err".to_owned()).into(),
                 ty: E::ty(),
+                comment: None,
             },
         ])
         .into()
@@ -470,7 +474,7 @@ macro_rules! tuple_impls {
             {
                 fn _ty() -> Type {
                     TypeInner::Record(vec![
-                        $(Field{ id: Label::Id($n).into(), ty: $name::ty() },)+
+                        $(Field{ id: Label::Id($n).into(), ty: $name::ty(), comment: None },)+
                     ]).into()
                 }
                 fn idl_serialize<S>(&self, serializer: S) -> Result<(), S::Error>
@@ -512,10 +516,12 @@ impl CandidType for std::time::SystemTime {
             Field {
                 id: Label::Named("nanos_since_epoch".to_owned()).into(),
                 ty: u32::ty(),
+                comment: None,
             },
             Field {
                 id: Label::Named("secs_since_epoch".to_owned()).into(),
                 ty: u64::ty(),
+                comment: None,
             },
         ])
         .into()
@@ -547,10 +553,12 @@ impl CandidType for std::time::Duration {
             Field {
                 id: Label::Named("secs".to_owned()).into(),
                 ty: u64::ty(),
+                comment: None,
             },
             Field {
                 id: Label::Named("nanos".to_owned()).into(),
                 ty: u32::ty(),
+                comment: None,
             },
         ])
         .into()