chore: fixes new clippy lints (dfinity#673)

christoph-dfinity · web-flow · commit 4767ae20164b · 2025-08-11T09:21:51.000+02:00
Looks like a recent bump of the Rust version on CI introduced new Clippy lints that make CI fail on dfinity#668 This PR fixes those lint errors on the `next` branch.
diff --git a/rust/candid/src/pretty/candid.rs b/rust/candid/src/pretty/candid.rs
@@ -71,15 +71,15 @@ fn ident_string(id: &str) -> String {
     }
 }
 
-pub fn pp_text(id: &str) -> RcDoc {
+pub fn pp_text(id: &str) -> RcDoc<'_> {
     RcDoc::text(ident_string(id))
 }
 
-pub fn pp_ty(ty: &Type) -> RcDoc {
+pub fn pp_ty(ty: &Type) -> RcDoc<'_> {
     pp_ty_inner(ty.as_ref())
 }
 
-pub fn pp_ty_inner(ty: &TypeInner) -> RcDoc {
+pub fn pp_ty_inner(ty: &TypeInner) -> RcDoc<'_> {
     use TypeInner::*;
     match ty {
         Null => str("null"),
@@ -130,18 +130,18 @@ pub fn pp_docs<'a>(docs: &'a [String]) -> RcDoc<'a> {
 /// This function is kept for backward compatibility.
 ///
 /// It is recommended to use [`pp_label_raw`] instead, which accepts a [`Label`].
-pub fn pp_label(id: &SharedLabel) -> RcDoc {
+pub fn pp_label(id: &SharedLabel) -> RcDoc<'_> {
     pp_label_raw(id.as_ref())
 }
 
-pub fn pp_label_raw(id: &Label) -> RcDoc {
+pub fn pp_label_raw(id: &Label) -> RcDoc<'_> {
     match id {
         Label::Named(id) => pp_text(id),
         Label::Id(_) | Label::Unnamed(_) => RcDoc::as_string(id),
     }
 }
 
-pub(crate) fn pp_field(field: &Field, is_variant: bool) -> RcDoc {
+pub(crate) fn pp_field(field: &Field, is_variant: bool) -> RcDoc<'_> {
     let ty_doc = if is_variant && *field.ty == TypeInner::Null {
         RcDoc::nil()
     } else {
@@ -150,12 +150,12 @@ pub(crate) fn pp_field(field: &Field, is_variant: bool) -> RcDoc {
     pp_label_raw(&field.id).append(ty_doc)
 }
 
-fn pp_fields(fs: &[Field], is_variant: bool) -> RcDoc {
+fn pp_fields(fs: &[Field], is_variant: bool) -> RcDoc<'_> {
     let fields = fs.iter().map(|f| pp_field(f, is_variant));
     enclose_space("{", concat(fields, ";"), "}")
 }
 
-pub fn pp_function(func: &Function) -> RcDoc {
+pub fn pp_function(func: &Function) -> RcDoc<'_> {
     let args = pp_named_args(&func.args);
     let rets = pp_rets(&func.rets);
     let modes = pp_modes(&func.modes);
@@ -168,7 +168,7 @@ pub fn pp_function(func: &Function) -> RcDoc {
 /// Pretty-prints named arguments in the form of `(name1 : type1, name2 : type2)`.
 ///
 /// To print unnamed arguments, use [`pp_args`] instead.
-pub fn pp_named_args(args: &[ArgType]) -> RcDoc {
+pub fn pp_named_args(args: &[ArgType]) -> RcDoc<'_> {
     let args = args.iter().map(|arg| {
         if let Some(name) = &arg.name {
             pp_text(name).append(kwd(" :")).append(pp_ty(&arg.typ))
@@ -183,24 +183,24 @@ pub fn pp_named_args(args: &[ArgType]) -> RcDoc {
 /// Pretty-prints arguments in the form of `(type1, type2)`.
 ///
 /// To print named arguments, use [`pp_named_args`] instead.
-pub fn pp_args(args: &[Type]) -> RcDoc {
+pub fn pp_args(args: &[Type]) -> RcDoc<'_> {
     let doc = concat(args.iter().map(pp_ty), ",");
     enclose("(", doc, ")")
 }
 
 /// Pretty-prints return types in the form of `(type1, type2)`.
-pub fn pp_rets(args: &[Type]) -> RcDoc {
+pub fn pp_rets(args: &[Type]) -> RcDoc<'_> {
     pp_args(args)
 }
 
-pub 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"),
         FuncMode::CompositeQuery => RcDoc::text("composite_query"),
     }
 }
-pub fn pp_modes(modes: &[FuncMode]) -> RcDoc {
+pub fn pp_modes(modes: &[FuncMode]) -> RcDoc<'_> {
     RcDoc::concat(modes.iter().map(|m| RcDoc::space().append(pp_mode(m))))
 }
 
@@ -223,7 +223,7 @@ fn pp_service<'a>(serv: &'a [(String, Type)], docs: Option<&'a DocComments>) ->
     enclose_space("{", doc, "}")
 }
 
-fn pp_defs(env: &TypeEnv) -> RcDoc {
+fn pp_defs(env: &TypeEnv) -> RcDoc<'_> {
     lines(env.to_sorted_iter().map(|(id, ty)| {
         kwd("type")
             .append(ident(id.as_str()))
@@ -523,7 +523,7 @@ pub mod value {
         }
     }
 
-    fn pp_field(depth: usize, field: &IDLField, is_variant: bool) -> RcDoc {
+    fn pp_field(depth: usize, field: &IDLField, is_variant: bool) -> RcDoc<'_> {
         let val_doc = if is_variant && field.val == IDLValue::Null {
             RcDoc::nil()
         } else {
@@ -532,7 +532,7 @@ pub mod value {
         pp_label_raw(&field.id).append(val_doc)
     }
 
-    fn pp_fields(depth: usize, fields: &[IDLField]) -> RcDoc {
+    fn pp_fields(depth: usize, fields: &[IDLField]) -> RcDoc<'_> {
         let fs = concat(fields.iter().map(|f| pp_field(depth, f, false)), ";");
         enclose_space("{", fs, "}")
     }
@@ -545,7 +545,7 @@ pub mod value {
             format!("\\{v:02x}")
         }
     }
-    pub fn pp_value(depth: usize, v: &IDLValue) -> RcDoc {
+    pub fn pp_value(depth: usize, v: &IDLValue) -> RcDoc<'_> {
         use IDLValue::*;
         if depth == 0 {
             return RcDoc::as_string(format!("{v:?}"));
@@ -579,7 +579,7 @@ pub mod value {
         }
     }
 
-    pub fn pp_args(args: &IDLArgs) -> RcDoc {
+    pub fn pp_args(args: &IDLArgs) -> RcDoc<'_> {
         let args = args
             .args
             .iter()
diff --git a/rust/candid/src/pretty/utils.rs b/rust/candid/src/pretty/utils.rs
@@ -71,19 +71,19 @@ where
     RcDoc::concat(docs.map(|doc| doc.append(RcDoc::hardline())))
 }
 
-pub fn kwd<U: std::fmt::Display + ?Sized>(str: &U) -> RcDoc {
+pub fn kwd<U: std::fmt::Display + ?Sized>(str: &U) -> RcDoc<'_> {
     RcDoc::as_string(str).append(RcDoc::space())
 }
 
-pub fn str(str: &str) -> RcDoc {
+pub fn str(str: &str) -> RcDoc<'_> {
     RcDoc::text(str)
 }
 
-pub fn ident(id: &str) -> RcDoc {
+pub fn ident(id: &str) -> RcDoc<'_> {
     kwd(id)
 }
 
-pub fn quote_ident(id: &str) -> RcDoc {
+pub fn quote_ident(id: &str) -> RcDoc<'_> {
     str("'")
         .append(format!("{}", id.escape_debug()))
         .append("'")
diff --git a/rust/candid_parser/src/bindings/javascript.rs b/rust/candid_parser/src/bindings/javascript.rs
@@ -91,15 +91,15 @@ static KEYWORDS: [&str; 64] = [
     "with",
     "yield",
 ];
-pub(crate) fn ident(id: &str) -> RcDoc {
+pub(crate) fn ident(id: &str) -> RcDoc<'_> {
     if KEYWORDS.contains(&id) {
         str(id).append("_")
     } else {
         str(id)
     }
 }
 
-fn pp_ty(ty: &Type) -> RcDoc {
+fn pp_ty(ty: &Type) -> RcDoc<'_> {
     use TypeInner::*;
     match ty.as_ref() {
         Null => str("IDL.Null"),
@@ -139,7 +139,7 @@ fn pp_ty(ty: &Type) -> RcDoc {
     }
 }
 
-fn pp_label(id: &SharedLabel) -> RcDoc {
+fn pp_label(id: &SharedLabel) -> RcDoc<'_> {
     match &**id {
         Label::Named(str) => quote_ident(str),
         Label::Id(n) | Label::Unnamed(n) => str("_")
@@ -149,36 +149,36 @@ fn pp_label(id: &SharedLabel) -> RcDoc {
     }
 }
 
-fn pp_field(field: &Field) -> RcDoc {
+fn pp_field(field: &Field) -> RcDoc<'_> {
     pp_label(&field.id)
         .append(kwd(":"))
         .append(pp_ty(&field.ty))
 }
 
-fn pp_fields(fs: &[Field]) -> RcDoc {
+fn pp_fields(fs: &[Field]) -> RcDoc<'_> {
     let fields = concat(fs.iter().map(pp_field), ",");
     enclose_space("({", fields, "})")
 }
 
-fn pp_function(func: &Function) -> RcDoc {
+fn pp_function(func: &Function) -> RcDoc<'_> {
     let args = pp_args(&func.args);
     let rets = pp_rets(&func.rets);
     let modes = pp_modes(&func.modes);
     let doc = concat([args, rets, modes].into_iter(), ",");
     enclose("(", doc, ")").nest(INDENT_SPACE)
 }
 
-fn pp_args(args: &[ArgType]) -> RcDoc {
+fn pp_args(args: &[ArgType]) -> RcDoc<'_> {
     let doc = concat(args.iter().map(|arg| pp_ty(&arg.typ)), ",");
     enclose("[", doc, "]")
 }
 
-fn pp_rets(args: &[Type]) -> RcDoc {
+fn pp_rets(args: &[Type]) -> RcDoc<'_> {
     let doc = concat(args.iter().map(pp_ty), ",");
     enclose("[", doc, "]")
 }
 
-fn pp_modes(modes: &[candid::types::FuncMode]) -> RcDoc {
+fn pp_modes(modes: &[candid::types::FuncMode]) -> RcDoc<'_> {
     let doc = concat(
         modes
             .iter()
@@ -188,7 +188,7 @@ fn pp_modes(modes: &[candid::types::FuncMode]) -> RcDoc {
     enclose("[", doc, "]")
 }
 
-fn pp_service(serv: &[(String, Type)]) -> RcDoc {
+fn pp_service(serv: &[(String, Type)]) -> RcDoc<'_> {
     let doc = concat(
         serv.iter()
             .map(|(id, func)| quote_ident(id).append(kwd(":")).append(pp_ty(func))),
@@ -298,7 +298,7 @@ pub mod value {
             _ => false,
         }
     }
-    fn pp_label(id: &Label) -> RcDoc {
+    fn pp_label(id: &Label) -> RcDoc<'_> {
         match id {
             Label::Named(str) => quote_ident(str),
             Label::Id(n) | Label::Unnamed(n) => str("_")
@@ -307,17 +307,17 @@ pub mod value {
                 .append(RcDoc::space()),
         }
     }
-    fn pp_field(field: &IDLField) -> RcDoc {
+    fn pp_field(field: &IDLField) -> RcDoc<'_> {
         pp_label(&field.id)
             .append(": ")
             .append(pp_value(&field.val))
     }
 
-    fn pp_fields(fields: &[IDLField]) -> RcDoc {
+    fn pp_fields(fields: &[IDLField]) -> RcDoc<'_> {
         concat(fields.iter().map(pp_field), ",")
     }
 
-    pub fn pp_value(v: &IDLValue) -> RcDoc {
+    pub fn pp_value(v: &IDLValue) -> RcDoc<'_> {
         use IDLValue::*;
         match v {
             Number(_) | Int(_) | Nat(_) | Int64(_) | Nat64(_) => {
@@ -362,7 +362,7 @@ pub mod value {
         }
     }
 
-    pub fn pp_args(args: &IDLArgs) -> RcDoc {
+    pub fn pp_args(args: &IDLArgs) -> RcDoc<'_> {
         let body = concat(args.args.iter().map(pp_value), ",");
         enclose("[", body, "]")
     }
diff --git a/rust/candid_parser/src/bindings/motoko.rs b/rust/candid_parser/src/bindings/motoko.rs
@@ -78,7 +78,7 @@ static KEYWORDS: [&str; 48] = [
     "while",
     "with",
 ];
-fn escape(id: &str, is_method: bool) -> RcDoc {
+fn escape(id: &str, is_method: bool) -> RcDoc<'_> {
     if KEYWORDS.contains(&id) {
         str(id).append("_")
     } else if is_valid_as_id(id) {
@@ -118,7 +118,7 @@ fn pp_ty_rich<'a>(ty: &'a Type, syntax: Option<&'a IDLType>) -> RcDoc<'a> {
     }
 }
 
-fn pp_ty(ty: &Type) -> RcDoc {
+fn pp_ty(ty: &Type) -> RcDoc<'_> {
     use TypeInner::*;
     match ty.as_ref() {
         Null => str("Null"),
@@ -151,7 +151,7 @@ fn pp_ty(ty: &Type) -> RcDoc {
     }
 }
 
-fn pp_label(id: &SharedLabel) -> RcDoc {
+fn pp_label(id: &SharedLabel) -> RcDoc<'_> {
     match &**id {
         Label::Named(str) => escape(str, false),
         Label::Id(n) | Label::Unnamed(n) => str("_")
@@ -161,7 +161,7 @@ fn pp_label(id: &SharedLabel) -> RcDoc {
     }
 }
 
-fn pp_function(func: &Function) -> RcDoc {
+fn pp_function(func: &Function) -> RcDoc<'_> {
     let args = pp_args(&func.args);
     let rets = pp_rets(&func.rets);
     match func.modes.as_slice() {
@@ -185,7 +185,7 @@ fn pp_function(func: &Function) -> RcDoc {
     }
     .nest(INDENT_SPACE)
 }
-fn pp_args(args: &[ArgType]) -> RcDoc {
+fn pp_args(args: &[ArgType]) -> RcDoc<'_> {
     match args {
         [ty] => {
             let typ = if is_tuple(&ty.typ) {
@@ -212,7 +212,7 @@ fn pp_args(args: &[ArgType]) -> RcDoc {
     }
 }
 
-fn pp_rets(args: &[Type]) -> RcDoc {
+fn pp_rets(args: &[Type]) -> RcDoc<'_> {
     match args {
         [ty] => {
             if is_tuple(ty) {
diff --git a/rust/candid_parser/src/bindings/rust.rs b/rust/candid_parser/src/bindings/rust.rs
@@ -131,7 +131,7 @@ static KEYWORDS: [&str; 51] = [
     "while", "async", "await", "dyn", "abstract", "become", "box", "do", "final", "macro",
     "override", "priv", "typeof", "unsized", "virtual", "yield", "try",
 ];
-fn ident_(id: &str, case: Option<Case>) -> (RcDoc, bool) {
+fn ident_(id: &str, case: Option<Case>) -> (RcDoc<'_>, bool) {
     if id.is_empty()
         || id.starts_with(|c: char| !c.is_ascii_alphabetic() && c != '_')
         || id.chars().any(|c| !c.is_ascii_alphanumeric() && c != '_')
@@ -152,7 +152,7 @@ fn ident_(id: &str, case: Option<Case>) -> (RcDoc, bool) {
         (RcDoc::text(id), is_rename)
     }
 }
-fn ident(id: &str, case: Option<Case>) -> RcDoc {
+fn ident(id: &str, case: Option<Case>) -> RcDoc<'_> {
     ident_(id, case).0
 }
 fn pp_vis<'a>(vis: &Option<String>) -> RcDoc<'a> {
@@ -1032,7 +1032,7 @@ impl<'b> NominalState<'_, 'b> {
                     if let Some(syntax) = syntax {
                         self.generated_types.insert(new_var.clone(), syntax);
                     }
-                    TypeInner::Var(new_var.into())
+                    TypeInner::Var(new_var)
                 }
             }
             TypeInner::Variant(fs) => {
@@ -1078,7 +1078,7 @@ impl<'b> NominalState<'_, 'b> {
                     if let Some(syntax) = syntax {
                         self.generated_types.insert(new_var.clone(), syntax);
                     }
-                    TypeInner::Var(new_var.into())
+                    TypeInner::Var(new_var)
                 }
             }
             TypeInner::Func(func) => match path.last() {
diff --git a/rust/candid_parser/src/bindings/typescript.rs b/rust/candid_parser/src/bindings/typescript.rs
@@ -99,7 +99,7 @@ fn pp_inline_service<'a>() -> RcDoc<'a> {
     str("Principal")
 }
 
-fn pp_label(id: &SharedLabel) -> RcDoc {
+fn pp_label(id: &SharedLabel) -> RcDoc<'_> {
     match &**id {
         Label::Named(str) => quote_ident(str),
         Label::Id(n) | Label::Unnamed(n) => str("_")
diff --git a/rust/candid_parser/src/syntax/pretty.rs b/rust/candid_parser/src/syntax/pretty.rs
diff --git a/rust/candid_parser/tests/value.rs b/rust/candid_parser/tests/value.rs
diff --git a/tools/didc-js/wasm-package/src/core.rs b/tools/didc-js/wasm-package/src/core.rs

Original file line number	Diff line number	Diff line change
`@@ -71,15 +71,15 @@ fn ident_string(id: &str) -> String {`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`-pub fn pp_text(id: &str) -> RcDoc {`
	`74`	`+pub fn pp_text(id: &str) -> RcDoc<'_> {`
`75`	`75`	`RcDoc::text(ident_string(id))`
`76`	`76`	`}`
`77`	`77`
`78`		`-pub fn pp_ty(ty: &Type) -> RcDoc {`
	`78`	`+pub fn pp_ty(ty: &Type) -> RcDoc<'_> {`
`79`	`79`	`pp_ty_inner(ty.as_ref())`
`80`	`80`	`}`
`81`	`81`
`82`		`-pub fn pp_ty_inner(ty: &TypeInner) -> RcDoc {`
	`82`	`+pub fn pp_ty_inner(ty: &TypeInner) -> RcDoc<'_> {`
`83`	`83`	`use TypeInner::*;`
`84`	`84`	`match ty {`
`85`	`85`	`Null => str("null"),`
`@@ -130,18 +130,18 @@ pub fn pp_docs<'a>(docs: &'a [String]) -> RcDoc<'a> {`
`130`	`130`	`/// This function is kept for backward compatibility.`
`131`	`131`	`///`
`132`	`132`	/// It is recommended to use [`pp_label_raw`] instead, which accepts a [`Label`].
`133`		`-pub fn pp_label(id: &SharedLabel) -> RcDoc {`
	`133`	`+pub fn pp_label(id: &SharedLabel) -> RcDoc<'_> {`
`134`	`134`	`pp_label_raw(id.as_ref())`
`135`	`135`	`}`
`136`	`136`
`137`		`-pub fn pp_label_raw(id: &Label) -> RcDoc {`
	`137`	`+pub fn pp_label_raw(id: &Label) -> RcDoc<'_> {`
`138`	`138`	`match id {`
`139`	`139`	`Label::Named(id) => pp_text(id),`
`140`	`140`	`Label::Id(_) \| Label::Unnamed(_) => RcDoc::as_string(id),`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`
`144`		`-pub(crate) fn pp_field(field: &Field, is_variant: bool) -> RcDoc {`
	`144`	`+pub(crate) fn pp_field(field: &Field, is_variant: bool) -> RcDoc<'_> {`
`145`	`145`	`let ty_doc = if is_variant && *field.ty == TypeInner::Null {`
`146`	`146`	`RcDoc::nil()`
`147`	`147`	`} else {`
`@@ -150,12 +150,12 @@ pub(crate) fn pp_field(field: &Field, is_variant: bool) -> RcDoc {`
`150`	`150`	`pp_label_raw(&field.id).append(ty_doc)`
`151`	`151`	`}`
`152`	`152`
`153`		`-fn pp_fields(fs: &[Field], is_variant: bool) -> RcDoc {`
	`153`	`+fn pp_fields(fs: &[Field], is_variant: bool) -> RcDoc<'_> {`
`154`	`154`	`let fields = fs.iter().map(\|f\| pp_field(f, is_variant));`
`155`	`155`	`enclose_space("{", concat(fields, ";"), "}")`
`156`	`156`	`}`
`157`	`157`
`158`		`-pub fn pp_function(func: &Function) -> RcDoc {`
	`158`	`+pub fn pp_function(func: &Function) -> RcDoc<'_> {`
`159`	`159`	`let args = pp_named_args(&func.args);`
`160`	`160`	`let rets = pp_rets(&func.rets);`
`161`	`161`	`let modes = pp_modes(&func.modes);`
`@@ -168,7 +168,7 @@ pub fn pp_function(func: &Function) -> RcDoc {`
`168`	`168`	/// Pretty-prints named arguments in the form of `(name1 : type1, name2 : type2)`.
`169`	`169`	`///`
`170`	`170`	/// To print unnamed arguments, use [`pp_args`] instead.
`171`		`-pub fn pp_named_args(args: &[ArgType]) -> RcDoc {`
	`171`	`+pub fn pp_named_args(args: &[ArgType]) -> RcDoc<'_> {`
`172`	`172`	`let args = args.iter().map(\|arg\| {`
`173`	`173`	`if let Some(name) = &arg.name {`
`174`	`174`	`pp_text(name).append(kwd(" :")).append(pp_ty(&arg.typ))`
`@@ -183,24 +183,24 @@ pub fn pp_named_args(args: &[ArgType]) -> RcDoc {`
`183`	`183`	/// Pretty-prints arguments in the form of `(type1, type2)`.
`184`	`184`	`///`
`185`	`185`	/// To print named arguments, use [`pp_named_args`] instead.
`186`		`-pub fn pp_args(args: &[Type]) -> RcDoc {`
	`186`	`+pub fn pp_args(args: &[Type]) -> RcDoc<'_> {`
`187`	`187`	`let doc = concat(args.iter().map(pp_ty), ",");`
`188`	`188`	`enclose("(", doc, ")")`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	/// Pretty-prints return types in the form of `(type1, type2)`.
`192`		`-pub fn pp_rets(args: &[Type]) -> RcDoc {`
	`192`	`+pub fn pp_rets(args: &[Type]) -> RcDoc<'_> {`
`193`	`193`	`pp_args(args)`
`194`	`194`	`}`
`195`	`195`
`196`		`-pub fn pp_mode(mode: &FuncMode) -> RcDoc {`
	`196`	`+pub fn pp_mode(mode: &FuncMode) -> RcDoc<'_> {`
`197`	`197`	`match mode {`
`198`	`198`	`FuncMode::Oneway => RcDoc::text("oneway"),`
`199`	`199`	`FuncMode::Query => RcDoc::text("query"),`
`200`	`200`	`FuncMode::CompositeQuery => RcDoc::text("composite_query"),`
`201`	`201`	`}`
`202`	`202`	`}`
`203`		`-pub fn pp_modes(modes: &[FuncMode]) -> RcDoc {`
	`203`	`+pub fn pp_modes(modes: &[FuncMode]) -> RcDoc<'_> {`
`204`	`204`	`RcDoc::concat(modes.iter().map(\|m\| RcDoc::space().append(pp_mode(m))))`
`205`	`205`	`}`
`206`	`206`
`@@ -223,7 +223,7 @@ fn pp_service<'a>(serv: &'a [(String, Type)], docs: Option<&'a DocComments>) ->`
`223`	`223`	`enclose_space("{", doc, "}")`
`224`	`224`	`}`
`225`	`225`
`226`		`-fn pp_defs(env: &TypeEnv) -> RcDoc {`
	`226`	`+fn pp_defs(env: &TypeEnv) -> RcDoc<'_> {`
`227`	`227`	`lines(env.to_sorted_iter().map(\|(id, ty)\| {`
`228`	`228`	`kwd("type")`
`229`	`229`	`.append(ident(id.as_str()))`
`@@ -523,7 +523,7 @@ pub mod value {`
`523`	`523`	`}`
`524`	`524`	`}`
`525`	`525`
`526`		`- fn pp_field(depth: usize, field: &IDLField, is_variant: bool) -> RcDoc {`
	`526`	`+ fn pp_field(depth: usize, field: &IDLField, is_variant: bool) -> RcDoc<'_> {`
`527`	`527`	`let val_doc = if is_variant && field.val == IDLValue::Null {`
`528`	`528`	`RcDoc::nil()`
`529`	`529`	`} else {`
`@@ -532,7 +532,7 @@ pub mod value {`
`532`	`532`	`pp_label_raw(&field.id).append(val_doc)`
`533`	`533`	`}`
`534`	`534`
`535`		`- fn pp_fields(depth: usize, fields: &[IDLField]) -> RcDoc {`
	`535`	`+ fn pp_fields(depth: usize, fields: &[IDLField]) -> RcDoc<'_> {`
`536`	`536`	`let fs = concat(fields.iter().map(\|f\| pp_field(depth, f, false)), ";");`
`537`	`537`	`enclose_space("{", fs, "}")`
`538`	`538`	`}`
`@@ -545,7 +545,7 @@ pub mod value {`
`545`	`545`	`format!("\\{v:02x}")`
`546`	`546`	`}`
`547`	`547`	`}`
`548`		`- pub fn pp_value(depth: usize, v: &IDLValue) -> RcDoc {`
	`548`	`+ pub fn pp_value(depth: usize, v: &IDLValue) -> RcDoc<'_> {`
`549`	`549`	`use IDLValue::*;`
`550`	`550`	`if depth == 0 {`
`551`	`551`	`return RcDoc::as_string(format!("{v:?}"));`
`@@ -579,7 +579,7 @@ pub mod value {`
`579`	`579`	`}`
`580`	`580`	`}`
`581`	`581`
`582`		`- pub fn pp_args(args: &IDLArgs) -> RcDoc {`
	`582`	`+ pub fn pp_args(args: &IDLArgs) -> RcDoc<'_> {`
`583`	`583`	`let args = args`
`584`	`584`	`.args`
`585`	`585`	`.iter()`
Original file line number	Diff line number	Diff line change
`@@ -71,19 +71,19 @@ where`
`71`	`71`	`RcDoc::concat(docs.map(\|doc\| doc.append(RcDoc::hardline())))`
`72`	`72`	`}`
`73`	`73`
`74`		`-pub fn kwd<U: std::fmt::Display + ?Sized>(str: &U) -> RcDoc {`
	`74`	`+pub fn kwd<U: std::fmt::Display + ?Sized>(str: &U) -> RcDoc<'_> {`
`75`	`75`	`RcDoc::as_string(str).append(RcDoc::space())`
`76`	`76`	`}`
`77`	`77`
`78`		`-pub fn str(str: &str) -> RcDoc {`
	`78`	`+pub fn str(str: &str) -> RcDoc<'_> {`
`79`	`79`	`RcDoc::text(str)`
`80`	`80`	`}`
`81`	`81`
`82`		`-pub fn ident(id: &str) -> RcDoc {`
	`82`	`+pub fn ident(id: &str) -> RcDoc<'_> {`
`83`	`83`	`kwd(id)`
`84`	`84`	`}`
`85`	`85`
`86`		`-pub fn quote_ident(id: &str) -> RcDoc {`
	`86`	`+pub fn quote_ident(id: &str) -> RcDoc<'_> {`
`87`	`87`	`str("'")`
`88`	`88`	`.append(format!("{}", id.escape_debug()))`
`89`	`89`	`.append("'")`
Original file line number	Diff line number	Diff line change
`@@ -91,15 +91,15 @@ static KEYWORDS: [&str; 64] = [`
`91`	`91`	`"with",`
`92`	`92`	`"yield",`
`93`	`93`	`];`
`94`		`-pub(crate) fn ident(id: &str) -> RcDoc {`
	`94`	`+pub(crate) fn ident(id: &str) -> RcDoc<'_> {`
`95`	`95`	`if KEYWORDS.contains(&id) {`
`96`	`96`	`str(id).append("_")`
`97`	`97`	`} else {`
`98`	`98`	`str(id)`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`-fn pp_ty(ty: &Type) -> RcDoc {`
	`102`	`+fn pp_ty(ty: &Type) -> RcDoc<'_> {`
`103`	`103`	`use TypeInner::*;`
`104`	`104`	`match ty.as_ref() {`
`105`	`105`	`Null => str("IDL.Null"),`
`@@ -139,7 +139,7 @@ fn pp_ty(ty: &Type) -> RcDoc {`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`142`		`-fn pp_label(id: &SharedLabel) -> RcDoc {`
	`142`	`+fn pp_label(id: &SharedLabel) -> RcDoc<'_> {`
`143`	`143`	`match &**id {`
`144`	`144`	`Label::Named(str) => quote_ident(str),`
`145`	`145`	`Label::Id(n) \| Label::Unnamed(n) => str("_")`
`@@ -149,36 +149,36 @@ fn pp_label(id: &SharedLabel) -> RcDoc {`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`		`-fn pp_field(field: &Field) -> RcDoc {`
	`152`	`+fn pp_field(field: &Field) -> RcDoc<'_> {`
`153`	`153`	`pp_label(&field.id)`
`154`	`154`	`.append(kwd(":"))`
`155`	`155`	`.append(pp_ty(&field.ty))`
`156`	`156`	`}`
`157`	`157`
`158`		`-fn pp_fields(fs: &[Field]) -> RcDoc {`
	`158`	`+fn pp_fields(fs: &[Field]) -> RcDoc<'_> {`
`159`	`159`	`let fields = concat(fs.iter().map(pp_field), ",");`
`160`	`160`	`enclose_space("({", fields, "})")`
`161`	`161`	`}`
`162`	`162`
`163`		`-fn pp_function(func: &Function) -> RcDoc {`
	`163`	`+fn pp_function(func: &Function) -> RcDoc<'_> {`
`164`	`164`	`let args = pp_args(&func.args);`
`165`	`165`	`let rets = pp_rets(&func.rets);`
`166`	`166`	`let modes = pp_modes(&func.modes);`
`167`	`167`	`let doc = concat([args, rets, modes].into_iter(), ",");`
`168`	`168`	`enclose("(", doc, ")").nest(INDENT_SPACE)`
`169`	`169`	`}`
`170`	`170`
`171`		`-fn pp_args(args: &[ArgType]) -> RcDoc {`
	`171`	`+fn pp_args(args: &[ArgType]) -> RcDoc<'_> {`
`172`	`172`	`let doc = concat(args.iter().map(\|arg\| pp_ty(&arg.typ)), ",");`
`173`	`173`	`enclose("[", doc, "]")`
`174`	`174`	`}`
`175`	`175`
`176`		`-fn pp_rets(args: &[Type]) -> RcDoc {`
	`176`	`+fn pp_rets(args: &[Type]) -> RcDoc<'_> {`
`177`	`177`	`let doc = concat(args.iter().map(pp_ty), ",");`
`178`	`178`	`enclose("[", doc, "]")`
`179`	`179`	`}`
`180`	`180`
`181`		`-fn pp_modes(modes: &[candid::types::FuncMode]) -> RcDoc {`
	`181`	`+fn pp_modes(modes: &[candid::types::FuncMode]) -> RcDoc<'_> {`
`182`	`182`	`let doc = concat(`
`183`	`183`	`modes`
`184`	`184`	`.iter()`
`@@ -188,7 +188,7 @@ fn pp_modes(modes: &[candid::types::FuncMode]) -> RcDoc {`
`188`	`188`	`enclose("[", doc, "]")`
`189`	`189`	`}`
`190`	`190`
`191`		`-fn pp_service(serv: &[(String, Type)]) -> RcDoc {`
	`191`	`+fn pp_service(serv: &[(String, Type)]) -> RcDoc<'_> {`
`192`	`192`	`let doc = concat(`
`193`	`193`	`serv.iter()`
`194`	`194`	`.map(\|(id, func)\| quote_ident(id).append(kwd(":")).append(pp_ty(func))),`
`@@ -298,7 +298,7 @@ pub mod value {`
`298`	`298`	`_ => false,`
`299`	`299`	`}`
`300`	`300`	`}`
`301`		`- fn pp_label(id: &Label) -> RcDoc {`
	`301`	`+ fn pp_label(id: &Label) -> RcDoc<'_> {`
`302`	`302`	`match id {`
`303`	`303`	`Label::Named(str) => quote_ident(str),`
`304`	`304`	`Label::Id(n) \| Label::Unnamed(n) => str("_")`
`@@ -307,17 +307,17 @@ pub mod value {`
`307`	`307`	`.append(RcDoc::space()),`
`308`	`308`	`}`
`309`	`309`	`}`
`310`		`- fn pp_field(field: &IDLField) -> RcDoc {`
	`310`	`+ fn pp_field(field: &IDLField) -> RcDoc<'_> {`
`311`	`311`	`pp_label(&field.id)`
`312`	`312`	`.append(": ")`
`313`	`313`	`.append(pp_value(&field.val))`
`314`	`314`	`}`
`315`	`315`
`316`		`- fn pp_fields(fields: &[IDLField]) -> RcDoc {`
	`316`	`+ fn pp_fields(fields: &[IDLField]) -> RcDoc<'_> {`
`317`	`317`	`concat(fields.iter().map(pp_field), ",")`
`318`	`318`	`}`
`319`	`319`
`320`		`- pub fn pp_value(v: &IDLValue) -> RcDoc {`
	`320`	`+ pub fn pp_value(v: &IDLValue) -> RcDoc<'_> {`
`321`	`321`	`use IDLValue::*;`
`322`	`322`	`match v {`
`323`	`323`	`Number(_) \| Int(_) \| Nat(_) \| Int64(_) \| Nat64(_) => {`
`@@ -362,7 +362,7 @@ pub mod value {`
`362`	`362`	`}`
`363`	`363`	`}`
`364`	`364`
`365`		`- pub fn pp_args(args: &IDLArgs) -> RcDoc {`
	`365`	`+ pub fn pp_args(args: &IDLArgs) -> RcDoc<'_> {`
`366`	`366`	`let body = concat(args.args.iter().map(pp_value), ",");`
`367`	`367`	`enclose("[", body, "]")`
`368`	`368`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ static KEYWORDS: [&str; 48] = [`
`78`	`78`	`"while",`
`79`	`79`	`"with",`
`80`	`80`	`];`
`81`		`-fn escape(id: &str, is_method: bool) -> RcDoc {`
	`81`	`+fn escape(id: &str, is_method: bool) -> RcDoc<'_> {`
`82`	`82`	`if KEYWORDS.contains(&id) {`
`83`	`83`	`str(id).append("_")`
`84`	`84`	`} else if is_valid_as_id(id) {`
`@@ -118,7 +118,7 @@ fn pp_ty_rich<'a>(ty: &'a Type, syntax: Option<&'a IDLType>) -> RcDoc<'a> {`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`121`		`-fn pp_ty(ty: &Type) -> RcDoc {`
	`121`	`+fn pp_ty(ty: &Type) -> RcDoc<'_> {`
`122`	`122`	`use TypeInner::*;`
`123`	`123`	`match ty.as_ref() {`
`124`	`124`	`Null => str("Null"),`
`@@ -151,7 +151,7 @@ fn pp_ty(ty: &Type) -> RcDoc {`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
`154`		`-fn pp_label(id: &SharedLabel) -> RcDoc {`
	`154`	`+fn pp_label(id: &SharedLabel) -> RcDoc<'_> {`
`155`	`155`	`match &**id {`
`156`	`156`	`Label::Named(str) => escape(str, false),`
`157`	`157`	`Label::Id(n) \| Label::Unnamed(n) => str("_")`
`@@ -161,7 +161,7 @@ fn pp_label(id: &SharedLabel) -> RcDoc {`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`164`		`-fn pp_function(func: &Function) -> RcDoc {`
	`164`	`+fn pp_function(func: &Function) -> RcDoc<'_> {`
`165`	`165`	`let args = pp_args(&func.args);`
`166`	`166`	`let rets = pp_rets(&func.rets);`
`167`	`167`	`match func.modes.as_slice() {`
`@@ -185,7 +185,7 @@ fn pp_function(func: &Function) -> RcDoc {`
`185`	`185`	`}`
`186`	`186`	`.nest(INDENT_SPACE)`
`187`	`187`	`}`
`188`		`-fn pp_args(args: &[ArgType]) -> RcDoc {`
	`188`	`+fn pp_args(args: &[ArgType]) -> RcDoc<'_> {`
`189`	`189`	`match args {`
`190`	`190`	`[ty] => {`
`191`	`191`	`let typ = if is_tuple(&ty.typ) {`
`@@ -212,7 +212,7 @@ fn pp_args(args: &[ArgType]) -> RcDoc {`
`212`	`212`	`}`
`213`	`213`	`}`
`214`	`214`
`215`		`-fn pp_rets(args: &[Type]) -> RcDoc {`
	`215`	`+fn pp_rets(args: &[Type]) -> RcDoc<'_> {`
`216`	`216`	`match args {`
`217`	`217`	`[ty] => {`
`218`	`218`	`if is_tuple(ty) {`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ static KEYWORDS: [&str; 51] = [`
`131`	`131`	`"while", "async", "await", "dyn", "abstract", "become", "box", "do", "final", "macro",`
`132`	`132`	`"override", "priv", "typeof", "unsized", "virtual", "yield", "try",`
`133`	`133`	`];`
`134`		`-fn ident_(id: &str, case: Option<Case>) -> (RcDoc, bool) {`
	`134`	`+fn ident_(id: &str, case: Option<Case>) -> (RcDoc<'_>, bool) {`
`135`	`135`	`if id.is_empty()`
`136`	`136`	`\|\| id.starts_with(\|c: char\| !c.is_ascii_alphabetic() && c != '_')`
`137`	`137`	`\|\| id.chars().any(\|c\| !c.is_ascii_alphanumeric() && c != '_')`
`@@ -152,7 +152,7 @@ fn ident_(id: &str, case: Option<Case>) -> (RcDoc, bool) {`
`152`	`152`	`(RcDoc::text(id), is_rename)`
`153`	`153`	`}`
`154`	`154`	`}`
`155`		`-fn ident(id: &str, case: Option<Case>) -> RcDoc {`
	`155`	`+fn ident(id: &str, case: Option<Case>) -> RcDoc<'_> {`
`156`	`156`	`ident_(id, case).0`
`157`	`157`	`}`
`158`	`158`	`fn pp_vis<'a>(vis: &Option<String>) -> RcDoc<'a> {`
`@@ -1032,7 +1032,7 @@ impl<'b> NominalState<'_, 'b> {`
`1032`	`1032`	`if let Some(syntax) = syntax {`
`1033`	`1033`	`self.generated_types.insert(new_var.clone(), syntax);`
`1034`	`1034`	`}`
`1035`		`- TypeInner::Var(new_var.into())`
	`1035`	`+ TypeInner::Var(new_var)`
`1036`	`1036`	`}`
`1037`	`1037`	`}`
`1038`	`1038`	`TypeInner::Variant(fs) => {`
`@@ -1078,7 +1078,7 @@ impl<'b> NominalState<'_, 'b> {`
`1078`	`1078`	`if let Some(syntax) = syntax {`
`1079`	`1079`	`self.generated_types.insert(new_var.clone(), syntax);`
`1080`	`1080`	`}`
`1081`		`- TypeInner::Var(new_var.into())`
	`1081`	`+ TypeInner::Var(new_var)`
`1082`	`1082`	`}`
`1083`	`1083`	`}`
`1084`	`1084`	`TypeInner::Func(func) => match path.last() {`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ fn pp_inline_service<'a>() -> RcDoc<'a> {`
`99`	`99`	`str("Principal")`
`100`	`100`	`}`
`101`	`101`
`102`		`-fn pp_label(id: &SharedLabel) -> RcDoc {`
	`102`	`+fn pp_label(id: &SharedLabel) -> RcDoc<'_> {`
`103`	`103`	`match &**id {`
`104`	`104`	`Label::Named(str) => quote_ident(str),`
`105`	`105`	`Label::Id(n) \| Label::Unnamed(n) => str("_")`