Bug: 135605033

Clone this repo:
  1. d921a46 DO NOT MERGE - qt-qpr1-dev-plus-aosp-without-vendor@5915889 into stage-aosp-master by Xin Li · 4 months ago master android-r-preview-1
  2. d6fe90d Use released remain-0.1.3 at crates.io am: d4a5e37af8 by Chih-Hung Hsieh · 4 months ago
  3. d4a5e37 Use released remain-0.1.3 at crates.io by Chih-Hung Hsieh · 4 months ago
  4. 353d7d1 Allow warnings in some rust modules. am: 4bc9fa5ed1 am: 07a3b89c3f by Chih-Hung Hsieh · 5 months ago
  5. 0cac3f7 Allow warnings in some rust modules. am: 4bc9fa5ed1 am: 07a3b89c3f by Chih-Hung Hsieh · 5 months ago

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