async_codegen/rust/
mod.rs

1/*
2 * Copyright © 2025 Anand Beh
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//!
18//! Rust syntax elements.
19//!
20//! Note that no checking exists to make sure the elements are used correctly, i.e. the correct
21//! combination of structs. Instead, the library user is expected to have basic knowledge of how
22//! Rust syntax is composed, and to combine the structs in this module likewise.
23//!
24//! Example:
25//!
26//! ```
27//! # use async_codegen::common::{CombinedSeq, NoOpSeq, SingularSeq, Str};
28//! # use async_codegen::{Output, Writable};
29//! # use async_codegen::rust::{CanHaveAttributes, CfgAttr, Deprecated, FunctionBodyImplement, FunctionDef, FunctionParam, ModPub, MustUse, NoMangle, Parameterized};
30//!
31//! async fn write_function<O>(output: &mut O) -> Result<(), O::Error> where O: Output {
32//!   // For more advanced usage, you can replace Str("") by other Writable implementations
33//!   let function_def = FunctionDef {
34//!     mods: SingularSeq(ModPub),
35//!     name: Str("my_func"),
36//!     args: CombinedSeq(
37//!      SingularSeq(FunctionParam(Str("var1"), Str("Type"))),
38//!      SingularSeq(FunctionParam(Str("var2"), Parameterized(Str("Option"), SingularSeq(Str("bool")))))
39//!     ),
40//!     return_type: Parameterized(Str("Box"), SingularSeq(Str("str"))),
41//!     where_conds: NoOpSeq,
42//!     body: FunctionBodyImplement(Str("todo!()"))
43//!   };
44//!   function_def.write_to(output).await
45//!   // Will render as:
46//!   /*
47//!   pub fn my_func(var1: Type, var2: Option<bool>) -> Box<str> {
48//!     todo!()
49//!   }
50//!    */
51//! }
52//! ```
53//!
54
55use crate::common::{Combined, NoOp, NoOpSeq, Str, SurroundingSeqAccept};
56use crate::{Output, SequenceAccept, Writable};
57use std::fmt::Debug;
58
59mod syntax;
60#[cfg(test)]
61mod tests;
62
63/// All possible Rust editions.
64/// This is the only type in this module meant to be used as context, and not as a writable itself.
65#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
66#[non_exhaustive]
67pub enum Edition {
68    /// This Rust edition is declared for usability purposes. However, not all [crate::Writable]
69    /// implementations are guaranteed to work with it.
70    Rust2015,
71    Rust2018,
72    Rust2021,
73    Rust2024,
74}
75
76/// Imports a single type so that it can be used later.
77/// Renders as `use Type;`. Adds a new line after the semicolon.
78#[derive(Clone, Debug)]
79pub struct UseType<Type>(pub Type);
80
81/// An attribute enabled conditionally, i.e. `#[cfg_attr(Cond, Attr)]`
82#[derive(Clone, Debug)]
83pub struct CfgAttr<Cond, Attr>(pub Cond, pub Attr);
84
85/// A cfg attribute. Renders as `cfg(Cond)`.
86#[derive(Clone, Debug)]
87pub struct Cfg<Cond>(pub Cond);
88
89/// A cfg condition for targeting an OS, OS family, or architecture. For example:
90/// ```
91/// # use async_codegen::common::{NoOpSeq, SingularSeq, Str};
92/// # use async_codegen::context::EmptyContext;
93/// # use async_codegen::rust::{FunctionBodyDeclare, Cfg, FunctionDef, Target, CanHaveAttributes};
94/// # use async_codegen::util::InMemoryOutput;
95/// let function = FunctionDef {
96///   mods: NoOpSeq,
97///   name: Str("conditional_func"),
98///   args: NoOpSeq,
99///   return_type: Str("()"),
100///   where_conds: NoOpSeq,
101///   body: FunctionBodyDeclare
102/// }.with_attributes(
103///   SingularSeq(Cfg(Target::Os(Str("linux"))))
104/// );
105/// let string = InMemoryOutput::print_output(EmptyContext, &function);
106/// assert_eq!("#[cfg(target_os = \"linux\")]\nfn conditional_func() -> ();\n", string);
107/// ```
108#[derive(Clone, Debug)]
109pub enum Target<Value> {
110    Os(Value),
111    Family(Value),
112    Arch(Value),
113}
114
115/// The link attribute.
116#[derive(Clone, Debug)]
117pub struct Link<Arg>(pub Arg);
118
119/// The no mangle attribute.
120///
121/// Requires that the context satisfies [ContextProvides] for [Edition], because in Rust 2024 and
122/// beyond, the no-mangle attribute is an unsafe attribute.
123#[derive(Clone, Debug)]
124pub struct NoMangle;
125
126/// The attribute content for `allow(...)`. The tuple value must be a sequence.
127#[derive(Clone, Debug)]
128pub struct AllowLints<Lints>(pub Lints);
129
130/// The deprecated attribute. The three variants of this enum correspond to the deprecated
131/// attribute's multiple ways of being specified. See:
132/// https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-deprecated-attribute
133#[derive(Clone, Debug)]
134pub enum Deprecated<Msg, Since = NoOp> {
135    Basic,
136    Message(Msg),
137    Full { since: Since, note: Msg },
138}
139
140impl Default for Deprecated<NoOp, NoOp> {
141    fn default() -> Self {
142        Self::Basic
143    }
144}
145
146impl Deprecated<NoOp, NoOp> {
147    pub fn basic() -> Self {
148        Self::Basic
149    }
150}
151
152impl<Msg> Deprecated<Msg> {
153    pub fn with_message(msg: Msg) -> Self {
154        Self::Message(msg)
155    }
156}
157
158/// The must_use attribute
159#[derive(Clone, Debug)]
160pub struct MustUse;
161
162/// The public modifier
163#[derive(Clone, Debug)]
164pub struct ModPub;
165
166/// The unsafe modifier
167#[derive(Clone, Debug)]
168pub struct ModUnsafe;
169
170/// The extern modifier, with the ABI selected as the tuple value.
171///
172/// This struct includes `unsafe`. Since Rust 2024, the unsafe keyword is required for extern
173/// functions, and before Rust 2024 it is optional. To make it easy to generate code targeting
174/// multiple editions, we unconditionally emit the "unsafe" keyword alongside "extern".
175#[derive(Clone, Debug)]
176pub struct ModUnsafeExtern<Abi>(pub Abi);
177
178/// A standalone statement. Renders the expression and adds a semicolon and a new line.
179#[derive(Clone, Debug)]
180pub struct Stmt<Expr>(pub Expr);
181
182/// A let statement. This statement includes the semicolon and a new line.
183#[derive(Clone, Debug)]
184pub struct LetStmt<Variable, Expr>(pub Variable, pub Expr);
185
186/// An assignation. This statement includes the semicolon and a new line.
187#[derive(Clone, Debug)]
188pub struct AssignStmt<Variable, Expr>(pub Variable, pub Expr);
189
190/// A return statement. Renders as `return Expr;` with a new line at the end.
191#[derive(Clone, Debug)]
192pub struct ReturnStmt<Expr>(pub Expr);
193
194/// A let expression.
195/// This can be used, for example, as the condition of [IfBlock] in order to create an "if-let" block.
196#[derive(Clone, Debug)]
197pub struct LetExpr<Pattern, Expr>(pub Pattern, pub Expr);
198
199/// An array literal with predefined elements written out.
200/// Renders as `[E1, E2, E3, ...]` where EX is in the element sequence.
201#[derive(Clone, Debug)]
202pub struct ArrayFromElements<Elements>(pub Elements);
203
204/// An item attached to an associated container, via "::".
205/// The output will look like `Cont::Item`.
206#[derive(Clone, Debug)]
207pub struct AssociatedItem<Cont, Item>(pub Cont, pub Item);
208
209/// A question mark following another expression.
210#[derive(Clone, Debug)]
211pub struct QuestionMarkAfter<Expr>(pub Expr);
212
213/// Wraps an expression in `Ok(EXPR)`.
214#[derive(Clone, Debug)]
215pub struct OkResultOf<Expr>(pub Expr);
216
217/// Uses the `as` expression to perform a qualified trait cast (ready for a method call).
218/// I.e., this will render as `<Type as Trait>`.
219#[derive(Clone, Debug)]
220pub struct TypeAsTrait<Type, Trait>(pub Type, pub Trait);
221
222/// Declaration of an extern block, i.e. for FFI.
223/// In Rust 2024 and later, the unsafe keyword must be added for extern blocks. Thus, this struct
224/// requires that the context satisfies [ContextProvides] for [Edition].
225#[derive(Clone, Debug)]
226pub struct ExternBlock<Abi, Body> {
227    /// The ABI chosen. Must be writable
228    pub abi: Abi,
229    /// The body of the extern block. Must be writable
230    pub body: Body,
231}
232
233impl<Abi, Body> CanHaveAttributes for ExternBlock<Abi, Body> {
234    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self> {
235        WithAttributes {
236            attr,
237            separator: "\n",
238            value: self,
239        }
240    }
241}
242
243/// Declaration of a module block. Renders as `mod Mod {Body}`.
244#[derive(Clone, Debug)]
245pub struct ModBlock<Name, Body> {
246    /// The module name
247    pub name: Name,
248    /// The body. Must be writable
249    pub body: Body,
250}
251
252/// An if block. The condition and body must both be writable.
253#[derive(Clone, Debug)]
254pub struct IfBlock<Cond, Body>(pub Cond, pub Body);
255
256/// Represents "else" syntactically. Renders as `Before else After`.
257///
258/// This struct requires you to specify what comes before and after the else. For example:
259/// ```
260/// # use async_codegen::common::Str;
261/// # use async_codegen::context::EmptyContext;
262/// # use async_codegen::rust::{Block, Else, IfBlock};
263/// # use async_codegen::util::InMemoryOutput;
264///
265/// let if_block = IfBlock(Str("true"), Str("log::info(\"Hello\")"));
266/// let else_block = Block(Str("panic!()"));
267/// let if_else = Else(if_block, else_block);
268///
269/// let string = InMemoryOutput::print_output(EmptyContext, &if_else);
270/// assert_eq!("if true {\nlog::info(\"Hello\")\n} else {\npanic!()\n}", string)
271/// ```
272#[derive(Clone, Debug)]
273pub struct Else<Before, After>(pub Before, pub After);
274
275/// An unlabeled block.
276/// This can be used in many contexts, including merely organizing the code.
277#[derive(Clone, Debug)]
278pub struct Block<Body>(pub Body);
279
280/// Places the expression inside an unsafe block.
281/// Adds new lines inside the brackets, wrapping the inner expression.
282#[derive(Clone, Debug)]
283pub struct UnsafeBlock<Expr>(pub Expr);
284
285/// Writes a closure.
286/// Adds new lines inside the brackets, wrapping the inner expression.
287#[derive(Clone, Debug)]
288pub struct Closure<InputVars, Expr> {
289    /// The input variables.
290    /// Should be a sequence. They will be comma separated and placed within the pipes.
291    /// To use no input variables, use [NoOpSeq].
292    pub input_vars: InputVars,
293    /// The expression inside the closure block.
294    pub inside_block: Expr,
295}
296
297/// Performs a call to a function inside code.
298#[derive(Clone, Debug)]
299pub struct FunctionCall<Recv, Name, Args> {
300    /// The function receiver
301    pub receiver: Recv,
302    /// Whether the function is associated, false if it's a method
303    pub is_assoc: bool,
304    /// The function name
305    pub name: Name,
306    /// The arguments. Must be a sequence
307    pub args: Args,
308}
309
310/// Provides access to the "turbofish" syntax, i.e. `Name::<Args>`.
311/// The first tuple value must be writable, and the second must be a sequence.
312///
313/// Note that if the sequence outputs nothing, this struct will behave as if no args were
314/// specified. I.e. `Turbofish(Name, NoOpSeq)` is equivalent to just `Name`.
315#[derive(Clone, Debug)]
316pub struct Turbofish<Name, Args>(pub Name, pub Args);
317
318/// A function declaration
319#[derive(Clone, Debug)]
320pub struct FunctionDef<Mods, Name, Args, Return, Where, Body> {
321    /// The modifiers. Must be a sequence.
322    pub mods: Mods,
323    /// The function name. Type variables can be declared here via [Parameterized]
324    pub name: Name,
325    /// The arguments. Must be a sequence
326    pub args: Args,
327    /// The return type, i.e. after the `->` arrow
328    pub return_type: Return,
329    /// The "where" conditions. Must be a sequence. Set to [NoOp] to disable.
330    /// Will render as `where C1, C2, C3, ...` where CX is a value in the sequence.
331    pub where_conds: Where,
332    /// The function body.
333    /// To only declare the function, this must be `;` so use [FunctionBodyDeclare]
334    /// To implement the function, use [FunctionBodyImplement]
335    pub body: Body,
336}
337
338impl<Mods, Name, Args, Return, Where, Body> CanHaveAttributes
339    for FunctionDef<Mods, Name, Args, Return, Where, Body>
340{
341    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self> {
342        WithAttributes {
343            attr,
344            separator: "\n",
345            value: self,
346        }
347    }
348}
349
350/// Declares a function body. This is equivalent to just a semicolon.
351#[derive(Clone, Debug)]
352pub struct FunctionBodyDeclare;
353
354/// Implements a function body. Places the contents inside brackets
355#[derive(Clone, Debug)]
356pub struct FunctionBodyImplement<Inner>(pub Inner);
357
358/// A function pointer. Can be used for `fn`, `Fn`, `FnMut`, and `FnOnce`.
359///
360/// Example:
361/// ```
362/// # use async_codegen::common::{SingularSeq, Str};
363/// # use async_codegen::context::EmptyContext;
364/// # use async_codegen::rust::{FunctionPtr, FunctionPtrKind};
365/// # use async_codegen::util::InMemoryOutput;
366/// let function_ptr = FunctionPtr {
367///   kind: FunctionPtrKind::FnMut,
368///   args: SingularSeq(Str("String")),
369///   return_type: Str("bool")
370/// };
371/// let string = InMemoryOutput::print_output(EmptyContext, &function_ptr);
372/// assert_eq!("FnMut(String) -> bool", string);
373/// ```
374#[derive(Clone, Debug)]
375pub struct FunctionPtr<Args, Return> {
376    /// The function pointer kind
377    pub kind: FunctionPtrKind,
378    /// The arguments. Must be a sequence
379    pub args: Args,
380    /// The return type, i.e. after the `->` arrow
381    pub return_type: Return,
382}
383
384/// The kind of function type
385#[derive(Clone, Debug)]
386pub enum FunctionPtrKind {
387    /// An `fn` pointer. E.g. `fn(String) -> bool`.
388    FnPtr,
389    /// Represents [Fn]
390    Fn,
391    /// Represents [FnMut]
392    FnMut,
393    /// Represents [FnOnce]
394    FnOnce,
395}
396
397/// Renders as `Type=Value`. Intended to be used as a type argument, to specify associated types.
398#[derive(Clone, Debug)]
399pub struct AssociatedTypeEquals<Type, Value>(pub Type, pub Value);
400
401/// Adds a "dyn " before a type expression.
402#[derive(Clone, Debug)]
403pub struct DynOf<Type>(pub Type);
404
405/// Adds a "&" before a type expression
406#[derive(Clone, Debug)]
407pub struct RefOf<Type>(pub Type);
408
409/// Adds an "impl " before a type expression
410pub struct ImplOf<Type>(pub Type);
411
412/// Adds a reference with a lifetime before a type expression, i.e. `&'<lifetime> <type>`
413#[derive(Clone, Debug)]
414pub struct LifetimedRefOf<'l, Type>(pub &'l str, pub Type);
415
416/// Declares an associated type, rendering as `type VarName = Value;`.
417/// Adds new lines before and after.
418#[derive(Clone, Debug)]
419pub struct AssociatedTypeDef<VarName, Value>(pub VarName, pub Value);
420
421/// The declaration of a trait
422#[derive(Clone, Debug)]
423pub struct TraitDef<Mods, Name, TypeVars, SuperTraits, Body> {
424    /// The trait modifiers, e.g. visibility. Must be a sequence.
425    pub mods: Mods,
426    /// The name of the trait
427    pub name: Name,
428    /// The type variables. Must be a sequence
429    pub type_variables: TypeVars,
430    /// The super traits. Must be a sequence
431    pub super_traits: SuperTraits,
432    /// The trait definition's body. Use [NoOp] if none exists.
433    pub body: Body,
434}
435
436impl<Mods, Name, TypeVars, SuperTraits, Body> CanHaveAttributes
437    for TraitDef<Mods, Name, TypeVars, SuperTraits, Body>
438{
439    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self> {
440        WithAttributes {
441            attr,
442            separator: "\n",
443            value: self,
444        }
445    }
446}
447
448/// The implementation declaration for a trait, applying to a certain receiver.
449#[derive(Clone, Debug)]
450pub struct TraitImpl<Mods, TypeVars, Trait, Recv, Where, Body> {
451    /// The modifiers on the `impl` block.
452    /// Set to [NoOpSeq] for none, or use `SingularSeq(ModUnsafe)` to generate an `unsafe impl`.
453    pub mods: Mods,
454    /// The type variables to use for the impl block itself. All type variables that appear later
455    /// on the trait or the receiver must be declared here, per Rust language rules.
456    ///
457    /// This field must be a sequence.
458    pub type_variables: TypeVars,
459    /// The trait being implemented
460    pub the_trait: Trait,
461    /// The receiver for which it is implemented
462    pub receiver: Recv,
463    /// The "where" conditions. Must be a sequence. Set to [NoOpSeq] to disable.
464    /// Will render as `where C1, C2, C3, ...` where CX is a value in the sequence.
465    pub where_conds: Where,
466    /// The body. Use [NoOp] if none exists.
467    pub body: Body,
468}
469
470impl<Mods, TypeVars, Trait, Recv, Where, Body> CanHaveAttributes
471    for TraitImpl<Mods, TypeVars, Trait, Recv, Where, Body>
472{
473    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self> {
474        WithAttributes {
475            attr,
476            separator: "\n",
477            value: self,
478        }
479    }
480}
481
482/// The declaration of a struct.
483#[derive(Clone, Debug)]
484pub struct StructDef<Mods, Name, Elements> {
485    /// The struct modifiers. Must be a sequence.
486    pub mods: Mods,
487    /// The kind of the struct.
488    ///
489    /// It is suggested to use either a [NamedTuple] or [StructCall]. A semicolon will be
490    /// automatically added afterward, as is needed for tuple structs, and this semicolon will not
491    /// affect structs with named fields.
492    pub kind: StructKind<Name, Elements>,
493}
494
495impl<Mods, Name, Elements> CanHaveAttributes for StructDef<Mods, Name, Elements> {
496    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self> {
497        WithAttributes {
498            attr,
499            separator: "\n",
500            value: self,
501        }
502    }
503}
504
505/// Completes the struct definition as either a named tuple or a struct with named fields.
506#[derive(Clone, Debug)]
507pub enum StructKind<Name, Elements> {
508    /// A named tuple. This will function similarly to [NamedTuple], except a semicolon will
509    /// be added afterward.
510    ///
511    /// `Name` must be writable, and `Elements` must be a writable sequence for the tuple arguments.
512    Tuple(Name, Elements),
513    /// A struct with named fields. This will function similarly to [StructCall].
514    ///
515    /// `Name` must be writable, and `Elements` must be writable sequence for the struct fields.
516    NamedFields(Name, Elements),
517}
518
519/// The construction or deconstruction of a struct.
520///
521/// When rendered, will use the format `Name { Body }`. Spaces will be added automatically.
522///
523/// This should **not** be used for tuple structs, for that see [NamedTuple].
524#[derive(Clone, Debug)]
525pub struct StructCall<Name, Body> {
526    /// The struct name. Must be writable.
527    ///
528    /// If you are declaring a struct for the first time, you can use [Parameterized] in order
529    /// to declare type variables.
530    pub name: Name,
531    /// The body. Must be writable.
532    ///
533    /// It is suggested to use [StructFields] for multiple fields, or [DeclareField] for just one.
534    pub body: Body,
535}
536
537/// Named struct fields. This will place every field on a new line with a comma afterward.
538/// It is recommended that the sequence should pass [DeclareField].
539///
540/// If you have a single field, you can skip using a sequence and just use [DeclareField] directly.
541pub struct StructFields<Fields>(pub Fields);
542
543/// Declares a single field within a struct. Renders as `Name: Value`.
544///
545/// Does not add attributes. If you want to use attributes for declaration purposes, you can use
546/// [CanHaveAttributes::with_attributes] on this field.
547pub struct DeclareField<Name, Value>(pub Name, pub Value);
548
549impl<Name, Value> CanHaveAttributes for DeclareField<Name, Value> {
550    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self> {
551        WithAttributes {
552            attr,
553            separator: "\n",
554            value: self,
555        }
556    }
557}
558
559/// A named tuple type.
560///
561/// Renders as `Name(A1, A2, A3, ...)` where AX is part of the argument sequence.
562/// If no arguments exist, will render only as `Name` (i.e., a unit struct).
563pub struct NamedTuple<Name, Args> {
564    pub name: Name,
565    pub args: Args,
566}
567
568/// An anonymous tuple type. This struct's tuple value must be a sequence.
569///
570/// Renders as `(A1, A2, A3, ...)` where AX is part of the argument sequence.
571#[derive(Clone, Debug)]
572pub struct AnonTuple<Args>(pub Args);
573
574/// The unit type, i.e. `()`
575pub type UnitType = AnonTuple<NoOpSeq>;
576
577impl AnonTuple<NoOpSeq> {
578    /// Creates
579    pub fn unit() -> Self {
580        Self(NoOpSeq)
581    }
582}
583
584/// Adds attributes to ANY item.
585///
586/// The first tuple value must be a sequence. The second must be a writable value. This struct
587/// is typically constructed via [CanHaveAttributes::with_attributes].
588///
589/// Rust attributes can be put in many places, so this enables you to add attributes to any
590/// writable item. For example, adding attributes to function parameters can be done like so:
591///
592/// ```rust
593/// # use async_codegen::common::{SingularSeq, Str};
594/// # use async_codegen::context::EmptyContext;
595/// # use async_codegen::rust::{Cfg, FunctionParam, MustUse, Target, WithAttributes, CanHaveAttributes};
596/// # use async_codegen::util::InMemoryOutput;
597///
598/// let function_param = FunctionParam(Str("conditional_param"), Str("Fd")).with_attributes(
599///   SingularSeq(Cfg(Target::Os(Str("linux"))))
600/// );
601/// let string = InMemoryOutput::print_output(EmptyContext, &function_param);
602/// assert_eq!("#[cfg(target_os = \"linux\")] conditional_param: Fd", string);
603/// ```
604#[derive(Clone, Debug)]
605pub struct WithAttributes<Attr, Value> {
606    pub attr: Attr,
607    /// The separator. Usually a space or a new line, depending on what the target value is
608    pub separator: &'static str,
609    /// The value
610    pub value: Value,
611}
612
613/// A writable that can have attributes attached to it
614pub trait CanHaveAttributes: Sized {
615    /// Adds attributes to this writable
616    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self>;
617}
618
619/// Defines an enum.
620///
621/// In order to use or refer to an enum, you can use [AssociatedItem] together with [NamedTuple]
622/// or [StructCall].
623pub struct EnumDef<Mods, Name, Entries> {
624    /// The modifiers on the type. Must be a sequence.
625    pub mods: Mods,
626    /// The name of the enum
627    pub name: Name,
628    /// The enum entries. Must be a sequence, each entry will be written on a new line with a comma
629    ///
630    /// As for the entries themselves, it is suggested to use [NamedTuple] or [StructCall]
631    /// depending on which kind of enum entry you want to create.
632    pub entries: Entries,
633}
634
635impl<Mods, Name, Entries> CanHaveAttributes for EnumDef<Mods, Name, Entries> {
636    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self> {
637        WithAttributes {
638            attr,
639            separator: "\n",
640            value: self,
641        }
642    }
643}
644
645/// A type argument-parameterized expression. Used in relation to parameterized names and their
646/// arguments. Examples: `function_name<args>`, `TypeName<'lifetime, args>`, `MyType<Assoc=Value>`.
647///
648/// If no type args exist, [NoOpSeq] should be used. In any case, the second tuple value of this
649/// struct must be a sequence.
650#[derive(Clone, Debug)]
651pub struct Parameterized<Name, TypeArgs>(pub Name, pub TypeArgs);
652
653/// A type variable with a sequence of bounds.
654/// Will render as `TypeVar: B1 + B2 + ...`
655#[derive(Clone, Debug)]
656pub struct BoundedTypeVar<TypeVar, Bounds>(pub TypeVar, pub Bounds);
657
658/// A standalone lifetime, intended to be used as a type argument or variable
659#[derive(Clone, Debug)]
660pub struct Lifetime<'l>(pub &'l str);
661
662/// Renders an individual function parameter, `Name: Type`
663#[derive(Clone, Debug)]
664pub struct FunctionParam<Name, Type>(pub Name, pub Type);
665
666impl<Name, Type> CanHaveAttributes for FunctionParam<Name, Type> {
667    fn with_attributes<Attr>(self, attr: Attr) -> WithAttributes<Attr, Self> {
668        WithAttributes {
669            attr,
670            separator: " ",
671            value: self,
672        }
673    }
674}
675
676/// A sequence acceptor that writes attributes. Every attribute will be surrounded with "#[]"
677#[derive(Debug)]
678pub struct AttributesAccept<'o, O, Sep> {
679    inner: SurroundingSeqAccept<'o, O, Str<&'static str>, Combined<Str<&'static str>, Sep>>,
680}
681
682impl<'o, O> AttributesAccept<'o, O, Str<&'static str>> {
683    pub fn multiline(output: &'o mut O) -> Self {
684        Self::with_separator(output, "\n")
685    }
686}
687
688impl<'o, O> AttributesAccept<'o, O, Str<&'static str>> {
689    pub fn with_separator(output: &'o mut O, separator: &'static str) -> Self {
690        Self {
691            inner: SurroundingSeqAccept::new(output, Str("#["), Combined(Str("]"), Str(separator))),
692        }
693    }
694}
695
696impl<'o, O, Sep> SequenceAccept<O> for AttributesAccept<'o, O, Sep>
697where
698    O: Output,
699    Sep: Writable<O>,
700{
701    async fn accept<W: Writable<O>>(&mut self, writable: &W) -> Result<(), O::Error> {
702        self.inner.accept(writable).await
703    }
704}
async_codegen/rust/mod.rs

async_codegen/rust/
mod.rs
