---

yaml
---
r: 235388
b: refs/heads/stable
c: 7fb8208
h: refs/heads/master
v: v3

Author: nrc

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 07be6299d89b24e59514b5d3fe13abed5b17e50e
+refs/heads/stable: 7fb8208758ceb25ed8e1beafc1b5ddb41315d32e
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/librustc/middle/fast_reject.rs

@@ -71,8 +71,10 @@ pub fn simplify_type(tcx: &ty::ctxt,
         }
         ty::TyBox(_) => {
             // treat like we would treat `Box`
-            let def_id = tcx.lang_items.owned_box().unwrap();
-            Some(StructSimplifiedType(def_id))
+            match tcx.lang_items.require_owned_box() {
+                Ok(def_id) => Some(StructSimplifiedType(def_id)),
+                Err(msg) => tcx.sess.fatal(&msg),
+            }
         }
         ty::TyClosure(def_id, _) => {
             Some(ClosureSimplifiedType(def_id))

branches/stable/src/librustc/middle/lang_items.rs

@@ -90,6 +90,10 @@ impl LanguageItems {
         }
     }
 
+    pub fn require_owned_box(&self) -> Result<ast::DefId, String> {
+        self.require(OwnedBoxLangItem)
+    }
+
     pub fn from_builtin_kind(&self, bound: ty::BuiltinBound)
                              -> Result<ast::DefId, String>
     {

branches/stable/src/librustc_typeck/coherence/orphan.rs

@@ -77,7 +77,10 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
                         self.check_def_id(item, data.principal_def_id());
                     }
                     ty::TyBox(..) => {
-                        self.check_def_id(item, self.tcx.lang_items.owned_box().unwrap());
+                        match self.tcx.lang_items.require_owned_box() {
+                            Ok(trait_id) => self.check_def_id(item, trait_id),
+                            Err(msg) => self.tcx.sess.span_fatal(item.span, &msg),
+                        }
                     }
                     ty::TyChar => {
                         self.check_primitive_impl(def_id,

branches/stable/src/libstd/thread/local.rs

@@ -275,7 +275,6 @@ mod imp {
 
     use cell::{Cell, UnsafeCell};
     use intrinsics;
-    use ptr;
 
     pub struct Key<T> {
         inner: UnsafeCell<Option<T>>,
@@ -328,6 +327,7 @@ mod imp {
     #[cfg(target_os = "linux")]
     unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern fn(*mut u8)) {
         use mem;
+        use ptr;
         use libc;
         use sys_common::thread_local as os;
 
@@ -394,24 +394,7 @@ mod imp {
         // destructor as running for this thread so calls to `get` will return
         // `None`.
         (*ptr).dtor_running.set(true);
-
-        // The OSX implementation of TLS apparently had an odd aspect to it
-        // where the pointer we have may be overwritten while this destructor
-        // is running. Specifically if a TLS destructor re-accesses TLS it may
-        // trigger a re-initialization of all TLS variables, paving over at
-        // least some destroyed ones with initial values.
-        //
-        // This means that if we drop a TLS value in place on OSX that we could
-        // revert the value to its original state halfway through the
-        // destructor, which would be bad!
-        //
-        // Hence, we use `ptr::read` on OSX (to move to a "safe" location)
-        // instead of drop_in_place.
-        if cfg!(target_os = "macos") {
-            ptr::read((*ptr).inner.get());
-        } else {
-            intrinsics::drop_in_place((*ptr).inner.get());
-        }
+        intrinsics::drop_in_place((*ptr).inner.get());
     }
 }
 

branches/stable/src/libsyntax/parse/lexer/mod.rs

@@ -172,11 +172,6 @@ impl<'a> StringReader<'a> {
         self.span_diagnostic.span_err(sp, m)
     }
 
-    /// Suggest some help with a given span.
-    pub fn help_span(&self, sp: Span, m: &str) {
-        self.span_diagnostic.span_help(sp, m)
-    }
-
     /// Report a fatal error spanning [`from_pos`, `to_pos`).
     fn fatal_span_(&self, from_pos: BytePos, to_pos: BytePos, m: &str) -> ! {
         self.fatal_span(codemap::mk_sp(from_pos, to_pos), m)
@@ -187,11 +182,6 @@ impl<'a> StringReader<'a> {
         self.err_span(codemap::mk_sp(from_pos, to_pos), m)
     }
 
-    /// Suggest some help spanning [`from_pos`, `to_pos`).
-    fn help_span_(&self, from_pos: BytePos, to_pos: BytePos, m: &str) {
-        self.help_span(codemap::mk_sp(from_pos, to_pos), m)
-    }
-
     /// Report a lexical error spanning [`from_pos`, `to_pos`), appending an
     /// escaped character to the error message
     fn fatal_span_char(&self, from_pos: BytePos, to_pos: BytePos, m: &str, c: char) -> ! {
@@ -738,24 +728,19 @@ impl<'a> StringReader<'a> {
                         return match e {
                             'n' | 'r' | 't' | '\\' | '\'' | '"' | '0' => true,
                             'x' => self.scan_byte_escape(delim, !ascii_only),
-                            'u' => {
-                                let valid = if self.curr_is('{') {
-                                    self.scan_unicode_escape(delim) && !ascii_only
-                                } else {
-                                    self.err_span_(start, self.last_pos,
-                                        "incorrect unicode escape sequence");
-                                    self.help_span_(start, self.last_pos,
-                                        "format of unicode escape sequences is `\\u{…}`");
-                                    false
-                                };
-                                if ascii_only {
-                                    self.err_span_(start, self.last_pos,
+                            'u' if self.curr_is('{') => {
+                                let valid = self.scan_unicode_escape(delim);
+                                if valid && ascii_only {
+                                    self.err_span_(
+                                        escaped_pos,
+                                        self.last_pos,
                                         "unicode escape sequences cannot be used as a byte or in \
                                         a byte string"
                                     );
+                                    false
+                                } else {
+                                   valid
                                 }
-                                valid
-
                             }
                             '\n' if delim == '"' => {
                                 self.consume_whitespace();
@@ -772,13 +757,16 @@ impl<'a> StringReader<'a> {
                                     if ascii_only { "unknown byte escape" }
                                     else { "unknown character escape" },
                                     c);
+                                let sp = codemap::mk_sp(escaped_pos, last_pos);
                                 if e == '\r' {
-                                    self.help_span_(escaped_pos, last_pos,
+                                    self.span_diagnostic.span_help(
+                                        sp,
                                         "this is an isolated carriage return; consider checking \
                                          your editor and version control settings")
                                 }
                                 if (e == '{' || e == '}') && !ascii_only {
-                                    self.help_span_(escaped_pos, last_pos,
+                                    self.span_diagnostic.span_help(
+                                        sp,
                                         "if used in a formatting string, \
                                         curly braces are escaped with `{{` and `}}`")
                                 }
@@ -860,12 +848,14 @@ impl<'a> StringReader<'a> {
             valid = false;
         }
 
+        self.bump(); // past the ending }
+
         if valid && (char::from_u32(accum_int).is_none() || count == 0) {
             self.err_span_(start_bpos, self.last_pos, "illegal unicode character escape");
             valid = false;
         }
 
-        self.bump(); // past the ending }
+
         valid
     }
 

branches/stable/src/libsyntax/parse/parser.rs

@@ -60,7 +60,7 @@ use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple};
 use ast::{Visibility, WhereClause};
 use ast;
 use ast_util::{self, AS_PREC, ident_to_path, operator_prec};
-use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp, CodeMap};
+use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp};
 use diagnostic;
 use ext::tt::macro_parser;
 use parse;
@@ -297,24 +297,6 @@ fn is_plain_ident_or_underscore(t: &token::Token) -> bool {
     t.is_plain_ident() || *t == token::Underscore
 }
 
-/// Information about the path to a module.
-pub struct ModulePath {
-    pub name: String,
-    pub path_exists: bool,
-    pub result: Result<ModulePathSuccess, ModulePathError>,
-}
-
-pub struct ModulePathSuccess {
-    pub path: ::std::path::PathBuf,
-    pub owns_directory: bool,
-}
-
-pub struct ModulePathError {
-    pub err_msg: String,
-    pub help_msg: String,
-}
-
-
 impl<'a> Parser<'a> {
     pub fn new(sess: &'a ParseSess,
                cfg: ast::CrateConfig,
@@ -4877,104 +4859,82 @@ impl<'a> Parser<'a> {
         self.mod_path_stack.pop().unwrap();
     }
 
-    pub fn submod_path_from_attr(attrs: &[ast::Attribute], dir_path: &Path) -> Option<PathBuf> {
-        ::attr::first_attr_value_str_by_name(attrs, "path").map(|d| dir_path.join(&*d))
-    }
-
-    /// Returns either a path to a module, or .
-    pub fn default_submod_path(id: ast::Ident, dir_path: &Path, codemap: &CodeMap) -> ModulePath
-    {
-        let mod_string = token::get_ident(id);
-        let mod_name = mod_string.to_string();
-        let default_path_str = format!("{}.rs", mod_name);
-        let secondary_path_str = format!("{}/mod.rs", mod_name);
-        let default_path = dir_path.join(&default_path_str);
-        let secondary_path = dir_path.join(&secondary_path_str);
-        let default_exists = codemap.file_exists(&default_path);
-        let secondary_exists = codemap.file_exists(&secondary_path);
-
-        let result = match (default_exists, secondary_exists) {
-            (true, false) => Ok(ModulePathSuccess { path: default_path, owns_directory: false }),
-            (false, true) => Ok(ModulePathSuccess { path: secondary_path, owns_directory: true }),
-            (false, false) => Err(ModulePathError {
-                err_msg: format!("file not found for module `{}`", mod_name),
-                help_msg: format!("name the file either {} or {} inside the directory {:?}",
-                                  default_path_str,
-                                  secondary_path_str,
-                                  dir_path.display()),
-            }),
-            (true, true) => Err(ModulePathError {
-                err_msg: format!("file for module `{}` found at both {} and {}",
-                                 mod_name,
-                                 default_path_str,
-                                 secondary_path_str),
-                help_msg: "delete or rename one of them to remove the ambiguity".to_owned(),
-            }),
-        };
-
-        ModulePath {
-            name: mod_name,
-            path_exists: default_exists || secondary_exists,
-            result: result,
-        }
-    }
-
-    fn submod_path(&mut self,
-                   id: ast::Ident,
-                   outer_attrs: &[ast::Attribute],
-                   id_sp: Span) -> PResult<ModulePathSuccess> {
+    /// Read a module from a source file.
+    fn eval_src_mod(&mut self,
+                    id: ast::Ident,
+                    outer_attrs: &[ast::Attribute],
+                    id_sp: Span)
+                    -> PResult<(ast::Item_, Vec<ast::Attribute> )> {
         let mut prefix = PathBuf::from(&self.sess.codemap().span_to_filename(self.span));
         prefix.pop();
         let mut dir_path = prefix;
         for part in &self.mod_path_stack {
             dir_path.push(&**part);
         }
+        let mod_string = token::get_ident(id);
+        let (file_path, owns_directory) = match ::attr::first_attr_value_str_by_name(
+                outer_attrs, "path") {
+            Some(d) => (dir_path.join(&*d), true),
+            None => {
+                let mod_name = mod_string.to_string();
+                let default_path_str = format!("{}.rs", mod_name);
+                let secondary_path_str = format!("{}/mod.rs", mod_name);
+                let default_path = dir_path.join(&default_path_str[..]);
+                let secondary_path = dir_path.join(&secondary_path_str[..]);
+                let default_exists = self.sess.codemap().file_exists(&default_path);
+                let secondary_exists = self.sess.codemap().file_exists(&secondary_path);
+
+                if !self.owns_directory {
+                    self.span_err(id_sp,
+                                  "cannot declare a new module at this location");
+                    let this_module = match self.mod_path_stack.last() {
+                        Some(name) => name.to_string(),
+                        None => self.root_module_name.as_ref().unwrap().clone(),
+                    };
+                    self.span_note(id_sp,
+                                   &format!("maybe move this module `{0}` \
+                                            to its own directory via \
+                                            `{0}/mod.rs`",
+                                           this_module));
+                    if default_exists || secondary_exists {
+                        self.span_note(id_sp,
+                                       &format!("... or maybe `use` the module \
+                                                `{}` instead of possibly \
+                                                redeclaring it",
+                                               mod_name));
+                    }
+                    self.abort_if_errors();
+                }
 
-        if let Some(p) = Parser::submod_path_from_attr(outer_attrs, &dir_path) {
-            return Ok(ModulePathSuccess { path: p, owns_directory: true });
-        }
-
-        let paths = Parser::default_submod_path(id, &dir_path, self.sess.codemap());
-
-        if !self.owns_directory {
-            self.span_err(id_sp, "cannot declare a new module at this location");
-            let this_module = match self.mod_path_stack.last() {
-                Some(name) => name.to_string(),
-                None => self.root_module_name.as_ref().unwrap().clone(),
-            };
-            self.span_note(id_sp,
-                           &format!("maybe move this module `{0}` to its own directory \
-                                     via `{0}/mod.rs`",
-                                    this_module));
-            if paths.path_exists {
-                self.span_note(id_sp,
-                               &format!("... or maybe `use` the module `{}` instead \
-                                         of possibly redeclaring it",
-                                        paths.name));
+                match (default_exists, secondary_exists) {
+                    (true, false) => (default_path, false),
+                    (false, true) => (secondary_path, true),
+                    (false, false) => {
+                        return Err(self.span_fatal_help(id_sp,
+                                             &format!("file not found for module `{}`",
+                                                     mod_name),
+                                             &format!("name the file either {} or {} inside \
+                                                     the directory {:?}",
+                                                     default_path_str,
+                                                     secondary_path_str,
+                                                     dir_path.display())));
+                    }
+                    (true, true) => {
+                        return Err(self.span_fatal_help(
+                            id_sp,
+                            &format!("file for module `{}` found at both {} \
+                                     and {}",
+                                    mod_name,
+                                    default_path_str,
+                                    secondary_path_str),
+                            "delete or rename one of them to remove the ambiguity"));
+                    }
+                }
             }
-            self.abort_if_errors();
-        }
-
-        match paths.result {
-            Ok(succ) => Ok(succ),
-            Err(err) => Err(self.span_fatal_help(id_sp, &err.err_msg, &err.help_msg)),
-        }
-    }
+        };
 
-    /// Read a module from a source file.
-    fn eval_src_mod(&mut self,
-                    id: ast::Ident,
-                    outer_attrs: &[ast::Attribute],
-                    id_sp: Span)
-                    -> PResult<(ast::Item_, Vec<ast::Attribute> )> {
-        let ModulePathSuccess { path, owns_directory } = try!(self.submod_path(id,
-                                                                               outer_attrs,
-                                                                               id_sp));
-
-        self.eval_src_mod_from_path(path,
-                                    owns_directory,
-                                    token::get_ident(id).to_string(),
-                                    id_sp)
+        self.eval_src_mod_from_path(file_path, owns_directory,
+                                    mod_string.to_string(), id_sp)
     }
 
     fn eval_src_mod_from_path(&mut self,