---

yaml
---
r: 105151
b: refs/heads/snap-stage3
c: 6bac560
h: refs/heads/master
i:
  105149: 606ed60
  105147: af49ad6
  105143: 2c1e172
  105135: 13c0a19
  105119: 59af289
  105087: bec1e39
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6200e761f0ef58510ad2acc383b29de7e7a79bcd
+refs/heads/snap-stage3: 6bac5607c963c61d488a0d832458341589a560b3
 refs/heads/try: db814977d07bd798feb24f6b74c00800ef458a13
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/install.mk

@@ -15,6 +15,8 @@
 # The stage we install from
 ISTAGE = $(PREPARE_STAGE)
 
+$(eval $(call DEF_PREPARE,mkfile-install))
+
 install: PREPARE_HOST=$(CFG_BUILD)
 install: PREPARE_TARGETS=$(CFG_TARGET)
 install: PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
@@ -28,7 +30,7 @@ install: PREPARE_SOURCE_MAN_DIR=$(S)/man
 install: PREPARE_DEST_BIN_DIR=$(DESTDIR)$(CFG_PREFIX)/bin
 install: PREPARE_DEST_LIB_DIR=$(DESTDIR)$(CFG_LIBDIR)
 install: PREPARE_DEST_MAN_DIR=$(DESTDIR)$(CFG_MANDIR)/man1
-install: prepare-everything
+install: prepare-everything-mkfile-install
 
 
 # Uninstall code

branches/snap-stage3/mk/prepare.mk

@@ -156,7 +156,9 @@ prepare-base-$(1): PREPARE_SOURCE_MAN_DIR=$$(S)/man
 prepare-base-$(1): PREPARE_DEST_BIN_DIR=$$(PREPARE_DEST_DIR)/bin
 prepare-base-$(1): PREPARE_DEST_LIB_DIR=$$(PREPARE_DEST_DIR)/$$(CFG_LIBDIR_RELATIVE)
 prepare-base-$(1): PREPARE_DEST_MAN_DIR=$$(PREPARE_DEST_DIR)/share/man/man1
-prepare-base-$(1): prepare-host-$(1) prepare-targets-$(1)
+prepare-base-$(1): prepare-everything-$(1)
+
+prepare-everything-$(1): prepare-host-$(1) prepare-targets-$(1)
 
 prepare-host-$(1): prepare-host-tools-$(1)
 

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

@@ -559,9 +559,14 @@ points at a static constant).
 
 # Named lifetimes
 
-Let's look at named lifetimes in more detail. Named lifetimes allow
-for grouping of parameters by lifetime. For example, consider this
-function:
+Lifetimes can be named and referenced. For example, the special lifetime
+`'static`, which does not go out of scope, can be used to create global
+variables and communicate between tasks (see the manual for usecases).
+
+## Parameter Lifetimes
+
+Named lifetimes allow for grouping of parameters by lifetime.
+For example, consider this function:
 
 ~~~
 # struct Point {x: f64, y: f64}; // as before
@@ -655,6 +660,25 @@ fn select<'r, T>(shape: &Shape, threshold: f64,
 
 This is equivalent to the previous definition.
 
+## Labeled Control Structures
+
+Named lifetime notation can also be used to control the flow of execution:
+
+~~~
+'h: for i in range(0,10) {
+    'g: loop {
+        if i % 2 == 0 { continue 'h; }
+        if i == 9 { break 'h; }
+        break 'g;
+    }
+}
+~~~
+
+> ***Note:*** Labelled breaks are not currently supported within `while` loops.
+
+Named labels are hygienic and can be used safely within macros.
+See the macros guide section on hygiene for more details.
+
 # Conclusion
 
 So there you have it: a (relatively) brief tour of the lifetime

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

@@ -398,6 +398,38 @@ position (in particular, not as an argument to yet another macro invocation),
 the expander will then proceed to evaluate `m2!()` (along with any other macro
 invocations `m1!(m2!())` produced).
 
+# Hygiene
+
+To prevent clashes, rust implements
+[hygienic macros](http://en.wikipedia.org/wiki/Hygienic_macro).
+
+As an example, `loop` and `for-loop` labels (discussed in the lifetimes guide)
+will not clash. The following code will print "Hello!" only once:
+
+~~~
+#[feature(macro_rules)];
+
+macro_rules! loop_x (
+    ($e: expr) => (
+        // $e will not interact with this 'x
+        'x: loop {
+            println!("Hello!");
+            $e
+        }
+    );
+)
+
+fn main() {
+    'x: loop {
+        loop_x!(break 'x);
+        println!("I am never printed.");
+    }
+}
+~~~
+
+The two `'x` names did not clash, which would have caused the loop
+to print "I am never printed" and to run forever.
+
 # A final note
 
 Macros, as currently implemented, are not for the faint of heart. Even

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

@@ -2103,7 +2103,8 @@ a `&T` pointer. `MutexArc` is an example of a *sharable* type with internal muta
 These are types that do not contain any data whose lifetime is bound to
 a particular stack frame. These are types that do not contain any
 references, or types where the only contained references
-have the `'static` lifetime.
+have the `'static` lifetime. (For more on named lifetimes and their uses, 
+see the [references and lifetimes guide][lifetimes].)
 
 > ***Note:*** These two traits were referred to as 'kinds' in earlier
 > iterations of the language, and often still are.

branches/snap-stage3/src/librustdoc/clean.rs

@@ -174,12 +174,18 @@ pub enum ItemEnum {
     StaticItem(Static),
     TraitItem(Trait),
     ImplItem(Impl),
+    /// `use` and `extern crate`
     ViewItemItem(ViewItem),
+    /// A method signature only. Used for required methods in traits (ie,
+    /// non-default-methods).
     TyMethodItem(TyMethod),
+    /// A method with a body.
     MethodItem(Method),
     StructFieldItem(StructField),
     VariantItem(Variant),
+    /// `fn`s from an extern block
     ForeignFunctionItem(Function),
+    /// `static`s from an extern block
     ForeignStaticItem(Static),
     MacroItem(Macro),
 }
@@ -1014,11 +1020,23 @@ pub struct Impl {
     generics: Generics,
     trait_: Option<Type>,
     for_: Type,
-    methods: Vec<Item> ,
+    methods: Vec<Item>,
+    derived: bool,
 }
 
 impl Clean<Item> for doctree::Impl {
     fn clean(&self) -> Item {
+        let mut derived = false;
+        for attr in self.attrs.iter() {
+            match attr.node.value.node {
+                ast::MetaWord(ref s) => {
+                    if s.get() == "automatically_derived" {
+                        derived = true;
+                    }
+                }
+                _ => {}
+            }
+        }
         Item {
             name: None,
             attrs: self.attrs.clean(),
@@ -1030,6 +1048,7 @@ impl Clean<Item> for doctree::Impl {
                 trait_: self.trait_.clean(),
                 for_: self.for_.clean(),
                 methods: self.methods.clean(),
+                derived: derived,
             }),
         }
     }

branches/snap-stage3/src/librustdoc/html/layout.rs

@@ -29,53 +29,53 @@ pub fn render<T: fmt::Show, S: fmt::Show>(
     -> fmt::Result
 {
     write!(dst,
-"<!DOCTYPE html>
-<html lang=\"en\">
+r##"<!DOCTYPE html>
+<html lang="en">
 <head>
-    <meta charset=\"utf-8\" />
+    <meta charset="utf-8" />
     <title>{title}</title>
 
     <link href='http://fonts.googleapis.com/css?family=Oswald:700|Inconsolata:400,700'
           rel='stylesheet' type='text/css'>
-    <link rel=\"stylesheet\" type=\"text/css\" href=\"{root_path}main.css\">
+    <link rel="stylesheet" type="text/css" href="{root_path}main.css">
 
-    {favicon, select, none{} other{<link rel=\"shortcut icon\" href=\"#\" />}}
+    {favicon, select, none{} other{<link rel="shortcut icon" href="\#" />}}
 </head>
 <body>
     <!--[if lte IE 8]>
-    <div class=\"warning\">
+    <div class="warning">
         This old browser is unsupported and will most likely display funky
         things.
     </div>
     <![endif]-->
 
-    <section class=\"sidebar\">
+    <section class="sidebar">
         {logo, select, none{} other{
-            <a href='{root_path}{krate}/index.html'><img src='#' alt=''/></a>
+            <a href='{root_path}{krate}/index.html'><img src='\#' alt=''/></a>
         }}
 
         {sidebar}
     </section>
 
-    <nav class=\"sub\">
-        <form class=\"search-form js-only\">
-            <button class=\"do-search\">Search</button>
-            <div class=\"search-container\">
-                <input class=\"search-input\" name=\"search\"
-                       autocomplete=\"off\"
-                       placeholder=\"Search documentation...\"
-                       type=\"search\" />
+    <nav class="sub">
+        <form class="search-form js-only">
+            <button class="do-search">Search</button>
+            <div class="search-container">
+                <input class="search-input" name="search"
+                       autocomplete="off"
+                       placeholder="Search documentation..."
+                       type="search" />
             </div>
         </form>
     </nav>
 
-    <section id='main' class=\"content {ty}\">{content}</section>
-    <section id='search' class=\"content hidden\"></section>
+    <section id='main' class="content {ty}">{content}</section>
+    <section id='search' class="content hidden"></section>
 
-    <section class=\"footer\"></section>
+    <section class="footer"></section>
 
-    <div id=\"help\" class=\"hidden\">
-        <div class=\"shortcuts\">
+    <div id="help" class="hidden">
+        <div class="shortcuts">
             <h1>Keyboard shortcuts</h1>
             <dl>
                 <dt>?</dt>
@@ -86,11 +86,11 @@ pub fn render<T: fmt::Show, S: fmt::Show>(
                 <dd>Move up in search results</dd>
                 <dt>&darr;</dt>
                 <dd>Move down in search results</dd>
-                <dt>&\\#9166;</dt>
+                <dt>&\#9166;</dt>
                 <dd>Go to active search result</dd>
             </dl>
         </div>
-        <div class=\"infos\">
+        <div class="infos">
             <h1>Search tricks</h1>
             <p>
                 Prefix searches with a type followed by a colon (e.g.
@@ -106,15 +106,15 @@ pub fn render<T: fmt::Show, S: fmt::Show>(
     </div>
 
     <script>
-        var rootPath = \"{root_path}\";
-        var currentCrate = \"{krate}\";
+        var rootPath = "{root_path}";
+        var currentCrate = "{krate}";
     </script>
-    <script src=\"{root_path}jquery.js\"></script>
-    <script src=\"{root_path}main.js\"></script>
-    <script async src=\"{root_path}search-index.js\"></script>
+    <script src="{root_path}jquery.js"></script>
+    <script src="{root_path}main.js"></script>
+    <script async src="{root_path}search-index.js"></script>
 </body>
 </html>
-",
+"##,
     content   = *t,
     root_path = page.root_path,
     ty        = page.ty,

branches/snap-stage3/src/librustdoc/html/render.rs

@@ -1517,8 +1517,22 @@ fn render_methods(w: &mut Writer, it: &clean::Item) -> fmt::Result {
                 if traits.len() > 0 {
                     try!(write!(w, "<h2 id='implementations'>Trait \
                                       Implementations</h2>"));
-                    for &(ref i, ref dox) in traits.move_iter() {
-                        try!(render_impl(w, i, dox));
+                    let mut any_derived = false;
+                    for & &(ref i, ref dox) in traits.iter() {
+                        if !i.derived {
+                            try!(render_impl(w, i, dox));
+                        } else {
+                            any_derived = true;
+                        }
+                    }
+                    if any_derived {
+                        try!(write!(w, "<h3 id='derived_implementations'>Derived Implementations \
+                                    </h3>"));
+                        for &(ref i, ref dox) in traits.move_iter() {
+                            if i.derived {
+                                try!(render_impl(w, i, dox));
+                            }
+                        }
                     }
                 }
             }

branches/snap-stage3/src/libstd/kinds.rs

@@ -40,7 +40,51 @@ pub trait Pod {
     // Empty.
 }
 
-/// Types that can be safely shared between threads, hence thread-safe.
+/// Types that can be safely shared between tasks when aliased.
+///
+/// The precise definition is: a type `T` is `Share` if `&T` is
+/// thread-safe. In other words, there is no possibility of data races
+/// when passing `&T` references between tasks.
+///
+/// As one would expect, primitive types like `u8` and `f64` are all
+/// `Share`, and so are simple aggregate types containing them (like
+/// tuples, structs and enums). More instances of basic `Share` types
+/// include "immutable" types like `&T` and those with simple
+/// inherited mutability, such as `~T`, `Vec<T>` and most other
+/// collection types. (Generic parameters need to be `Share` for their
+/// container to be `Share`.)
+///
+/// A somewhat surprising consequence of the definition is `&mut T` is
+/// `Share` (if `T` is `Share`) even though it seems that it might
+/// provide unsynchronised mutation. The trick is a mutable reference
+/// stored in an aliasable reference (that is, `& &mut T`) becomes
+/// read-only, as if it were a `& &T`, hence there is no risk of a data
+/// race.
+///
+/// Types that are not `Share` are those that have "interior
+/// mutability" in a non-thread-safe way, such as `Cell` and `RefCell`
+/// in `std::cell`. These types allow for mutation of their contents
+/// even when in an immutable, aliasable slot, e.g. the contents of
+/// `&Cell<T>` can be `.set`, and do not ensure data races are
+/// impossible, hence they cannot be `Share`. A higher level example
+/// of a non-`Share` type is the reference counted pointer
+/// `std::rc::Rc`, because any reference `&Rc<T>` can clone a new
+/// reference, which modifies the reference counts in a non-atomic
+/// way.
+///
+/// For cases when one does need thread-safe interior mutability,
+/// types like the atomics in `std::sync` and `Mutex` & `RWLock` in
+/// the `sync` crate do ensure that any mutation cannot cause data
+/// races.  Hence these types are `Share`.
+///
+/// Users writing their own types with interior mutability (or anything
+/// else that is not thread-safe) should use the `NoShare` marker type
+/// (from `std::kinds::marker`) to ensure that the compiler doesn't
+/// consider the user-defined type to be `Share`.  Any types with
+/// interior mutability must also use the `std::ty::Unsafe` wrapper
+/// around the value(s) which can be mutated when behind a `&`
+/// reference; not doing this is undefined behaviour (for example,
+/// `transmute`-ing from `&T` to `&mut T` is illegal).
 #[lang="share"]
 pub trait Share {
     // Empty