---

yaml
---
r: 151167
b: refs/heads/try2
c: 6c41253
h: refs/heads/master
i:
  151165: 3d26ac4
  151163: 885dc7e
  151159: 5324772
  151151: 60b8d14
  151135: e54df38
  151103: aa2e817
  151039: 23747c4
v: v3

Author: alxgnon

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 1f4278d650837bf30e5461fd15c2364b2bb5ceff
+refs/heads/try2: 6c41253a473728451283e20bef3498fdfe797243
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/tutorial.md

@@ -1793,6 +1793,11 @@ spawn(proc() {
 });
 ~~~~
 
+> *Note:* If you want to see the output of `debug!` statements, you will need to turn on
+> `debug!` logging.  To enable `debug!` logging, set the RUST_LOG environment
+> variable to the name of your crate, which, for a file named `foo.rs`, will be
+> `foo` (e.g., with bash, `export RUST_LOG=foo`).
+
 ## Closure compatibility
 
 Rust closures have a convenient subtyping property: you can pass any kind of

branches/try2/src/etc/maketest.py

@@ -12,53 +12,26 @@
 import os
 import sys
 
-# msys1/msys2 automatically converts `/abs/path1:/abs/path2` into
-# `c:\real\abs\path1;c:\real\abs\path2` (semicolons) if shell thinks
-# the value is list of paths.
-# this causes great confusion and error: shell and Makefile doesn't like
-# windows paths so it is really error-prone. revert it for peace.
-def normalize_path(v):
-    # c:\path -> /c/path
-    if ':\\' in v:
-        v = '/' + v.replace(':\\', '/')
-    v = v.replace('\\', '/')
-    return v
-
-
-def putenv(name, value):
-    if os.name == 'nt':
-        value = normalize_path(value)
-    os.putenv(name, value)
-
+# FIXME #12303 these tests are broken on windows
+if os.name == 'nt':
+    print 'ignoring make tests on windows'
+    sys.exit(0)
 
 make = sys.argv[2]
-putenv('RUSTC', os.path.abspath(sys.argv[3]))
-putenv('TMPDIR', os.path.abspath(sys.argv[4]))
-putenv('CC', sys.argv[5])
-putenv('RUSTDOC', os.path.abspath(sys.argv[6]))
+os.putenv('RUSTC', os.path.abspath(sys.argv[3]))
+os.putenv('TMPDIR', os.path.abspath(sys.argv[4]))
+os.putenv('CC', sys.argv[5])
+os.putenv('RUSTDOC', os.path.abspath(sys.argv[6]))
 filt = sys.argv[7]
 ldpath = sys.argv[8]
 if ldpath != '':
-    name = ldpath.split('=')[0]
-    value = ldpath.split('=')[1]
-    if os.name == 'nt' and name != 'PATH':
-        value = ":".join(normalize_path(v) for v in value.split(";"))
-    os.putenv(name, value)
+    os.putenv(ldpath.split('=')[0], ldpath.split('=')[1])
 
 if not filt in sys.argv[1]:
     sys.exit(0)
 print('maketest: ' + os.path.basename(os.path.dirname(sys.argv[1])))
 
-path = sys.argv[1]
-if path[-1] == '/':
-    # msys1 has a bug that `make` fails to include `../tools.mk` (parent dir)
-    # if `-C path` option is given and `path` is absolute directory with
-    # trailing slash (`c:/path/to/test/`).
-    # the easist workaround is to remove the slash (`c:/path/to/test`).
-    # msys2 seems to fix this problem.
-    path = path[:-1]
-
-proc = subprocess.Popen([make, '-C', path],
+proc = subprocess.Popen([make, '-C', sys.argv[1]],
                         stdout = subprocess.PIPE,
                         stderr = subprocess.PIPE)
 out, err = proc.communicate()

branches/try2/src/librustc/front/config.rs

@@ -70,7 +70,6 @@ fn fold_mod(cx: &mut Context, m: &ast::Mod) -> ast::Mod {
         filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
     }).collect();
     ast::Mod {
-        inner: m.inner,
         view_items: filtered_view_items,
         items: flattened_items
     }

branches/try2/src/librustc/front/test.rs

@@ -143,7 +143,6 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
         }
 
         let mod_nomain = ast::Mod {
-            inner: m.inner,
             view_items: m.view_items.clone(),
             items: m.items.iter().map(|i| nomain(&self.cx, *i)).collect(),
         };
@@ -336,7 +335,6 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::Item {
     )).unwrap();
 
     let testmod = ast::Mod {
-        inner: DUMMY_SP,
         view_items: view_items,
         items: vec!(mainfn, tests),
     };

branches/try2/src/librustdoc/clean.rs

@@ -227,27 +227,10 @@ impl Clean<Item> for doctree::Module {
             self.view_items.clean().move_iter().collect(),
             self.macros.clean().move_iter().collect()
         );
-
-        // determine if we should display the inner contents or
-        // the outer `mod` item for the source code.
-        let where = {
-            let ctxt = local_data::get(super::ctxtkey, |x| *x.unwrap());
-            let cm = ctxt.sess().codemap();
-            let outer = cm.lookup_char_pos(self.where_outer.lo);
-            let inner = cm.lookup_char_pos(self.where_inner.lo);
-            if outer.file.start_pos == inner.file.start_pos {
-                // mod foo { ... }
-                self.where_outer
-            } else {
-                // mod foo; (and a separate FileMap for the contents)
-                self.where_inner
-            }
-        };
-
         Item {
             name: Some(name),
             attrs: self.attrs.clean(),
-            source: where.clean(),
+            source: self.where.clean(),
             visibility: self.vis.clean(),
             id: self.id,
             inner: ModuleItem(Module {

branches/try2/src/librustdoc/doctree.rs

@@ -19,8 +19,7 @@ use syntax::ast::{Ident, NodeId};
 pub struct Module {
     pub name: Option<Ident>,
     pub attrs: Vec<ast::Attribute>,
-    pub where_outer: Span,
-    pub where_inner: Span,
+    pub where: Span,
     pub structs: Vec<Struct>,
     pub enums: Vec<Enum>,
     pub fns: Vec<Function>,
@@ -43,8 +42,7 @@ impl Module {
             name       : name,
             id: 0,
             vis: ast::Inherited,
-            where_outer: syntax::codemap::DUMMY_SP,
-            where_inner: syntax::codemap::DUMMY_SP,
+            where: syntax::codemap::DUMMY_SP,
             attrs      : Vec::new(),
             structs    : Vec::new(),
             enums      : Vec::new(),

branches/try2/src/librustdoc/visit_ast.rs

@@ -118,8 +118,7 @@ impl<'a> RustdocVisitor<'a> {
         for item in m.view_items.iter() {
             self.visit_view_item(item, &mut om);
         }
-        om.where_outer = span;
-        om.where_inner = m.inner;
+        om.where = span;
         om.attrs = attrs;
         om.vis = vis;
         om.id = id;

branches/try2/src/librustuv/lib.rs

@@ -88,10 +88,7 @@ mod homing;
 mod queue;
 mod rc;
 
-/// The implementation of `rtio` for libuv
 pub mod uvio;
-
-/// C bindings to libuv
 pub mod uvll;
 
 pub mod file;

branches/try2/src/librustuv/uvio.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+//! The implementation of `rtio` for libuv
+
 use std::c_str::CString;
 use std::cast;
 use std::io::IoError;

branches/try2/src/libstd/mem.rs

@@ -248,38 +248,6 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
 /**
  * Replace the value at a mutable location with a new one, returning the old
  * value, without deinitialising or copying either one.
- *
- * This is primarily used for transferring and swapping ownership of a value
- * in a mutable location. For example, this function allows consumption of
- * one field of a struct by replacing it with another value. The normal approach
- * doesn't always work:
- *
- * ```rust,ignore
- * struct Buffer<T> { buf: Vec<T> }
- *
- * impl<T> Buffer<T> {
- *     fn get_and_reset(&mut self) -> Vec<T> {
- *         // error: cannot move out of dereference of `&mut`-pointer
- *         let buf = self.buf;
- *         self.buf = Vec::new();
- *         buf
- *     }
- * }
- * ```
- *
- * Note that `T` does not necessarily implement `Clone`, so it can't even
- * clone and reset `self.buf`. But `replace` can be used to disassociate
- * the original value of `self.buf` from `self`, allowing it to be returned:
- *
- * ```rust
- * # struct Buffer<T> { buf: Vec<T> }
- * impl<T> Buffer<T> {
- *     fn get_and_reset(&mut self) -> Vec<T> {
- *         use std::mem::replace;
- *         replace(&mut self.buf, Vec::new())
- *     }
- * }
- * ```
  */
 #[inline]
 pub fn replace<T>(dest: &mut T, mut src: T) -> T {

branches/try2/src/libstd/rt/backtrace.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+//! Simple backtrace functionality (to print on failure)
+
 #![allow(non_camel_case_types)]
 
 use char::Char;

branches/try2/src/libstd/rt/global_heap.rs

@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
+//! The global (exchange) heap.
+
 use libc::{c_void, size_t, free, malloc, realloc};
 use ptr::{RawPtr, mut_null};
 use intrinsics::abort;

branches/try2/src/libstd/rt/mod.rs

@@ -85,44 +85,44 @@ pub mod shouldnt_be_public {
 // Internal macros used by the runtime.
 mod macros;
 
-/// The global (exchange) heap.
+// The global (exchange) heap.
 pub mod global_heap;
 
-/// Implementations of language-critical runtime features like @.
+// Implementations of language-critical runtime features like @.
 pub mod task;
 
-/// The EventLoop and internal synchronous I/O interface.
+// The EventLoop and internal synchronous I/O interface.
 pub mod rtio;
 
-/// The Local trait for types that are accessible via thread-local
-/// or task-local storage.
+// The Local trait for types that are accessible via thread-local
+// or task-local storage.
 pub mod local;
 
-/// Bindings to system threading libraries.
+// Bindings to system threading libraries.
 pub mod thread;
 
-/// The runtime configuration, read from environment variables.
+// The runtime configuration, read from environment variables.
 pub mod env;
 
-/// The local, managed heap
+// The local, managed heap
 pub mod local_heap;
 
-/// The runtime needs to be able to put a pointer into thread-local storage.
+// The runtime needs to be able to put a pointer into thread-local storage.
 mod local_ptr;
 
-/// Bindings to pthread/windows thread-local storage.
+// Bindings to pthread/windows thread-local storage.
 mod thread_local_storage;
 
-/// Stack unwinding
+// Stack unwinding
 pub mod unwind;
 
-/// The interface to libunwind that rust is using.
+// The interface to libunwind that rust is using.
 mod libunwind;
 
-/// Simple backtrace functionality (to print on failure)
+// Simple backtrace functionality (to print on failure)
 pub mod backtrace;
 
-/// Just stuff
+// Just stuff
 mod util;
 
 // Global command line argument storage

branches/try2/src/libstd/rt/rtio.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+//! The EventLoop and internal synchronous I/O interface.
+
 use c_str::CString;
 use cast;
 use comm::{Sender, Receiver};

branches/try2/src/libstd/rt/unwind.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+//! Stack unwinding
+
 // Implementation of Rust stack unwinding
 //
 // For background on exception handling and stack unwinding please see

branches/try2/src/libstd/vec.rs

@@ -1288,7 +1288,7 @@ impl<T:Eq> Vec<T> {
             //     +---+---+---+---+---+---+
             //           w
             //
-            // Comparing self[r] against self[w-1], this is not a duplicate, so
+            // Comparing self[r] against self[w-1], tis is not a duplicate, so
             // we swap self[r] and self[w] (no effect as r==w) and then increment both
             // r and w, leaving us with:
             //

branches/try2/src/libsyntax/ast.rs

@@ -921,12 +921,8 @@ pub struct Method {
 
 #[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)]
 pub struct Mod {
-    /// A span from the first token past `{` to the last token until `}`.
-    /// For `mod foo;`, the inner span ranges from the first token
-    /// to the last token in the external file.
-    pub inner: Span,
-    pub view_items: Vec<ViewItem>,
-    pub items: Vec<@Item>,
+    pub view_items: Vec<ViewItem> ,
+    pub items: Vec<@Item> ,
 }
 
 #[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)]
@@ -1169,15 +1165,7 @@ mod test {
     fn check_asts_encodable() {
         use std::io;
         let e = Crate {
-            module: Mod {
-                inner: Span {
-                    lo: BytePos(11),
-                    hi: BytePos(19),
-                    expn_info: None,
-                },
-                view_items: Vec::new(),
-                items: Vec::new(),
-            },
+            module: Mod {view_items: Vec::new(), items: Vec::new()},
             attrs: Vec::new(),
             config: Vec::new(),
             span: Span {

branches/try2/src/libsyntax/ext/build.rs

@@ -220,7 +220,7 @@ pub trait AstBuilder {
                         generics: Generics) -> @ast::Item;
     fn item_struct(&self, span: Span, name: Ident, struct_def: ast::StructDef) -> @ast::Item;
 
-    fn item_mod(&self, span: Span, inner_span: Span,
+    fn item_mod(&self, span: Span,
                 name: Ident, attrs: Vec<ast::Attribute> ,
                 vi: Vec<ast::ViewItem> , items: Vec<@ast::Item> ) -> @ast::Item;
 
@@ -898,7 +898,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         self.item(span, name, Vec::new(), ast::ItemStruct(@struct_def, generics))
     }
 
-    fn item_mod(&self, span: Span, inner_span: Span, name: Ident,
+    fn item_mod(&self, span: Span, name: Ident,
                 attrs: Vec<ast::Attribute> ,
                 vi: Vec<ast::ViewItem> ,
                 items: Vec<@ast::Item> ) -> @ast::Item {
@@ -907,7 +907,6 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             name,
             attrs,
             ast::ItemMod(ast::Mod {
-                inner: inner_span,
                 view_items: vi,
                 items: items,
             })

branches/try2/src/libsyntax/fold.rs

@@ -652,7 +652,6 @@ pub fn noop_fold_type_method<T: Folder>(m: &TypeMethod, fld: &mut T) -> TypeMeth
 
 pub fn noop_fold_mod<T: Folder>(m: &Mod, folder: &mut T) -> Mod {
     ast::Mod {
-        inner: folder.new_span(m.inner),
         view_items: m.view_items
                      .iter()
                      .map(|x| folder.fold_view_item(x)).collect(),