Struct CompileRequest 

pub struct CompileRequest<'a> {
    pub target: CompileTarget,
    pub assembly_flavor: Option<AssemblyFlavor>,
    pub demangle_assembly: Option<DemangleAssembly>,
    pub process_assembly: Option<ProcessAssembly>,
    pub channel: Channel,
    pub mode: Mode,
    pub edition: Edition,
    pub crate_type: CrateType,
    pub tests: bool,
    pub backtrace: bool,
    pub code: Cow<'a, str>,
}

Request structure for compiling Rust code via the playground API.

Contains configuration for target output, compilation channel, mode, crate type, edition, and the source code to compile.

Fields

target: CompileTarget

The output target format of the compilation (e.g., Assembly, MIR).

assembly_flavor: Option<AssemblyFlavor>

What flavour the assembly output should have (only required when target is CompileTarget::Assembly)

demangle_assembly: Option<DemangleAssembly>

If the assembly output should be demangled or not (only required when target is CompileTarget::Assembly)

process_assembly: Option<ProcessAssembly>

If the output should be processed or not (only required when target is CompileTarget::Assembly)

channel: Channel

The Rust release channel to use (stable, beta, nightly).

mode: Mode

The compilation mode: debug or release.

edition: Edition

The Rust edition to use (2015, 2018, 2021, 2024).

crate_type: CrateType

The crate type: binary or library.

tests: bool

Whether to include test code during compilation.

backtrace: bool

Whether to enable backtrace output on errors.

code: Cow<'a, str>

The Rust source code to compile.

Implementations

impl<'a> CompileRequest<'a>

pub fn new( target: CompileTarget, assembly_flavor: Option<AssemblyFlavor>, demangle_assembly: Option<DemangleAssembly>, process_assembly: Option<ProcessAssembly>, channel: Channel, mode: Mode, edition: Edition, crate_type: CrateType, tests: bool, backtrace: bool, code: Cow<'a, str>, ) -> Self

Creates a new CompileRequest instance.

Arguments

• target - The compilation target (e.g., Assembly, LLVM IR, Wasm).
• assembly_flavor - The assembly flavor used when targeting assembly (e.g., AT&T or Intel). Optional.
• demangle_assembly - Whether to demangle symbols in assembly output. Optional.
• process_assembly - Whether to filter or output raw assembly. Optional.
• channel - The Rust release channel (e.g., stable, beta, nightly).
• mode - Compilation mode (e.g., debug or release).
• edition - The Rust edition to compile against.
• crate_type - The crate type (binary or library).
• tests - Whether to compile with test harness.
• backtrace - Whether to enable backtrace support.
• code - The Rust source code to compile.

Returns

A fully constructed CompileRequest.

Trait Implementations

impl<'a> Clone for CompileRequest<'a>

fn clone(&self) -> CompileRequest<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for CompileRequest<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for CompileRequest<'a>

fn default() -> Self

Provides a default CompileRequest configuration.

Defaults to:

• Target: Assembly
• Assembly flavor: AT&T
• Demangling: Demangle
• Process: Filter
• Channel: Stable
• Mode: Debug
• Edition: 2024
• Crate type: Binary
• Tests: disabled
• Backtrace: disabled
• Code: fn main() { println!("Hello, world!"); }

Returns

A CompileRequest instance with default values for compiling basic Rust code.

impl<'de, 'a> Deserialize<'de> for CompileRequest<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> PartialEq for CompileRequest<'a>

fn eq(&self, other: &CompileRequest<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'b> Request for CompileRequest<'b>

fn endpoint<'a>(&self) -> Endpoints<'a>

impl<'a> Serialize for CompileRequest<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for CompileRequest<'a>

impl<'a> StructuralPartialEq for CompileRequest<'a>