---

yaml
---
r: 157221
b: refs/heads/master
c: 737e396
h: refs/heads/master
i:
  157219: ee10ca1
v: v3

Author: ftxqxd

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 14398f29290b0d96dbe60f329b69062442eefb33
+refs/heads/master: 737e39696ba0964729f29410cf4e75a061ce120a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d44ea720fa9dfe062ef06d0eb49a58d4e7e92344
 refs/heads/try: 6ecdf1fa83d7cdbf44a0091132e9c6580be72275

trunk/src/librustc/middle/typeck/check/vtable.rs

@@ -303,15 +303,25 @@ pub fn maybe_report_ambiguity(fcx: &FnCtxt, obligation: &Obligation) {
         // has_errors() to be sure that compilation isn't happening
         // anyway. In that case, why inundate the user.
         if !fcx.tcx().sess.has_errors() {
-            fcx.tcx().sess.span_err(
-                obligation.cause.span,
-                format!(
-                    "unable to infer enough type information to \
-                     locate the impl of the trait `{}` for \
-                     the type `{}`; type annotations required",
-                    trait_ref.user_string(fcx.tcx()),
-                    self_ty.user_string(fcx.tcx())).as_slice());
-            note_obligation_cause(fcx, obligation);
+            if fcx.ccx.tcx.lang_items.sized_trait()
+                  .map_or(false, |sized_id| sized_id == trait_ref.def_id) {
+                fcx.tcx().sess.span_err(
+                    obligation.cause.span,
+                    format!(
+                        "unable to infer enough type information about `{}`; type annotations \
+                         required",
+                        self_ty.user_string(fcx.tcx())).as_slice());
+            } else {
+                fcx.tcx().sess.span_err(
+                    obligation.cause.span,
+                    format!(
+                        "unable to infer enough type information to \
+                         locate the impl of the trait `{}` for \
+                         the type `{}`; type annotations required",
+                        trait_ref.user_string(fcx.tcx()),
+                        self_ty.user_string(fcx.tcx())).as_slice());
+                note_obligation_cause(fcx, obligation);
+            }
         }
     } else if !fcx.tcx().sess.has_errors() {
          // Ambiguity. Coherence should have reported an error.

trunk/src/test/compile-fail/issue-16562.rs

@@ -16,8 +16,7 @@ struct Col<D, C> {
 }
 
 impl<T, M: MatrixShape> Collection for Col<M, uint> {
-//~^ ERROR unable to infer enough type information to locate the impl of the trait
-//~^^ NOTE the trait `core::kinds::Sized` must be implemented because it is required by
+//~^ ERROR unable to infer enough type information
     fn len(&self) -> uint {
         unimplemented!()
     }

trunk/src/test/compile-fail/issue-17551.rs

@@ -13,6 +13,6 @@
 struct B<T>;
 
 fn main() {
-    let foo = B; //~ ERROR unable to infer enough type information to locate the impl of the trait
+    let foo = B; //~ ERROR unable to infer enough type information
     let closure = |:| foo;
 }

trunk/src/test/compile-fail/issue-18159.rs

@@ -0,0 +1,13 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let x; //~ ERROR unable to infer enough type information
+}