---

yaml
---
r: 207870
b: refs/heads/snap-stage3
c: 19717cb
h: refs/heads/master
v: v3

Author: jooert

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 38a97becdf3e6a6157f6f7ec2d98ade8d8edc193
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: e962870420fef19e8f23a299dbe7499aca1656a5
+refs/heads/snap-stage3: 19717cbf46ecc9735c0f9ae110638db9445740a5
 refs/heads/try: 7b4ef47b7805a402d756fb8157101f64880a522f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/configure

@@ -544,7 +544,7 @@ fi
 BOOL_OPTIONS=""
 VAL_OPTIONS=""
 
-opt debug 0 "debug mode; disables optimization unless \`--enable-optimize\` given"
+opt debug 0 "debug mode"
 opt valgrind 0 "run tests with valgrind (memcheck by default)"
 opt helgrind 0 "run tests with helgrind instead of memcheck"
 opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind"

branches/snap-stage3/src/doc/grammar.md

@@ -176,15 +176,9 @@ excluded from the `ident` rule.
 
 ```antlr
 lit_suffix : ident;
-literal : [ string_lit | char_lit | byte_string_lit | byte_lit | num_lit | bool_lit ] lit_suffix ?;
+literal : [ string_lit | char_lit | byte_string_lit | byte_lit | num_lit ] lit_suffix ?;
 ```
 
-The optional `lit_suffix` production is only used for certain numeric literals,
-but is reserved for future extension. That is, the above gives the lexical
-grammar, but a Rust parser will reject everything but the 12 special cases
-mentioned in [Number literals](reference.html#number-literals) in the
-reference.
-
 #### Character and string literals
 
 ```antlr
@@ -244,9 +238,7 @@ dec_lit : [ dec_digit | '_' ] + ;
 
 #### Boolean literals
 
-```antlr
-bool_lit : [ "true" | "false" ] ;
-```
+**FIXME:** write grammar
 
 The two values of the boolean type are written `true` and `false`.
 
@@ -305,7 +297,7 @@ transcriber : '(' transcriber * ')' | '[' transcriber * ']'
 
 ```antlr
 item : mod_item | fn_item | type_item | struct_item | enum_item
-     | const_item | static_item | trait_item | impl_item | extern_block ;
+     | static_item | trait_item | impl_item | extern_block ;
 ```
 
 ### Type Parameters
@@ -377,10 +369,6 @@ path_item : ident | "mod" ;
 
 **FIXME:** grammar?
 
-### Enumerations
-
-**FIXME:** grammar?
-
 ### Constant items
 
 ```antlr

branches/snap-stage3/src/doc/reference.md

@@ -130,6 +130,11 @@ of tokens, that immediately and directly denotes the value it evaluates to,
 rather than referring to it by name or some other evaluation rule. A literal is
 a form of constant expression, so is evaluated (primarily) at compile time.
 
+The optional suffix is only used for certain numeric literals, but is
+reserved for future extension, that is, the above gives the lexical
+grammar, but a Rust parser will reject everything but the 12 special
+cases mentioned in [Number literals](#number-literals) below.
+
 #### Examples
 
 ##### Characters and strings

branches/snap-stage3/src/doc/trpl/inline-assembly.md

@@ -58,7 +58,7 @@ but you must add the right number of `:` if you skip them:
 asm!("xor %eax, %eax"
     :
     :
-    : "{eax}"
+    : "eax"
    );
 # } }
 ```
@@ -69,21 +69,21 @@ Whitespace also doesn't matter:
 # #![feature(asm)]
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 # fn main() { unsafe {
-asm!("xor %eax, %eax" ::: "{eax}");
+asm!("xor %eax, %eax" ::: "eax");
 # } }
 ```
 
 ## Operands
 
 Input and output operands follow the same format: `:
 "constraints1"(expr1), "constraints2"(expr2), ..."`. Output operand
-expressions must be mutable lvalues, or not yet assigned:
+expressions must be mutable lvalues:
 
 ```
 # #![feature(asm)]
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 fn add(a: i32, b: i32) -> i32 {
-    let c: i32;
+    let mut c = 0;
     unsafe {
         asm!("add $2, $0"
              : "=r"(c)
@@ -100,22 +100,6 @@ fn main() {
 }
 ```
 
-If you would like to use real operands in this position, however,
-you are required to put curly braces `{}` around the register that
-you want, and you are required to put the specific size of the
-operand. This is useful for very low level programming, where 
-which register you use is important:
-
-```
-# #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-# unsafe fn read_byte_in(port: u16) -> u8 {
-let result: u8;
-asm!("in %dx, %al" : "={al}"(result) : "{dx}"(port));
-result
-# }
-```
-
 ## Clobbers
 
 Some instructions modify registers which might otherwise have held
@@ -128,7 +112,7 @@ stay valid.
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 # fn main() { unsafe {
 // Put the value 0x200 in eax
-asm!("mov $$0x200, %eax" : /* no outputs */ : /* no inputs */ : "{eax}");
+asm!("mov $$0x200, %eax" : /* no outputs */ : /* no inputs */ : "eax");
 # } }
 ```
 
@@ -155,14 +139,3 @@ Current valid options are:
    the compiler to insert its usual stack alignment code
 3. *intel* - use intel syntax instead of the default AT&T.
 
-```
-# #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-# fn main() {
-let result: i32;
-unsafe {
-   asm!("mov eax, 2" : "={eax}"(result) : : : "intel")
-}
-println!("eax is currently {}", result);
-# }
-```

branches/snap-stage3/src/librustc/diagnostics.rs

@@ -168,12 +168,6 @@ match x {
 ```
 "##,
 
-E0010: r##"
-The value of statics and constants must be known at compile time, and they live
-for the entire lifetime of a program. Creating a boxed value allocates memory on
-the heap at runtime, and therefore cannot be done at compile time.
-"##,
-
 E0013: r##"
 Static and const variables can refer to other const variables. But a const
 variable cannot refer to a static variable. For example, `Y` cannot refer to `X`
@@ -227,31 +221,6 @@ This error indicates that an attempt was made to divide by zero (or take the
 remainder of a zero divisor) in a static or constant expression.
 "##,
 
-E0079: r##"
-Enum variants which contain no data can be given a custom integer
-representation. This error indicates that the value provided is not an
-integer literal and is therefore invalid.
-"##,
-
-E0080: r##"
-This error indicates that the compiler was unable to sensibly evaluate an
-integer expression provided as an enum discriminant. Attempting to divide by 0
-or causing integer overflow are two ways to induce this error. For example:
-
-```
-enum Enum {
-    X = (1 << 500),
-    Y = (1 / 0)
-}
-```
-
-Ensure that the expressions given can be evaluated as the desired integer type.
-See the FFI section of the Reference for more information about using a custom
-integer type:
-
-http://doc.rust-lang.org/reference.html#ffi-attributes
-"##,
-
 E0133: r##"
 Using unsafe functionality, such as dereferencing raw pointers and calling
 functions via FFI or marked as unsafe, is potentially dangerous and disallowed
@@ -525,13 +494,16 @@ a compile-time constant.
 }
 
 register_diagnostics! {
+    E0010,
     E0011,
     E0012,
     E0014,
     E0016,
     E0017,
     E0019,
     E0022,
+    E0079, // enum variant: expected signed integer constant
+    E0080, // enum variant: constant evaluation error
     E0109,
     E0110,
     E0134,

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -5732,10 +5732,8 @@ fn compute_enum_variants<'tcx>(cx: &ctxt<'tcx>,
                     Ok(const_eval::const_int(val)) => current_disr_val = val as Disr,
                     Ok(const_eval::const_uint(val)) => current_disr_val = val as Disr,
                     Ok(_) => {
-                        let sign_desc = if repr_type.is_signed() { "signed" } else { "unsigned" };
                         span_err!(cx.sess, e.span, E0079,
-                                  "expected {} integer constant",
-                                  sign_desc);
+                                  "expected signed integer constant");
                         current_disr_val = attempt_fresh_value();
                     }
                     Err(ref err) => {

branches/snap-stage3/src/librustc_typeck/diagnostics.rs

@@ -10,85 +10,6 @@
 
 #![allow(non_snake_case)]
 
-register_long_diagnostics! {
-
-E0081: r##"
-Enum discriminants are used to differentiate enum variants stored in memory.
-This error indicates that the same value was used for two or more variants,
-making them impossible to tell apart.
-
-```
-// Good.
-enum Enum {
-    P,
-    X = 3,
-    Y = 5
-}
-
-// Bad.
-enum Enum {
-    P = 3,
-    X = 3,
-    Y = 5
-}
-```
-
-Note that variants without a manually specified discriminant are numbered from
-top to bottom starting from 0, so clashes can occur with seemingly unrelated
-variants.
-
-```
-enum Bad {
-    X,
-    Y = 0
-}
-```
-
-Here `X` will have already been assigned the discriminant 0 by the time `Y` is
-encountered, so a conflict occurs.
-"##,
-
-E0082: r##"
-The default type for enum discriminants is `isize`, but it can be adjusted by
-adding the `repr` attribute to the enum declaration. This error indicates that
-an integer literal given as a discriminant is not a member of the discriminant
-type. For example:
-
-```
-#[repr(u8)]
-enum Thing {
-    A = 1024,
-    B = 5
-}
-```
-
-Here, 1024 lies outside the valid range for `u8`, so the discriminant for `A` is
-invalid. You may want to change representation types to fix this, or else change
-invalid discriminant values so that they fit within the existing type.
-
-Note also that without a representation manually defined, the compiler will
-optimize by using the smallest integer type possible.
-"##,
-
-E0083: r##"
-At present, it's not possible to define a custom representation for an enum with
-a single variant. As a workaround you can add a `Dummy` variant.
-
-See: https://github.com/rust-lang/rust/issues/10292
-"##,
-
-E0084: r##"
-It is impossible to define an integer type to be used to represent zero-variant
-enum values because there are no zero-variant enum values. There is no way to
-construct an instance of the following type using only safe code:
-
-```
-enum Empty {}
-```
-"##
-
-}
-
 register_diagnostics! {
     E0023,
     E0024,
@@ -130,6 +51,10 @@ register_diagnostics! {
     E0075,
     E0076,
     E0077,
+    E0081,
+    E0082,
+    E0083,
+    E0084,
     E0085,
     E0086,
     E0087,

branches/snap-stage3/src/test/compile-fail/issue-24446.rs

@@ -0,0 +1,20 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    static foo: Fn() -> u32 = || -> u32 {
+        //~^ ERROR: mismatched types:
+        //~| expected `core::ops::Fn() -> u32`,
+        //~| found closure
+        //~| (expected trait core::ops::Fn,
+        //~| found closure)
+        0
+    };
+}