Better interface for static assert

[emberian]

In #6670 I add a basic form of static assertions (as suggested by graydon in #6568), but it's not nice to use. The biggest problem with it is you need a static variable with a name, that goes through trans and ends up in the object file.

@kud1ing suggested static_assert!(), which I think is a nice API but would need some invasive changed to the compiler (I think, uncertain).

[graydon]

Eh. I'm actually kinda ok with the way it turned out. If it's non-pub it shouldn't wind up in the object file as a public symbol (if it does, we're doing-stuff-wrong in codegen) and we can potentially just mark it as a throw-me-away sort of value harder if LLVM requires further convincing.

Considering that static asserts in C are typically done by composing a negative-sized array and allowing the compiler to yell about that, I consider this implementation already pretty luxurious :)

[Kimundi]

How about having a static_assert!() thats just a wrapper around a automatically generated private static item with the #[static_assert] attribute?

[kud1ing]

@Kimundi: if i understand you correctly, that's what i've suggested in #6670 (comment) but it seems not straightfoward to implement

[Kimundi]

Hm, but the current attribute-static item system works, no? Wouldn't a static_assert!() just be trivial sugar for that? Or is the 'generate a name'-part the hard one?

[emberian]

I don't know how to implement a macro to do this, so feel free to take a shot at it 😺

[catamorphism]

Visiting for triage. Doesn't seem like a release blocker.

[emberian]

With hygiene, it should be much easier. @jbclements?

[huonw]

Triage: hygiene doesn't particularly help in this case, it's currently only for names created/bound with let.

A sketch:

macro_rules! static_assert {
    ($e:expr) => {
        mod assertion { // mod needed to put attributes on the `static`
            #[static_assert]
            static asssertion: bool = $e;
        }
    }
}

// static_assert!(true)
static_assert!(false)

fn main() {}

Uncommenting the static_assert!(false) gives a duplicate module error (as one might expect). If there was a gensym!() macro (for creating a completely new ident) this might help, but mod gensym!(assertion) { ... } is currently not valid as macros aren't allowed in place of Idents.

[kud1ing]

Macros can now expand to items with attributes: #9783

[flaper87]

triage bump. Nothing to add

[thestinger]

It always needs to be crippled enough that it can't cause a compilation failure during expansion of generics. I think we should just remove the current attribute. It doesn't appear to have any real world use cases.

[steveklabnik]

triage: nothing to add. We don't currently use static_assert anywhere in the codebase, which leads me to wonder if @thestinger isn't right here.

[nodakai]

An implementation in standard Rust based on the array size trick:

macro_rules! static_assert {
    (type $t:ty; ) => (
        type __StaticAssert = $t;
    );

    (type $t:ty; $e:expr $(, $ee:expr)*) => (
        static_assert!(type ($t, [i8; 0 - ((false == ($e)) as usize)]); $($ee),*);
    );

    ($e:expr $(, $ee:expr)*) => (
        static_assert!(type [i8; 0 - ((false == ($e)) as usize)]; $($ee),*);
    );
}

// static_assert!(1 > 0);
static_assert!(1 > 0, 2 > 1, 3 > 2);

fn main() {
//    static_assert!(1 > 0);
    static_assert!(1 > 0);
}

• https://play.rust-lang.org/?gist=cb2d54bc13da8cddcf27&version=stable

In short, an invocation static_assert!(1 > 0, 2 > 1, 3 > 2, 3 > 1); expands to

type __StaticAssert =
    (((
       [i8; 0 - ((false == (1 > 0)) as usize)],
       [i8; 0 - ((false == (2 > 1)) as usize)]),
      [i8; 0 - ((false == (3 > 2)) as usize)]),
     [i8; 0 - ((false == (3 > 1)) as usize)]);

It is variadic because there will be a name collision between two invocations... Yes the usability is horrible.

[lilianmoraru]

I wish Rust would support more static features(I use them extensively in C++ in order to enforce correct API usage)...
I need to assert the simplest case: making sure the user doesn't pass an empty array/slice - and I cannot do it with the language...
It's awful that I have to "assert" at run-time for such a simple case...