Dividing by 0 is possible in statics.

[mahkoh]

static X: uint = 1/0;

compiles just fine and gives me X=0.

static X: [uint, ..1] = [0];
static Z: uint = X[1/0];

does not compile because I'm trying to divide by 0.

And that's because constant expressions get evaluated in two disconnected places depending on the operations they contain.

[huonw]

If the first X is used in some static contexts (i.e. forced to be evaluated for some other compile time operation) an error occurs.

static _X: uint = 1/0;
static _Y: uint = [0][_X];

fn main() {}

<anon>:2:23: 2:25 error: attempted to divide by zero
<anon>:2 static _Y: uint = [0][_X];
                               ^~

(That is, the error can be picked up even for a freestanding divide-by-zero.)

[mahkoh]

In my experience that's because using a static in another constant expression causes the right hand side to be re-evaluated in the new context. E.g. the commented out line will fail to compile but the program prints 1:

#[repr(uint)]
enum A {
    B,
    C,
}

static X: uint = C as uint;

//static Y: [uint, ..X] = [0, ..X];

fn main() {
    println!("{}", X);
}

Also note that the commented out line will compile if you explicitly write "C = 1".

[klutzy]

pub static S: int = 1i / 0i;
pub const C: int = 1i / 0i;
pub fn f() -> int { C }

@_ZN1S20habfc95597beb73e7eaaE = constant i64 undef

; Function Attrs: nounwind readnone uwtable
define i64 @_ZN1f20h68855414a12538bcqaaE() unnamed_addr #0 {
entry-block:
  ret i64 undef
}

They cause undefined behaviors.

[pnkfelix]

Assigning P-high, not 1.0.