Match assumes extern statics stay the same forever

[bytwise]

The code:

// aux.rs
#[crate_type = "lib"];
pub static Foo: uint = 1;

// main.rs
extern mod aux;
fn main() {
    let x = aux::Foo;
    match x {
        aux::Foo => println("Foo == Foo"),
        _ => println("Foo != Foo")
    }
}

produces the expected output: Foo == Foo
But after changing aux.rs to

#[crate_type = "lib"];
pub static Foo: uint = 2;

and recompiling only aux.rs, the output is Foo != Foo

This is because rustc is too eager and replaces the match pattern aux::Foo with 1 at compile-time. That works until we change aux::Foo. Because x gets its value at runtime, it becomes 2 and doesn't fit the first match arm.

[nikomatsakis]

This is not (necessarily) too eager. You are expected to recompile if
static constants change (the same is true in many languages). There is
however a need to clearly and explicitly lay out the conditions in
which a recompile is expected.

[alexcrichton]

This is working as intended. Changing a static is like changing a #define in a header file. C/C++ don't magically recompile object files, you have to explicitly lay out dependencies.

This would fall under the purview of a project like rustpkg, but there is currently no form of dependency management between crates.

Due to working as intended, I'm closing this issue. It's well understood that dependency management is not ideal today, but I don't think that this is the right issue to track that in.