---

yaml
---
r: 273209
b: refs/heads/beta
c: 7a2c50f
h: refs/heads/master
i:
  273207: b1f29fe

Author: oli-obk

[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: 6e0f2f2f050443f2aec4e9c7d25618a6a6639b83
+refs/heads/beta: 7a2c50f9512ff5816aeb5e3341d0b3c217ba88f8
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/compiler-rt

@@ -1 +1 @@
-Subproject commit 57315f7e07d09b6f0341ebbcd50dded6c20d782f
+Subproject commit b6087e82ba1384c4af3adf2dc68e92316f0d4caf

branches/beta/src/librustc/middle/const_eval.rs

@@ -671,7 +671,7 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &TyCtxt<'tcx>,
       }
       hir::ExprBinary(op, ref a, ref b) => {
         let b_ty = match op.node {
-            hir::BiShl | hir::BiShr => ty_hint.checked_or(tcx.types.usize),
+            hir::BiShl | hir::BiShr => ty_hint.erase_hint(),
             _ => ty_hint
         };
         // technically, if we don't have type hints, but integral eval

branches/beta/src/librustc/middle/liveness.rs

@@ -112,9 +112,7 @@ use self::VarKind::*;
 use dep_graph::DepNode;
 use middle::def::*;
 use middle::pat_util;
-use middle::ty::{self, TyCtxt, ParameterEnvironment};
-use middle::traits::{self, ProjectionMode};
-use middle::infer;
+use middle::ty::{self, TyCtxt};
 use lint;
 use util::nodemap::NodeMap;
 
@@ -1492,19 +1490,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
 
         match fn_ret {
             ty::FnConverging(t_ret)
-                    if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => {
-
-                let param_env = ParameterEnvironment::for_item(&self.ir.tcx, id);
-                let infcx = infer::new_infer_ctxt(&self.ir.tcx,
-                                                  &self.ir.tcx.tables,
-                                                  Some(param_env),
-                                                  ProjectionMode::Any);
-                let cause = traits::ObligationCause::dummy();
-                let norm = traits::fully_normalize(&infcx,
-                                                   cause,
-                                                   &t_ret);
-
-                if norm.unwrap().is_nil() {
+                if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => {
+
+                if t_ret.is_nil() {
                     // for nil return types, it is ok to not return a value expl.
                 } else {
                     let ends_with_stmt = match body.expr {

branches/beta/src/librustc_resolve/build_reduced_graph.rs

@@ -105,8 +105,36 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
     /// otherwise, reports an error.
     fn define<T: ToNameBinding<'b>>(&self, parent: Module<'b>, name: Name, ns: Namespace, def: T) {
         let binding = def.to_name_binding();
-        if let Err(old_binding) = parent.try_define_child(name, ns, binding.clone()) {
-            self.report_conflict(parent, name, ns, old_binding, &binding);
+        let old_binding = match parent.try_define_child(name, ns, binding.clone()) {
+            Ok(()) => return,
+            Err(old_binding) => old_binding,
+        };
+
+        let span = binding.span.unwrap_or(DUMMY_SP);
+        if !old_binding.is_extern_crate() && !binding.is_extern_crate() {
+            // Record an error here by looking up the namespace that had the duplicate
+            let ns_str = match ns { TypeNS => "type or module", ValueNS => "value" };
+            let resolution_error = ResolutionError::DuplicateDefinition(ns_str, name);
+            let mut err = resolve_struct_error(self, span, resolution_error);
+
+            if let Some(sp) = old_binding.span {
+                let note = format!("first definition of {} `{}` here", ns_str, name);
+                err.span_note(sp, &note);
+            }
+            err.emit();
+        } else if old_binding.is_extern_crate() && binding.is_extern_crate() {
+            span_err!(self.session,
+                      span,
+                      E0259,
+                      "an external crate named `{}` has already been imported into this module",
+                      name);
+        } else {
+            span_err!(self.session,
+                      span,
+                      E0260,
+                      "the name `{}` conflicts with an external crate \
+                      that has been imported into this module",
+                      name);
         }
     }
 

branches/beta/src/librustc_resolve/lib.rs

@@ -183,6 +183,8 @@ pub enum ResolutionError<'a> {
     UndeclaredLabel(&'a str),
     /// error E0427: cannot use `ref` binding mode with ...
     CannotUseRefBindingModeWith(&'a str),
+    /// error E0428: duplicate definition
+    DuplicateDefinition(&'a str, Name),
     /// error E0429: `self` imports are only allowed within a { } list
     SelfImportsOnlyAllowedWithin,
     /// error E0430: `self` import can only appear once in the list
@@ -488,6 +490,14 @@ fn resolve_struct_error<'b, 'a: 'b, 'tcx: 'a>(resolver: &'b Resolver<'a, 'tcx>,
                              "cannot use `ref` binding mode with {}",
                              descr)
         }
+        ResolutionError::DuplicateDefinition(namespace, name) => {
+            struct_span_err!(resolver.session,
+                             span,
+                             E0428,
+                             "duplicate definition of {} `{}`",
+                             namespace,
+                             name)
+        }
         ResolutionError::SelfImportsOnlyAllowedWithin => {
             struct_span_err!(resolver.session,
                              span,
@@ -3520,63 +3530,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             }
         }
     }
-
-    fn report_conflict(&self,
-                       parent: Module,
-                       name: Name,
-                       ns: Namespace,
-                       binding: &NameBinding,
-                       old_binding: &NameBinding) {
-        // Error on the second of two conflicting names
-        if old_binding.span.unwrap().lo > binding.span.unwrap().lo {
-            return self.report_conflict(parent, name, ns, old_binding, binding);
-        }
-
-        let container = match parent.def {
-            Some(Def::Mod(_)) => "module",
-            Some(Def::Trait(_)) => "trait",
-            None => "block",
-            _ => "enum",
-        };
-
-        let (participle, noun) = match old_binding.is_import() || old_binding.is_extern_crate() {
-            true => ("imported", "import"),
-            false => ("defined", "definition"),
-        };
-
-        let span = binding.span.unwrap();
-        let msg = {
-            let kind = match (ns, old_binding.module()) {
-                (ValueNS, _) => "a value",
-                (TypeNS, Some(module)) if module.extern_crate_id.is_some() => "an extern crate",
-                (TypeNS, Some(module)) if module.is_normal() => "a module",
-                (TypeNS, Some(module)) if module.is_trait() => "a trait",
-                (TypeNS, _) => "a type",
-            };
-            format!("{} named `{}` has already been {} in this {}",
-                    kind, name, participle, container)
-        };
-
-        let mut err = match (old_binding.is_extern_crate(), binding.is_extern_crate()) {
-            (true, true) => struct_span_err!(self.session, span, E0259, "{}", msg),
-            (true, _) | (_, true) if binding.is_import() || old_binding.is_import() =>
-                struct_span_err!(self.session, span, E0254, "{}", msg),
-            (true, _) | (_, true) => struct_span_err!(self.session, span, E0260, "{}", msg),
-            _ => match (old_binding.is_import(), binding.is_import()) {
-                (false, false) => struct_span_err!(self.session, span, E0428, "{}", msg),
-                (true, true) => struct_span_err!(self.session, span, E0252, "{}", msg),
-                _ => struct_span_err!(self.session, span, E0255, "{}", msg),
-            },
-        };
-
-        let span = old_binding.span.unwrap();
-        if span != codemap::DUMMY_SP {
-            err.span_note(span, &format!("previous {} of `{}` here", noun, name));
-        }
-        err.emit();
-    }
 }
 
+
 fn names_to_string(names: &[Name]) -> String {
     let mut first = true;
     let mut result = String::new();

branches/beta/src/librustc_resolve/resolve_imports.rs

@@ -513,8 +513,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                 let imported_binding = directive.import(binding, privacy_error);
                 let conflict = module_.try_define_child(target, ns, imported_binding);
                 if let Err(old_binding) = conflict {
-                    let binding = &directive.import(binding, None);
-                    self.resolver.report_conflict(module_, target, ns, binding, old_binding);
+                    self.report_conflict(target, ns, &directive.import(binding, None), old_binding);
                 }
             }
 
@@ -651,6 +650,67 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
         return Success(());
     }
 
+    fn report_conflict(&mut self,
+                       name: Name,
+                       ns: Namespace,
+                       binding: &NameBinding,
+                       old_binding: &NameBinding) {
+        // Error on the second of two conflicting imports
+        if old_binding.is_import() && binding.is_import() &&
+           old_binding.span.unwrap().lo > binding.span.unwrap().lo {
+            self.report_conflict(name, ns, old_binding, binding);
+            return;
+        }
+
+        if old_binding.is_extern_crate() {
+            let msg = format!("import `{0}` conflicts with imported crate \
+                               in this module (maybe you meant `use {0}::*`?)",
+                              name);
+            span_err!(self.resolver.session, binding.span.unwrap(), E0254, "{}", &msg);
+        } else if old_binding.is_import() {
+            let ns_word = match (ns, old_binding.module()) {
+                (ValueNS, _) => "value",
+                (TypeNS, Some(module)) if module.is_normal() => "module",
+                (TypeNS, Some(module)) if module.is_trait() => "trait",
+                (TypeNS, _) => "type",
+            };
+            let mut err = struct_span_err!(self.resolver.session,
+                                           binding.span.unwrap(),
+                                           E0252,
+                                           "a {} named `{}` has already been imported \
+                                            in this module",
+                                           ns_word,
+                                           name);
+            err.span_note(old_binding.span.unwrap(),
+                          &format!("previous import of `{}` here", name));
+            err.emit();
+        } else if ns == ValueNS { // Check for item conflicts in the value namespace
+            let mut err = struct_span_err!(self.resolver.session,
+                                           binding.span.unwrap(),
+                                           E0255,
+                                           "import `{}` conflicts with value in this module",
+                                           name);
+            err.span_note(old_binding.span.unwrap(), "conflicting value here");
+            err.emit();
+        } else { // Check for item conflicts in the type namespace
+            let (what, note) = match old_binding.module() {
+                Some(ref module) if module.is_normal() =>
+                    ("existing submodule", "note conflicting module here"),
+                Some(ref module) if module.is_trait() =>
+                    ("trait in this module", "note conflicting trait here"),
+                _ => ("type in this module", "note conflicting type here"),
+            };
+            let mut err = struct_span_err!(self.resolver.session,
+                                           binding.span.unwrap(),
+                                           E0256,
+                                           "import `{}` conflicts with {}",
+                                           name,
+                                           what);
+            err.span_note(old_binding.span.unwrap(), note);
+            err.emit();
+        }
+    }
+
     // Miscellaneous post-processing, including recording reexports, recording shadowed traits,
     // reporting conflicts, reporting the PRIVATE_IN_PUBLIC lint, and reporting unresolved imports.
     fn finalize_resolutions(&mut self, module: Module<'b>, report_unresolved_imports: bool) {
@@ -660,10 +720,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
 
         let mut reexports = Vec::new();
         for (&(name, ns), resolution) in module.resolutions.borrow().iter() {
-            resolution.report_conflicts(|b1, b2| {
-                self.resolver.report_conflict(module, name, ns, b1, b2)
-            });
-
+            resolution.report_conflicts(|b1, b2| self.report_conflict(name, ns, b1, b2));
             let binding = match resolution.binding {
                 Some(binding) => binding,
                 None => continue,

branches/beta/src/libstd/sys/unix/time.rs

@@ -88,11 +88,11 @@ mod inner {
                         -> Result<Duration, Duration> {
             if self >= other {
                 Ok(if self.t.tv_usec >= other.t.tv_usec {
-                    Duration::new((self.t.tv_sec - other.t.tv_sec) as u64,
-                                  ((self.t.tv_usec -
-                                    other.t.tv_usec) as u32) * 1000)
+                    Duration::new(self.t.tv_sec as u64 - other.t.tv_sec as u64,
+                                  (self.t.tv_usec as u32 -
+                                   other.t.tv_usec as u32) * 1000)
                 } else {
-                    Duration::new((self.t.tv_sec - 1 - other.t.tv_sec) as u64,
+                    Duration::new(self.t.tv_sec as u64 - 1 - other.t.tv_sec as u64,
                                   (self.t.tv_usec as u32 + (USEC_PER_SEC as u32) -
                                    other.t.tv_usec as u32) * 1000)
                 })

branches/beta/src/libsyntax/print/pprust.rs

@@ -752,8 +752,7 @@ pub trait PrintState<'a> {
         }
         try!(self.maybe_print_comment(attr.span.lo));
         if attr.node.is_sugared_doc {
-            try!(word(self.writer(), &attr.value_str().unwrap()));
-            hardbreak(self.writer())
+            word(self.writer(), &attr.value_str().unwrap())
         } else {
             match attr.node.style {
                 ast::AttrStyle::Inner => try!(word(self.writer(), "#![")),

branches/beta/src/llvm

@@ -1 +1 @@
-Subproject commit 63f3a1bfcd78355398a460712db25922247756b6
+Subproject commit be89e4b532fba8544f629c257460b63fe26c680d

branches/beta/src/rustllvm/llvm-auto-clean-trigger

@@ -1,4 +1,4 @@
 # If this file is modified, then llvm will be forcibly cleaned and then rebuilt.
 # The actual contents of this file do not matter, but to trigger a change on the
 # build bots then the contents should be changed so git updates the mtime.
-2016-03-15
+2016-03-13

branches/beta/src/test/compile-fail/blind-item-block-item-shadow.rs

@@ -14,7 +14,7 @@ fn main() {
     {
         struct Bar;
         use foo::Bar;
-        //~^ ERROR a type named `Bar` has already been defined in this block
-        //~^^ ERROR a value named `Bar` has already been defined in this block
+        //~^ ERROR import `Bar` conflicts with type in this module
+        //~^^ ERROR import `Bar` conflicts with value in this module
     }
 }

branches/beta/src/test/compile-fail/blind-item-item-shadow.rs

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-mod foo { pub mod foo {  } } //~ NOTE previous definition of `foo` here
+mod foo { pub mod foo {  } }
 
-use foo::foo; //~ ERROR a module named `foo` has already been defined in this module
+use foo::foo; //~ ERROR import `foo` conflicts with existing submodule
 
 fn main() {}

branches/beta/src/test/compile-fail/enum-and-module-in-same-scope.rs

@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-enum Foo { //~ NOTE previous definition
+enum Foo {
     X
 }
 
-mod Foo { //~ ERROR a type named `Foo` has already been defined
+mod Foo { //~ ERROR duplicate definition of type or module `Foo`
     pub static X: isize = 42;
     fn f() { f() } // Check that this does not result in a resolution error
 }

branches/beta/src/test/compile-fail/issue-19498.rs

@@ -8,14 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use self::A; //~ NOTE previous import of `A` here
-use self::B; //~ NOTE previous import of `B` here
-mod A {} //~ ERROR a module named `A` has already been imported in this module
-pub mod B {} //~ ERROR a module named `B` has already been imported in this module
+use self::A; //~ ERROR import `A` conflicts with existing submodule
+use self::B; //~ ERROR import `B` conflicts with existing submodule
+mod A {}
+pub mod B {}
 
 mod C {
-    use C::D; //~ NOTE previous import of `D` here
-    mod D {} //~ ERROR a module named `D` has already been imported in this module
+    use C::D; //~ ERROR import `D` conflicts with existing submodule
+    mod D {}
 }
 
 fn main() {}