---

yaml
---
r: 138103
b: refs/heads/try
c: b2949ae
h: refs/heads/master
i:
  138101: c4eb886
  138099: 343a2de
  138095: cc9eb74
v: v3

Author: nodakai

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b6e0d3a5bf4c88650a22f605f822e02c6b163580
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
-refs/heads/try: 412f4d1fc7ec8858ee4c91abd78097ac48cb15ef
+refs/heads/try: b2949ae543e5a7a1e2b5543aff8e4252f1aab41c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/README.md

@@ -87,7 +87,7 @@ fetch snapshots, and an OS that can execute the available snapshot binaries.
 
 Snapshot binaries are currently built and tested on several platforms:
 
-* Windows (7, 8, Server 2008 R2), x86 and x86-64 (64-bit support added in Rust 0.12.0)
+* Windows (7, 8, Server 2008 R2), x86 only
 * Linux (2.6.18 or later, various distributions), x86 and x86-64
 * OSX 10.7 (Lion) or greater, x86 and x86-64
 

branches/try/src/doc/guide-ffi.md

@@ -475,7 +475,7 @@ conventions. Rust provides a way to tell the compiler which convention to use:
 ~~~~
 extern crate libc;
 
-#[cfg(all(target_os = "win32", target_arch = "x86"))]
+#[cfg(target_os = "win32", target_arch = "x86")]
 #[link(name = "kernel32")]
 #[allow(non_snake_case)]
 extern "stdcall" {

branches/try/src/doc/guide-unsafe.md

@@ -313,15 +313,17 @@ literal string (i.e `""`)
 ```
 #![feature(asm)]
 
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+#[cfg(target_arch = "x86")]
+#[cfg(target_arch = "x86_64")]
 fn foo() {
     unsafe {
         asm!("NOP");
     }
 }
 
 // other platforms
-#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(not(target_arch = "x86"),
+      not(target_arch = "x86_64"))]
 fn foo() { /* ... */ }
 
 fn main() {
@@ -338,7 +340,7 @@ but you must add the right number of `:` if you skip them:
 
 ```
 # #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+# #[cfg(target_arch = "x86")] #[cfg(target_arch = "x86_64")]
 # fn main() { unsafe {
 asm!("xor %eax, %eax"
     :
@@ -352,7 +354,7 @@ Whitespace also doesn't matter:
 
 ```
 # #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+# #[cfg(target_arch = "x86")] #[cfg(target_arch = "x86_64")]
 # fn main() { unsafe {
 asm!("xor %eax, %eax" ::: "eax");
 # } }
@@ -366,7 +368,7 @@ expressions must be mutable lvalues:
 
 ```
 # #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+# #[cfg(target_arch = "x86")] #[cfg(target_arch = "x86_64")]
 fn add(a: int, b: int) -> int {
     let mut c = 0;
     unsafe {
@@ -377,7 +379,7 @@ fn add(a: int, b: int) -> int {
     }
     c
 }
-# #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+# #[cfg(not(target_arch = "x86"), not(target_arch = "x86_64"))]
 # fn add(a: int, b: int) -> int { a + b }
 
 fn main() {
@@ -394,7 +396,7 @@ stay valid.
 
 ```
 # #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+# #[cfg(target_arch = "x86")] #[cfg(target_arch = "x86_64")]
 # fn main() { unsafe {
 // Put the value 0x200 in eax
 asm!("mov $$0x200, %eax" : /* no outputs */ : /* no inputs */ : "eax");

branches/try/src/doc/reference.md

@@ -185,40 +185,24 @@ grammar as double-quoted strings. Other tokens have exact rules given.
 
 ### Keywords
 
-The keywords are the following strings, organized by first letter:
+<p id="keyword-table-marker">The keywords are the following strings, organized by first letter:</p>
 
-<div id="keywords">
 |          |        |        |       |
 |----------|--------|--------|-------|
 | as       |        |        |       |
-|----------|--------|--------|-------|
 | box      | break  |        |       |
-|----------|--------|--------|-------|
 | continue | crate  |        |       |
-|----------|--------|--------|-------|
 | else     | enum   | extern |       |
-|----------|--------|--------|-------|
 | false    | fn     | for    |       |
-|----------|--------|--------|-------|
 | if       | impl   | in     |       |
-|----------|--------|--------|-------|
 | let      | loop   |        |       |
-|----------|--------|--------|-------|
 | match    | mod    | mut    |       |
-|----------|--------|--------|-------|
 | priv     | proc   | pub    |       |
-|----------|--------|--------|-------|
 | ref      | return |        |       |
-|----------|--------|--------|-------|
 | self     | static | struct | super |
-|----------|--------|--------|-------|
 | trait    | true   | type   |       |
-|----------|--------|--------|-------|
 | unsafe   | use    |        |       |
-|----------|--------|--------|-------|
 | while    |        |        |       |
-|----------|--------|--------|-------|
-</div>
 
 Each of these keywords has special meaning in its grammar, and all of them are
 excluded from the `ident` rule.
@@ -1328,6 +1312,23 @@ let c = [Cookie, Cookie, Cookie, Cookie];
 The precise memory layout of a structure is not specified. One can specify a
 particular layout using the [`repr` attribute](#ffi-attributes).
 
+By using the `struct_inherit` feature gate, structures may use single
+inheritance. A Structure may only inherit from a single other structure, called
+the _super-struct_. The inheriting structure (sub-struct) acts as if all fields
+in the super-struct were present in the sub-struct. Fields declared in a
+sub-struct must not have the same name as any field in any (transitive)
+super-struct. All fields (both declared and inherited) must be specified in any
+initializers. Inheritance between structures does not give subtyping or
+coercion. The super-struct and sub-struct must be defined in the same crate.
+The super-struct must be declared using the `virtual` keyword. For example:
+
+```{.ignore}
+virtual struct Sup { x: int }
+struct Sub : Sup { y: int }
+let s = Sub {x: 10, y: 11};
+let sx = s.x;
+```
+
 ### Enumerations
 
 An _enumeration_ is a simultaneous definition of a nominal [enumerated
@@ -2049,28 +2050,26 @@ fn macos_only() {
 }
 
 // This function is only included when either foo or bar is defined
-#[cfg(any(foo, bar))]
+#[cfg(foo)]
+#[cfg(bar)]
 fn needs_foo_or_bar() {
   // ...
 }
 
 // This function is only included when compiling for a unixish OS with a 32-bit
 // architecture
-#[cfg(all(unix, target_word_size = "32"))]
+#[cfg(unix, target_word_size = "32")]
 fn on_32bit_unix() {
   // ...
 }
-
-// This function is only included when foo is not defined
-#[cfg(not(foo))]
-fn needs_not_foo() {
-  // ...
-}
 ```
 
 This illustrates some conditional compilation can be achieved using the
-`#[cfg(...)]` attribute. `any`, `all` and `not` can be used to assemble
-arbitrarily complex configurations through nesting.
+`#[cfg(...)]` attribute. Note that `#[cfg(foo, bar)]` is a condition that needs
+both `foo` and `bar` to be defined while `#[cfg(foo)] #[cfg(bar)]` only needs
+one of `foo` and `bar` to be defined (this resembles in the disjunctive normal
+form). Additionally, one can reverse a condition by enclosing it in a
+`not(...)`, like e. g. `#[cfg(not(target_os = "win32"))]`.
 
 The following configurations must be defined by the implementation:
 
@@ -2488,8 +2487,6 @@ The currently implemented features of the reference compiler are:
 
 * `if_let` - Allows use of the `if let` syntax.
 
-* `while_let` - Allows use of the `while let` syntax.
-
 * `intrinsics` - Allows use of the "rust-intrinsics" ABI. Compiler intrinsics
                  are inherently unstable and no promise about them is made.
 
@@ -3496,18 +3493,6 @@ of a condition expression it expects a refutable let statement. If the value of
 expression on the right hand side of the let statement matches the pattern, the corresponding
 block will execute, otherwise flow proceeds to the first `else` block that follows.
 
-### While let loops
-
-```{.ebnf .gram}
-while_let_expr : "while" "let" pat '=' expr '{' block '}' ;
-```
-
-A `while let` loop is semantically identical to a `while` loop but in place of a
-condition expression it expects a refutable let statement. If the value of the
-expression on the right hand side of the let statement matches the pattern, the
-loop body block executes and control returns to the pattern matching statement.
-Otherwise, the while expression completes.
-
 ### Return expressions
 
 ```{.ebnf .gram}

branches/try/src/doc/rust.css

@@ -393,4 +393,9 @@ pre.rust { position: relative; }
     }
 }
 
-#keywords table td { border: none; }
+#keyword-table-marker + table thead { display: none; }
+#keyword-table-marker + table td { border: none; }
+#keyword-table-marker + table {
+    margin-left: 2em;
+    margin-bottom: 1em;
+}

branches/try/src/libcollections/bitv.rs

@@ -33,7 +33,7 @@
 //!     bv.set(0, false);
 //!     bv.set(1, false);
 //!
-//!     for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as uint) {
+//!     for i in range(2, max_prime) {
 //!         // if i is a prime
 //!         if bv[i] {
 //!             // Mark all multiples of i as non-prime (any multiples below i * i

branches/try/src/librustc/back/write.rs

@@ -34,6 +34,7 @@ use std::sync::{Arc, Mutex};
 use std::task::TaskBuilder;
 use libc::{c_uint, c_int, c_void};
 
+
 #[deriving(Clone, PartialEq, PartialOrd, Ord, Eq)]
 pub enum OutputType {
     OutputTypeBitcode,
@@ -43,6 +44,7 @@ pub enum OutputType {
     OutputTypeExe,
 }
 
+
 pub fn llvm_err(handler: &diagnostic::Handler, msg: String) -> ! {
     unsafe {
         let cstr = llvm::LLVMRustGetLastError();
@@ -200,10 +202,6 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef {
                      (sess.targ_cfg.os == abi::OsMacos &&
                       sess.targ_cfg.arch == abi::X86_64);
 
-    let any_library = sess.crate_types.borrow().iter().any(|ty| {
-        *ty != config::CrateTypeExecutable
-    });
-
     // OSX has -dead_strip, which doesn't rely on ffunction_sections
     // FIXME(#13846) this should be enabled for windows
     let ffunction_sections = sess.targ_cfg.os != abi::OsMacos &&
@@ -242,7 +240,6 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef {
                         true /* EnableSegstk */,
                         use_softfp,
                         no_fp_elim,
-                        !any_library && reloc_model == llvm::RelocPIC,
                         ffunction_sections,
                         fdata_sections,
                     )

branches/try/src/librustc/diagnostics.rs

@@ -56,6 +56,7 @@ register_diagnostics!(
     E0038,
     E0039,
     E0040,
+    E0041,
     E0044,
     E0045,
     E0046,
@@ -122,6 +123,7 @@ register_diagnostics!(
     E0121,
     E0122,
     E0124,
+    E0126,
     E0127,
     E0128,
     E0129,
@@ -139,12 +141,14 @@ register_diagnostics!(
     E0141,
     E0152,
     E0153,
+    E0154,
+    E0155,
+    E0156,
     E0157,
     E0158,
     E0159,
     E0161,
     E0162,
     E0163,
-    E0164,
-    E0165
+    E0164
 )

branches/try/src/librustc/lint/builtin.rs

@@ -1082,8 +1082,7 @@ impl LintPass for UnnecessaryParens {
             ast::ExprWhile(ref cond, _, _) => (cond, "`while` condition", true),
             ast::ExprMatch(ref head, _, source) => match source {
                 ast::MatchNormal => (head, "`match` head expression", true),
-                ast::MatchIfLetDesugar => (head, "`if let` head expression", true),
-                ast::MatchWhileLetDesugar => (head, "`while let` head expression", true),
+                ast::MatchIfLetDesugar => (head, "`if let` head expression", true)
             },
             ast::ExprRet(Some(ref value)) => (value, "`return` value", false),
             ast::ExprAssign(_, ref value) => (value, "assigned value", false),

branches/try/src/librustc/middle/cfg/construct.rs

@@ -259,10 +259,6 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 expr_exit
             }
 
-            ast::ExprWhileLet(..) => {
-                self.tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet");
-            }
-
             ast::ExprForLoop(ref pat, ref head, ref body, _) => {
                 //
                 //          [pred]