---

yaml
---
r: 233149
b: refs/heads/beta
c: 9bba711
h: refs/heads/master
i:
  233147: 142c2ba
v: v3

Author: bors

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: ad9a0713fde9a9ee9eb3cb9d1b766300b36435c2
+refs/heads/beta: 9bba7110639cbd1d51977d97106d377fdfac7cdf
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/doc/trpl/advanced-linking.md

@@ -38,12 +38,12 @@ Static linking refers to the process of creating output that contain all
 required libraries and so don't need libraries installed on every system where
 you want to use your compiled project. Pure-Rust dependencies are statically
 linked by default so you can use created binaries and libraries without
-installing the Rust everywhere. By contrast, native libraries
-(e.g. `libc` and `libm`) usually dynamically linked, but it is possible to
+installing Rust everywhere. By contrast, native libraries
+(e.g. `libc` and `libm`) are usually dynamically linked, but it is possible to
 change this and statically link them as well.
 
-Linking is a very platform dependent topic — on some platforms, static linking
-may not be possible at all! This section assumes some basic familiarity with
+Linking is a very platform-dependent topic, and static linking may not even be
+possible on some platforms! This section assumes some basic familiarity with
 linking on your platform of choice.
 
 ## Linux
@@ -71,8 +71,7 @@ Dynamic linking on Linux can be undesirable if you wish to use new library
 features on old systems or target systems which do not have the required
 dependencies for your program to run.
 
-Static linking is supported via an alternative `libc`, `musl` - this must be
-enabled at Rust compile-time with some prerequisites available. You can compile
+Static linking is supported via an alternative `libc`, `musl`. You can compile
 your own version of Rust with `musl` enabled and install it into a custom
 directory with the instructions below:
 
@@ -123,7 +122,7 @@ $ du -h musldist/bin/rustc
 ```
 
 You now have a build of a `musl`-enabled Rust! Because we've installed it to a
-custom prefix we need to make sure our system can the binaries and appropriate
+custom prefix we need to make sure our system can find the binaries and appropriate
 libraries when we try and run it:
 
 ```text

branches/beta/src/doc/trpl/lifetimes.md

@@ -81,7 +81,7 @@ We previously talked a little about [function syntax][functions], but we didn’
 discuss the `<>`s after a function’s name. A function can have ‘generic
 parameters’ between the `<>`s, of which lifetimes are one kind. We’ll discuss
 other kinds of generics [later in the book][generics], but for now, let’s
-just focus on the lifteimes aspect.
+just focus on the lifetimes aspect.
 
 [functions]: functions.html
 [generics]: generics.html

branches/beta/src/librustc/metadata/creader.rs

@@ -261,6 +261,7 @@ impl<'a> CrateReader<'a> {
         let loader::Library { dylib, rlib, metadata } = lib;
 
         let cnum_map = self.resolve_crate_deps(root, metadata.as_slice(), span);
+        let staged_api = self.is_staged_api(metadata.as_slice());
 
         let cmeta = Rc::new( cstore::crate_metadata {
             name: name.to_string(),
@@ -270,6 +271,7 @@ impl<'a> CrateReader<'a> {
             cnum: cnum,
             codemap_import_info: RefCell::new(vec![]),
             span: span,
+            staged_api: staged_api
         });
 
         let source = cstore::CrateSource {
@@ -283,6 +285,17 @@ impl<'a> CrateReader<'a> {
         (cnum, cmeta, source)
     }
 
+    fn is_staged_api(&self, data: &[u8]) -> bool {
+        let attrs = decoder::get_crate_attributes(data);
+        for attr in &attrs {
+            if &attr.name()[..] == "staged_api" {
+                match attr.node.value.node { ast::MetaWord(_) => return true, _ => (/*pass*/) }
+            }
+        }
+
+        return false;
+    }
+
     fn resolve_crate(&mut self,
                      root: &Option<CratePaths>,
                      ident: &str,

branches/beta/src/librustc/metadata/csearch.rs

@@ -22,7 +22,6 @@ use rbml::reader;
 use std::rc::Rc;
 use syntax::ast;
 use syntax::attr;
-use syntax::attr::AttrMetaMethods;
 use syntax::diagnostic::expect;
 
 use std::collections::hash_map::HashMap;
@@ -386,15 +385,7 @@ pub fn get_stability(cstore: &cstore::CStore,
 }
 
 pub fn is_staged_api(cstore: &cstore::CStore, krate: ast::CrateNum) -> bool {
-    let cdata = cstore.get_crate_data(krate);
-    let attrs = decoder::get_crate_attributes(cdata.data());
-    for attr in &attrs {
-        if &attr.name()[..] == "staged_api" {
-            match attr.node.value.node { ast::MetaWord(_) => return true, _ => (/*pass*/) }
-        }
-    }
-
-    return false;
+    cstore.get_crate_data(krate).staged_api
 }
 
 pub fn get_repr_attrs(cstore: &cstore::CStore, def: ast::DefId)

branches/beta/src/librustc/metadata/cstore.rs

@@ -63,6 +63,7 @@ pub struct crate_metadata {
     pub cnum: ast::CrateNum,
     pub codemap_import_info: RefCell<Vec<ImportedFileMap>>,
     pub span: codemap::Span,
+    pub staged_api: bool
 }
 
 #[derive(Copy, Debug, PartialEq, Clone)]