Module rust

Expand description

Rust code syntax is available through this module.

Rust syntax elements.

Note that no checking exists to make sure the elements are used correctly, i.e. the correct combination of structs. Instead, the library user is expected to have basic knowledge of how Rust syntax is composed, and to combine the structs in this module likewise.

Example:

use async_codegen::common::{CombinedSeq, SingularSeq, Str};
use async_codegen::{Output, Writable};

use async_codegen::rust::{CfgAttr, Deprecated, Function, FunctionDef, FunctionParam, ModPub, MustUse, NoMangle, Parameterized};

async fn write_function<O>(output: &mut O) -> Result<(), O::Error> where O: Output {
  // For more advanced usage, you can replace Str("") by other Writable implementations
  let function_def = FunctionDef {
    attr: SingularSeq(Deprecated::with_message(Str("because we all love deprecation"))),
    mods: SingularSeq(ModPub),
    decl: Function {
      name: Str("my_func"),
      args: CombinedSeq(
        SingularSeq(FunctionParam(Str("var1"), Str("Type"))),
        SingularSeq(FunctionParam(Str("var2"), Parameterized::new(Str("Option"), SingularSeq(Str("bool")))))
      )
    },
    return_type: Parameterized::new(Str("Box"), SingularSeq(Str("str"))),
    body: Str("\ntodo!()\n")
  };
  function_def.write_to(output).await
  // Will render as:
  /*
  #[deprecated = "because we all love deprecation"]
  pub fn my_func(var1: Type, var2: Option<bool>) -> Box<str> {
    todo!()
  }
   */
}

Structs§

AllowLints: The attribute content for allow(...). The tuple value must be a sequence.
AssociatedItem: An item attached to an associated container, via “::”. The output will look like Cont::Item.
AssociatedTypeDef: Declares an associated type, rendering as type VarName = Value;. Adds new lines before and after.
AssociatedTypeEquals: Renders as Type=Value. Intended to be used as a type argument, to specify associated types.
AttributesAccept: A sequence acceptor that writes attributes. Every attribute will be placed on a new line and automatically be surrounded with “#[]”
BodyDeclare: Declares a function body. This is equivalent to just a semicolon.
BoundedTypeVar: A type variable with a sequence of bounds. Will render as TypeVar: B1 + B2 + ...
Cfg: A cfg attribute. Renders as cfg(Cond).
CfgAttr: An attribute enabled conditionally, i.e. #[cfg_attr(Cond, Attr)]
Closure: Writes a closure. Adds new lines inside the brackets, wrapping the inner expression.
DeclareField: Declares a single field within a struct. Renders as Name: Value.
DynOf: Adds a “dyn “ before a type expression.
EnumDef: Defines an enum.
ExternBlock: Declaration of an extern block, i.e. for FFI. In Rust 2024 and later, the unsafe keyword must be added for extern blocks. Thus, this struct requires that the context satisfies [ContextProvides] for Edition.
Function: The base struct for a function. Includes name and arguments. This function is re-used in other places and is likely not helpful by itself.
FunctionCall: Performs a call to a function inside code.
FunctionDef: A function declaration
FunctionParam: Renders an individual function parameter, Name: Type
ImplOf: Adds an “impl “ before a type expression
LetStmt: A let statement. This statement includes the semicolon and a new line.
Lifetime: A standalone lifetime, intended to be used as a type argument or variable
LifetimedRefOf: Adds a reference with a lifetime before a type expression, i.e. &'<lifetime> <type>
ModPub: The public modifier
ModUnsafeExtern: The extern modifier, with the ABI selected as the tuple value.
MustUse: The must_use attribute
NamedTuple: A named tuple type. Renders as Name(A1, A2, A3, ...) where AX is part of the sequence in Tuple
NoMangle: The no mangle attribute.
OkResultOf: Wraps an expression in Ok(EXPR).
Parameterized: A type argument-parameterized expression. Used in relation to parameterized names and their arguments. Examples: function_name<args>, TypeName<'lifetime, args>, MyType<Assoc=Value>.
QuestionMarkAfter: A question mark following another expression.
RefOf: Adds a “&” before a type expression
StructCall: The construction or deconstruction of a struct.
StructDef: The declaration of a struct.
StructFields: Named struct fields. This will place every field on a new line with a comma afterward. It is recommended that the sequence should pass DeclareField.
TraitDef: The declaration of a trait
TraitImpl: The implementation declaration for a trait, applying to a certain receiver.
Tuple: A tuple type. This struct’s tuple value must be a sequence.
TypeAsTrait: Uses the as expression to perform a qualified trait cast (ready for a method call). I.e., this will render as <Type as Trait>.
UnsafeBlock: Places the expression inside an unsafe block. Adds new lines inside the brackets, wrapping the inner expression.
WithAttributes: Adds attributes to ANY item.

Enums§

Deprecated: The deprecated attribute. The three variants of this enum correspond to the deprecated attribute’s multiple ways of being specified. See: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-deprecated-attribute
Edition: All possible Rust editions. This is the only type in this module meant to be used as context, and not as a writable itself.
StructKind: Completes the struct definition as either a named tuple or a struct with named fields.
Target: A cfg condition for targeting an OS, OS family, or architecture. For example:

Module rust

Module rust Copy item path

Structs§

Enums§

Module rust