---

yaml
---
r: 156267
b: refs/heads/snap-stage3
c: 4a382d7
h: refs/heads/master
i:
  156265: fb1c142
  156263: 06c5e7b
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c29a7520e7fb4a5b4d4eccfc594e05793ef6688d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: b6397da105f4615d84f1164a1d3d24ffae3f7d76
+refs/heads/snap-stage3: 4a382d7c4743775e9ee87735ed606b0a673d8ed5
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/compiletest/runtest.rs

@@ -952,10 +952,10 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         to_lower(line).as_slice().starts_with(to_lower(prefix).as_slice())
     }
 
-    #[cfg(target_os = "linux")]
-    #[cfg(target_os = "macos")]
-    #[cfg(target_os = "freebsd")]
-    #[cfg(target_os = "dragonfly")]
+    #[cfg(any(target_os = "linux",
+              target_os = "macos",
+              target_os = "freebsd",
+              target_os = "dragonfly"))]
     fn prefix_matches( line : &str, prefix : &str ) -> bool {
         line.starts_with( prefix )
     }
@@ -1356,10 +1356,10 @@ fn program_output(config: &Config, testfile: &Path, lib_path: &str, prog: String
 }
 
 // Linux and mac don't require adjusting the library search path
-#[cfg(target_os = "linux")]
-#[cfg(target_os = "macos")]
-#[cfg(target_os = "freebsd")]
-#[cfg(target_os = "dragonfly")]
+#[cfg(any(target_os = "linux",
+          target_os = "macos",
+          target_os = "freebsd",
+          target_os = "dragonfly"))]
 fn make_cmdline(_libpath: &str, prog: &str, args: &[String]) -> String {
     format!("{} {}", prog, args.connect(" "))
 }

branches/snap-stage3/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(target_os = "win32", target_arch = "x86")]
+#[cfg(all(target_os = "win32", target_arch = "x86"))]
 #[link(name = "kernel32")]
 #[allow(non_snake_case)]
 extern "stdcall" {

branches/snap-stage3/src/doc/guide-unsafe.md

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

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

@@ -1328,23 +1328,6 @@ 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
@@ -2066,26 +2049,28 @@ fn macos_only() {
 }
 
 // This function is only included when either foo or bar is defined
-#[cfg(foo)]
-#[cfg(bar)]
+#[cfg(any(foo, bar))]
 fn needs_foo_or_bar() {
   // ...
 }
 
 // This function is only included when compiling for a unixish OS with a 32-bit
 // architecture
-#[cfg(unix, target_word_size = "32")]
+#[cfg(all(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. 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"))]`.
+`#[cfg(...)]` attribute. `any`, `all` and `not` can be used to assemble
+arbitrarily complex configurations through nesting.
 
 The following configurations must be defined by the implementation:
 

branches/snap-stage3/src/libcoretest/mem.rs

@@ -19,10 +19,10 @@ fn size_of_basic() {
 }
 
 #[test]
-#[cfg(target_arch = "x86")]
-#[cfg(target_arch = "arm")]
-#[cfg(target_arch = "mips")]
-#[cfg(target_arch = "mipsel")]
+#[cfg(any(target_arch = "x86",
+          target_arch = "arm",
+          target_arch = "mips",
+          target_arch = "mipsel"))]
 fn size_of_32() {
     assert_eq!(size_of::<uint>(), 4u);
     assert_eq!(size_of::<*const uint>(), 4u);
@@ -51,10 +51,10 @@ fn align_of_basic() {
 }
 
 #[test]
-#[cfg(target_arch = "x86")]
-#[cfg(target_arch = "arm")]
-#[cfg(target_arch = "mips")]
-#[cfg(target_arch = "mipsel")]
+#[cfg(any(target_arch = "x86",
+          target_arch = "arm",
+          target_arch = "mips",
+          target_arch = "mipsel"))]
 fn align_of_32() {
     assert_eq!(align_of::<uint>(), 4u);
     assert_eq!(align_of::<*const uint>(), 4u);

branches/snap-stage3/src/librustc/back/write.rs

@@ -34,7 +34,6 @@ 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,
@@ -44,7 +43,6 @@ pub enum OutputType {
     OutputTypeExe,
 }
 
-
 pub fn llvm_err(handler: &diagnostic::Handler, msg: String) -> ! {
     unsafe {
         let cstr = llvm::LLVMRustGetLastError();
@@ -202,6 +200,10 @@ 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 &&
@@ -240,6 +242,7 @@ 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/snap-stage3/src/librustc/diagnostics.rs

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

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

@@ -638,15 +638,15 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
         PatEnum(..) =>
             match cx.tcx.def_map.borrow().find(&pat.id) {
                 Some(&DefConst(..)) =>
-                    cx.tcx.sess.span_bug(pat.span, "static pattern should've \
+                    cx.tcx.sess.span_bug(pat.span, "const pattern should've \
                                                     been rewritten"),
                 Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
                 _ => vec!(Single)
             },
         PatStruct(..) =>
             match cx.tcx.def_map.borrow().find(&pat.id) {
                 Some(&DefConst(..)) =>
-                    cx.tcx.sess.span_bug(pat.span, "static pattern should've \
+                    cx.tcx.sess.span_bug(pat.span, "const pattern should've \
                                                     been rewritten"),
                 Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
                 _ => vec!(Single)

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

@@ -25,11 +25,25 @@ pub type PatIdMap = HashMap<Ident, NodeId>;
 pub fn pat_id_map(dm: &resolve::DefMap, pat: &Pat) -> PatIdMap {
     let mut map = HashMap::new();
     pat_bindings(dm, pat, |_bm, p_id, _s, path1| {
-      map.insert(path1.node, p_id);
+        map.insert(path1.node, p_id);
     });
     map
 }
 
+pub fn pat_is_refutable(dm: &resolve::DefMap, pat: &Pat) -> bool {
+    match pat.node {
+        PatLit(_) | PatRange(_, _) => true,
+        PatEnum(_, _) | PatIdent(_, _, None) | PatStruct(..) => {
+            match dm.borrow().find(&pat.id) {
+                Some(&DefVariant(..)) => true,
+                _ => false
+            }
+        }
+        PatVec(_, _, _) => true,
+        _ => false
+    }
+}
+
 pub fn pat_is_variant_or_struct(dm: &resolve::DefMap, pat: &Pat) -> bool {
     match pat.node {
         PatEnum(_, _) | PatIdent(_, _, None) | PatStruct(..) => {

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

@@ -54,7 +54,6 @@ use syntax::parse::token::special_idents;
 use syntax::parse::token;
 use syntax::codemap::{Span, DUMMY_SP, Pos};
 use syntax::owned_slice::OwnedSlice;
-use syntax::ptr::P;
 use syntax::visit;
 use syntax::visit::Visitor;
 
@@ -4179,7 +4178,6 @@ impl<'a> Resolver<'a> {
             ItemStruct(ref struct_def, ref generics) => {
                 self.resolve_struct(item.id,
                                     generics,
-                                    &struct_def.super_struct,
                                     struct_def.fields.as_slice());
             }
 
@@ -4505,7 +4503,6 @@ impl<'a> Resolver<'a> {
     fn resolve_struct(&mut self,
                       id: NodeId,
                       generics: &Generics,
-                      super_struct: &Option<P<Ty>>,
                       fields: &[StructField]) {
         // If applicable, create a rib for the type parameters.
         self.with_type_parameter_rib(HasTypeParameters(generics,
@@ -4517,42 +4514,6 @@ impl<'a> Resolver<'a> {
             this.resolve_type_parameters(&generics.ty_params);
             this.resolve_where_clause(&generics.where_clause);
 
-            // Resolve the super struct.
-            match *super_struct {
-                Some(ref t) => match t.node {
-                    TyPath(ref path, None, path_id) => {
-                        match this.resolve_path(id, path, TypeNS, true) {
-                            Some((DefTy(def_id, _), lp)) if this.structs.contains_key(&def_id) => {
-                                let def = DefStruct(def_id);
-                                debug!("(resolving struct) resolved `{}` to type {:?}",
-                                       token::get_ident(path.segments
-                                                            .last().unwrap()
-                                                            .identifier),
-                                       def);
-                                debug!("(resolving struct) writing resolution for `{}` (id {})",
-                                       this.path_idents_to_string(path),
-                                       path_id);
-                                this.record_def(path_id, (def, lp));
-                            }
-                            Some((DefStruct(_), _)) => {
-                                span_err!(this.session, t.span, E0154,
-                                    "super-struct is defined in a different crate");
-                            },
-                            Some(_) => {
-                                span_err!(this.session, t.span, E0155,
-                                    "super-struct is not a struct type");
-                            }
-                            None => {
-                                span_err!(this.session, t.span, E0156,
-                                    "super-struct could not be resolved");
-                            }
-                        }
-                    },
-                    _ => this.session.span_bug(t.span, "path not mapped to a TyPath")
-                },
-                None => {}
-            }
-
             // Resolve fields.
             for field in fields.iter() {
                 this.resolve_type(&*field.node.ty);
@@ -5112,10 +5073,15 @@ impl<'a> Resolver<'a> {
                         Some(def @ (DefFn(..), _))      |
                         Some(def @ (DefVariant(..), _)) |
                         Some(def @ (DefStruct(..), _))  |
-                        Some(def @ (DefConst(..), _))  |
-                        Some(def @ (DefStatic(..), _)) => {
+                        Some(def @ (DefConst(..), _)) => {
                             self.record_def(pattern.id, def);
                         }
+                        Some((DefStatic(..), _)) => {
+                            self.resolve_error(path.span,
+                                               "static variables cannot be \
+                                                referenced in a pattern, \
+                                                use a `const` instead");
+                        }
                         Some(_) => {
                             self.resolve_error(path.span,
                                 format!("`{}` is not an enum variant, struct or const",