---

yaml
---
r: 114616
b: refs/heads/auto
c: ea46a74
h: refs/heads/master
v: v3

Author: aaronraimist

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 5c16cf975d8aec57f8e4681d4500483c8f053385
+refs/heads/auto: ea46a7406acc8d1599c81f9b288b262e175fe9e5
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/CONTRIBUTING.md

@@ -33,11 +33,11 @@ message explaining why.
 
 In the licensing header at the beginning of any files you change,
 please make sure the listed date range includes the current year.  For
-example, if it's 2013, and you change a Rust file that was created in
+example, if it's 2014, and you change a Rust file that was created in
 2010, it should begin:
 
 ```
-// Copyright 2010-2013 The Rust Project Developers.
+// Copyright 2010-2014 The Rust Project Developers.
 ```
 
 For more details, please refer to

branches/auto/src/doc/guide-tasks.md

@@ -89,10 +89,9 @@ closure in the new task.
 fn print_message() { println!("I am running in a different task!"); }
 spawn(print_message);
 
-// Print something profound in a different task using a `proc` expression
-// The `proc` expression evaluates to an (unnamed) owned closure.
-// That closure will call `println!(...)` when the spawned task runs.
-
+// Print something more profound in a different task using a lambda expression
+// This uses the proc() keyword to assign to spawn a function with no name
+// That function will call println!(...) as requested
 spawn(proc() println!("I am also running in a different task!") );
 ~~~~
 

branches/auto/src/doc/intro.md

@@ -370,7 +370,7 @@ fn main() {
 ```
 
 This example is starting to get more subtle,
-but it hints at the powerful composability of Rust's concurrent types.
+but it hints at the powerful compositionality of Rust's concurrent types.
 This time we've put our array of numbers inside a `Mutex` and then put *that* inside the `Arc`.
 Like immutable data,
 `Mutex`es are sharable,

branches/auto/src/etc/vim/indent/rust.vim

@@ -30,7 +30,7 @@ endif
 
 " Come here when loading the script the first time.
 
-function! s:get_line_trimmed(lnum)
+function s:get_line_trimmed(lnum)
 	" Get the line and remove a trailing comment.
 	" Use syntax highlighting attributes when possible.
 	" NOTE: this is not accurate; /* */ or a line continuation could trick it
@@ -61,20 +61,6 @@ function! s:get_line_trimmed(lnum)
 	endif
 endfunction
 
-function! s:is_string_comment(lnum, col)
-	if has('syntax_items')
-		for id in synstack(a:lnum, a:col)
-			let synname = synIDattr(id, "name")
-			if synname == "rustString" || synname =~ "^rustComment"
-				return 1
-			endif
-		endfor
-	else
-		" without syntax, let's not even try
-		return 0
-	endif
-endfunction
-
 function GetRustIndent(lnum)
 
 	" Starting assumption: cindent (called at the end) will do it right
@@ -166,10 +152,8 @@ function GetRustIndent(lnum)
 	" column zero)
 
 	call cursor(a:lnum, 1)
-	if searchpair('{\|(', '', '}\|)', 'nbW'
-				\ 's:is_string_comment(line("."), col("."))') == 0
-		if searchpair('\[', '', '\]', 'nbW',
-					\ 's:is_string_comment(line("."), col("."))') == 0
+	if searchpair('{\|(', '', '}\|)', 'nbW') == 0
+		if searchpair('\[', '', '\]', 'nbW') == 0
 			" Global scope, should be zero
 			return 0
 		else

branches/auto/src/libarena/lib.rs

@@ -26,7 +26,7 @@
 
 extern crate collections;
 
-use std::cast::{transmute, transmute_mut_lifetime};
+use std::cast::{transmute, transmute_mut, transmute_mut_lifetime};
 use std::cast;
 use std::cell::{Cell, RefCell};
 use std::mem;
@@ -281,8 +281,8 @@ impl Arena {
     #[inline]
     pub fn alloc<'a, T>(&'a self, op: || -> T) -> &'a T {
         unsafe {
-            // FIXME #13933: Remove/justify all `&T` to `&mut T` transmutes
-            let this: &mut Arena = transmute::<&_, &mut _>(self);
+            // FIXME: Borrow check
+            let this = transmute_mut(self);
             if intrinsics::needs_drop::<T>() {
                 this.alloc_noncopy(op)
             } else {
@@ -438,8 +438,7 @@ impl<T> TypedArena<T> {
     #[inline]
     pub fn alloc<'a>(&'a self, object: T) -> &'a T {
         unsafe {
-            // FIXME #13933: Remove/justify all `&T` to `&mut T` transmutes
-            let this: &mut TypedArena<T> = cast::transmute::<&_, &mut _>(self);
+            let this = cast::transmute_mut(self);
             if this.ptr == this.end {
                 this.grow()
             }

branches/auto/src/liblog/directive.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::ascii::StrAsciiExt;
 use std::cmp;
 
 #[deriving(Show, Clone)]
@@ -17,13 +16,13 @@ pub struct LogDirective {
     pub level: u32,
 }
 
-pub static LOG_LEVEL_NAMES: [&'static str, ..4] = ["ERROR", "WARN", "INFO",
-                                               "DEBUG"];
+static LOG_LEVEL_NAMES: [&'static str, ..4] = ["error", "warn", "info",
+                                               "debug"];
 
 /// Parse an individual log level that is either a number or a symbolic log level
 fn parse_log_level(level: &str) -> Option<u32> {
     from_str::<u32>(level).or_else(|| {
-        let pos = LOG_LEVEL_NAMES.iter().position(|&name| name.eq_ignore_ascii_case(level));
+        let pos = LOG_LEVEL_NAMES.iter().position(|&name| name == level);
         pos.map(|p| p as u32 + 1)
     }).map(|p| cmp::min(p, ::MAX_LOG_LEVEL))
 }

branches/auto/src/liblog/lib.rs

@@ -129,8 +129,6 @@ use std::slice;
 
 use sync::one::{Once, ONCE_INIT};
 
-use directive::LOG_LEVEL_NAMES;
-
 pub mod macros;
 mod directive;
 
@@ -164,42 +162,19 @@ local_data_key!(local_logger: ~Logger:Send)
 /// can have its own custom logger which can respond to logging messages
 /// however it likes.
 pub trait Logger {
-    /// Logs a single message described by the `record`.
-    fn log(&mut self, record: &LogRecord);
+    /// Logs a single message described by the `args` structure. The level is
+    /// provided in case you want to do things like color the message, etc.
+    fn log(&mut self, level: u32, args: &fmt::Arguments);
 }
 
 struct DefaultLogger {
     handle: LineBufferedWriter<io::stdio::StdWriter>,
 }
 
-/// Wraps the log level with fmt implementations.
-#[deriving(Eq, Ord)]
-pub struct LogLevel(pub u32);
-
-impl fmt::Show for LogLevel {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let LogLevel(level) = *self;
-        match LOG_LEVEL_NAMES.get(level as uint - 1) {
-            Some(name) => name.fmt(fmt),
-            None => level.fmt(fmt)
-        }
-    }
-}
-
-impl fmt::Signed for LogLevel {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let LogLevel(level) = *self;
-        write!(fmt.buf, "{}", level)
-    }
-}
-
 impl Logger for DefaultLogger {
-    fn log(&mut self, record: &LogRecord) {
-        match write!(&mut self.handle,
-                     "{}:{}: {}",
-                     record.level,
-                     record.module_path,
-                     record.args) {
+    // by default, just ignore the level
+    fn log(&mut self, _level: u32, args: &fmt::Arguments) {
+        match fmt::writeln(&mut self.handle, args) {
             Err(e) => fail!("failed to log: {}", e),
             Ok(()) => {}
         }
@@ -223,21 +198,14 @@ impl Drop for DefaultLogger {
 ///
 /// It is not recommended to call this function directly, rather it should be
 /// invoked through the logging family of macros.
-#[doc(hidden)]
-pub fn log(level: u32, loc: &'static LogLocation, args: &fmt::Arguments) {
+pub fn log(level: u32, args: &fmt::Arguments) {
     // Completely remove the local logger from TLS in case anyone attempts to
     // frob the slot while we're doing the logging. This will destroy any logger
     // set during logging.
     let mut logger = local_data::pop(local_logger).unwrap_or_else(|| {
         box DefaultLogger { handle: io::stderr() } as ~Logger:Send
     });
-    logger.log(&LogRecord {
-        level: LogLevel(level),
-        args: args,
-        file: loc.file,
-        module_path: loc.module_path,
-        line: loc.line,
-    });
+    logger.log(level, args);
     local_data::set(local_logger, logger);
 }
 
@@ -255,34 +223,6 @@ pub fn set_logger(logger: ~Logger:Send) -> Option<~Logger:Send> {
     return prev;
 }
 
-/// A LogRecord is created by the logging macros, and passed as the only
-/// argument to Loggers.
-#[deriving(Show)]
-pub struct LogRecord<'a> {
-
-    /// The module path of where the LogRecord originated.
-    pub module_path: &'a str,
-
-    /// The LogLevel of this record.
-    pub level: LogLevel,
-
-    /// The arguments from the log line.
-    pub args: &'a fmt::Arguments<'a>,
-
-    /// The file of where the LogRecord originated.
-    pub file: &'a str,
-
-    /// The line number of where the LogRecord originated.
-    pub line: uint,
-}
-
-#[doc(hidden)]
-pub struct LogLocation {
-    pub module_path: &'static str,
-    pub file: &'static str,
-    pub line: uint,
-}
-
 /// Tests whether a given module's name is enabled for a particular level of
 /// logging. This is the second layer of defense about determining whether a
 /// module's log statement should be emitted or not.

branches/auto/src/liblog/macros.rs

@@ -33,14 +33,9 @@
 #[macro_export]
 macro_rules! log(
     ($lvl:expr, $($arg:tt)+) => ({
-        static LOC: ::log::LogLocation = ::log::LogLocation {
-            line: line!(),
-            file: file!(),
-            module_path: module_path!(),
-        };
         let lvl = $lvl;
         if log_enabled!(lvl) {
-            format_args!(|args| { ::log::log(lvl, &LOC, args) }, $($arg)+)
+            format_args!(|args| { ::log::log(lvl, args) }, $($arg)+)
         }
     })
 )

branches/auto/src/libnative/io/file_win32.rs

@@ -174,8 +174,7 @@ impl rtio::RtioFileStream for FileDesc {
     fn tell(&self) -> Result<u64, IoError> {
         // This transmute is fine because our seek implementation doesn't
         // actually use the mutable self at all.
-        // FIXME #13933: Remove/justify all `&T` to `&mut T` transmutes
-        unsafe { cast::transmute::<&_, &mut FileDesc>(self).seek(0, io::SeekCur) }
+        unsafe { cast::transmute_mut(self).seek(0, io::SeekCur) }
     }
 
     fn fsync(&mut self) -> Result<(), IoError> {

branches/auto/src/librustc/middle/lint.rs

@@ -1270,7 +1270,7 @@ fn check_pat_uppercase_variable(cx: &Context, p: &ast::Pat) {
                     // last identifier alone is right choice for this lint.
                     let ident = path.segments.last().unwrap().identifier;
                     let s = token::get_ident(ident);
-                    if s.get().len() > 0 && s.get().char_at(0).is_uppercase() {
+                    if s.get().char_at(0).is_uppercase() {
                         cx.span_lint(
                             UppercaseVariables,
                             path.span,