---

yaml
---
r: 274220
b: refs/heads/stable
c: c0984e4
h: refs/heads/master

Author: mopp

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 5a81d9aa6d622b3ea208118c9b121340f04b6460
+refs/heads/stable: c0984e42bd598ea119b128b4a52066dae7cb64d3
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/configure

@@ -1051,7 +1051,7 @@ then
             esac
         else
             case $CFG_CLANG_VERSION in
-                (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7* | 3.8*)
+                (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7* | 3.8* | 3.9*)
                 step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
                 ;;
                 (*)

branches/stable/src/librustc_passes/diagnostics.rs

@@ -150,36 +150,26 @@ If you really want global mutable state, try using `static mut` or a global
 "##,
 
 E0018: r##"
+The value of static and const variables must be known at compile time. You
+can't cast a pointer as an integer because we can't know what value the
+address will take.
 
-The value of static and constant integers must be known at compile time. You
-can't cast a pointer to an integer because the address of a pointer can
-vary.
+However, pointers to other constants' addresses are allowed in constants,
+example:
 
-For example, if you write:
 ```
-static MY_STATIC: u32 = 42;
-static MY_STATIC_ADDR: usize = &MY_STATIC as *const _ as usize;
-static WHAT: usize = (MY_STATIC_ADDR^17) + MY_STATIC_ADDR;
+const X: u32 = 50;
+const Y: *const u32 = &X;
 ```
 
-Then `MY_STATIC_ADDR` would contain the address of `MY_STATIC`. However,
-the address can change when the program is linked, as well as change
-between different executions due to ASLR, and many linkers would
-not be able to calculate the value of `WHAT`.
-
-On the other hand, static and constant pointers can point either to
-a known numeric address or to the address of a symbol.
+Therefore, casting one of these non-constant pointers to an integer results
+in a non-constant integer which lead to this error. Example:
 
 ```
-static MY_STATIC_ADDR: &'static u32 = &MY_STATIC;
-// ... and also
-static MY_STATIC_ADDR2: *const u32 = &MY_STATIC;
-
-const CONST_ADDR: *const u8 = 0x5f3759df as *const u8;
+const X: u32 = 1;
+const Y: usize = &X as *const u32 as usize;
+println!("{}", Y);
 ```
-
-This does not pose a problem by itself because they can't be
-accessed directly.
 "##,
 
 E0019: r##"
@@ -357,59 +347,55 @@ From [RFC 246]:
 [RFC 246]: https://github.com/rust-lang/rfcs/pull/246
 "##,
 
-
 E0395: r##"
-The value assigned to a constant scalar must be known at compile time,
-which is not the case when comparing raw pointers.
+The value assigned to a constant expression must be known at compile time,
+which is not the case when comparing raw pointers. Erroneous code example:
 
-
-Erroneous code example:
 ```
-static FOO: i32 = 42;
-static BAR: i32 = 42;
+static foo: i32 = 42;
+static bar: i32 = 43;
 
-static BAZ: bool = { (&FOO as *const i32) == (&BAR as *const i32) };
+static baz: bool = { (&foo as *const i32) == (&bar as *const i32) };
 // error: raw pointers cannot be compared in statics!
 ```
 
-The address assigned by the linker to `FOO` and `BAR` may or may not
-be identical, so the value of `BAZ` can't be determined.
-
-If you want to do the comparison, please do it at run-time.
-
-For example:
+Please check that the result of the comparison can be determined at compile time
+or isn't assigned to a constant expression. Example:
 
 ```
-static FOO: i32 = 42;
-static BAR: i32 = 42;
+static foo: i32 = 42;
+static bar: i32 = 43;
 
-let baz: bool = { (&FOO as *const i32) == (&BAR as *const i32) };
+let baz: bool = { (&foo as *const i32) == (&bar as *const i32) };
 // baz isn't a constant expression so it's ok
 ```
 "##,
 
 E0396: r##"
-The value behind a raw pointer can't be determined at compile-time
-(or even link-time), which means it can't be used in a constant
-expression.
+The value assigned to a constant expression must be known at compile time,
+which is not the case when dereferencing raw pointers. Erroneous code
+example:
 
-For example:
 ```
-const REG_ADDR: *const u8 = 0x5f3759df as *const u8;
+const foo: i32 = 42;
+const baz: *const i32 = (&foo as *const i32);
 
-const VALUE: u8 = unsafe { *REG_ADDR };
+const deref: i32 = *baz;
 // error: raw pointers cannot be dereferenced in constants
 ```
 
-A possible fix is to dereference your pointer at some point in run-time.
-
-For example:
+To fix this error, please do not assign this value to a constant expression.
+Example:
 
 ```
-const REG_ADDR: *const u8 = 0x5f3759df as *const u8;
+const foo: i32 = 42;
+const baz: *const i32 = (&foo as *const i32);
 
-let reg_value = unsafe { *REG_ADDR };
+unsafe { let deref: i32 = *baz; }
+// baz isn't a constant expression so it's ok
 ```
+
+You'll also note that this assignment must be done in an unsafe block!
 "##,
 
 E0397: r##"