Rollup of 14 pull requests

src/librustc_typeck/check/method/mod.rs

@@ -84,7 +84,8 @@ pub fn exists<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                         span: Span,
                         method_name: ast::Name,
                         self_ty: ty::Ty<'tcx>,
-                        call_expr_id: ast::NodeId)
+                        call_expr_id: ast::NodeId,
+                        allow_private: bool)
                         -> bool
 {
     let mode = probe::Mode::MethodCall;
@@ -93,7 +94,7 @@ pub fn exists<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
         Err(NoMatch(..)) => false,
         Err(Ambiguity(..)) => true,
         Err(ClosureAmbiguity(..)) => true,
-        Err(PrivateMatch(..)) => true,
+        Err(PrivateMatch(..)) => allow_private,
     }
 }
 

src/librustc_typeck/check/mod.rs

@@ -2943,12 +2943,19 @@ fn check_expr_with_expectation_and_lvalue_pref<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 
         if let Some((did, field_ty)) = private_candidate {
             let struct_path = fcx.tcx().item_path_str(did);
-            let msg = format!("field `{}` of struct `{}` is private", field.node, struct_path);
-            fcx.tcx().sess.span_err(expr.span, &msg);
             fcx.write_ty(expr.id, field_ty);
+            let msg = format!("field `{}` of struct `{}` is private", field.node, struct_path);
+            let mut err = fcx.tcx().sess.struct_span_err(expr.span, &msg);
+            // Also check if an accessible method exists, which is often what is meant.
+            if method::exists(fcx, field.span, field.node, expr_t, expr.id, false) {
+                err.fileline_note(field.span, &format!("a method called `{}` also exists, \
+                                                        maybe a `()` to call it is missing?",
+                                                       field.node));
+            }
+            err.emit();
         } else if field.node == keywords::Invalid.name() {
             fcx.write_error(expr.id);
-        } else if method::exists(fcx, field.span, field.node, expr_t, expr.id) {
+        } else if method::exists(fcx, field.span, field.node, expr_t, expr.id, true) {
             fcx.type_error_struct(field.span,
                                   |actual| {
                                        format!("attempted to take value of method `{}` on type \

src/test/compile-fail/issue-26472.rs

@@ -0,0 +1,24 @@
+// Copyright 2016 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.
+
+mod sub {
+    pub struct S { len: usize }
+    impl S {
+        pub fn new() -> S { S { len: 0 } }
+        pub fn len(&self) -> usize { self.len }
+    }
+}
+
+fn main() {
+    let s = sub::S::new();
+    let v = s.len;
+    //~^ ERROR field `len` of struct `sub::S` is private
+    //~| NOTE a method called `len` also exists, maybe a `()` to call it is missing
+}