Google Git
Sign in
android / platform / external / rust / crates / remain / bb3f00e08e2534237b959bc94d0fd583dbc8f7f8
commitbb3f00e08e2534237b959bc94d0fd583dbc8f7f8[log] [tgz]
authorIvan Lozano <ivanlozano@google.com>Tue Sep 24 15:43:56 2019 -0700
committerandroid-build-merger <android-build-merger@google.com>Tue Sep 24 15:43:56 2019 -0700
tree03e0f3547135aad7d468690973a851926e1b0806
parent4aa83c6c8099fcbf6e004ff47cf5651c362b6d60 [diff]
parent6f7168d16c07b4eb011d05ab27936801fe267bb5 [diff]
Remove host_supported property. am: 776ba3a1e2 am: f8b2601e37 am: e9c390f720
am: 6f7168d16c

Change-Id: I6805085d6f2e8ad81310f538e34358cfd6ed415a
tree: 03e0f3547135aad7d468690973a851926e1b0806
  1. src/
  2. tests/
  3. .gitignore
  4. .travis.yml
  5. Android.bp
  6. Cargo.toml
  7. LICENSE-APACHE
  8. LICENSE-MIT
  9. README.md
README.md

Remain sorted

Build Status Latest Version Rust Documentation

This crate provides an attribute macro to check at compile time that the variants of an enum or the arms of a match expression are written in sorted order.

[dependencies]
remain = "0.1"

Syntax

Place a #[remain::sorted] attribute on enums, structs, match-expressions, or let-statements whose value is a match-expression.

Alternatively, import as use remain::sorted; and use #[sorted] as the attribute.

#[remain::sorted]
#[derive(Debug)]
pub enum Error {
    BlockSignal(signal::Error),
    CreateCrasClient(libcras::Error),
    CreateEventFd(sys_util::Error),
    CreateSignalFd(sys_util::SignalFdError),
    CreateSocket(io::Error),
    DetectImageType(qcow::Error),
    DeviceJail(io_jail::Error),
    NetDeviceNew(virtio::NetError),
    SpawnVcpu(io::Error),
}

#[remain::sorted]
#[derive(Debug)]
pub enum Registers {
    ax: u16,
    cx: u16,
    di: u16,
    si: u16,
    sp: u16,
}

impl Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use self::Error::*;

        #[remain::sorted]
        match self {
            BlockSignal(e) => write!(f, "failed to block signal: {}", e),
            CreateCrasClient(e) => write!(f, "failed to create cras client: {}", e),
            CreateEventFd(e) => write!(f, "failed to create eventfd: {}", e),
            CreateSignalFd(e) => write!(f, "failed to create signalfd: {}", e),
            CreateSocket(e) => write!(f, "failed to create socket: {}", e),
            DetectImageType(e) => write!(f, "failed to detect disk image type: {}", e),
            DeviceJail(e) => write!(f, "failed to jail device: {}", e),
            NetDeviceNew(e) => write!(f, "failed to set up virtio networking: {}", e),
            SpawnVcpu(e) => write!(f, "failed to spawn VCPU thread: {}", e),
        }
    }
}

If an enum variant, struct field, or match arm is inserted out of order,

      NetDeviceNew(virtio::NetError),
      SpawnVcpu(io::Error),
+     AaaUhOh(Box<dyn StdError>),
  }

then the macro produces a compile error.

error: AaaUhOh should sort before BlockSignal
  --> tests/stable.rs:49:5
   |
49 |     AaaUhOh(Box<dyn StdError>),
   |     ^^^^^^^

Compiler support

The attribute on enums and structs is supported on any rustc version 1.31+.

Rust does not yet have stable support for user-defined attributes within a function body, so the attribute on match-expressions and let-statements requires a nightly compiler and the following two features enabled:

#![feature(proc_macro_hygiene, stmt_expr_attributes)]

As a stable alternative, this crate provides a function-level attribute called #[remain::check] which makes match-expression and let-statement attributes work on any rustc version 1.31+. Place this attribute on any function containing #[sorted] to make them work on a stable compiler.

impl Display for Error {
    #[remain::check]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use self::Error::*;

        #[sorted]
        match self {
            /* ... */
        }
    }
}

License