Add error code for private struct field issue

src/librustc_privacy/diagnostics.rs

@@ -22,6 +22,8 @@ fn dummy(&self) { }
 }
 
 pub trait Bar : Foo {} // error: private trait in exported type parameter bound
+pub struct Bar<T: Foo>(pub T); // same error
+pub fn foo<T: Foo> (t: T) {} // same error
 ```
 
 To solve this error, please ensure that the trait is also public and accessible
@@ -34,6 +36,8 @@ fn dummy(&self) { }
 }
 
 pub trait Bar : Foo {} // ok!
+pub struct Bar<T: Foo>(pub T); // ok!
+pub fn foo<T: Foo> (t: T) {} // ok!
 ```
 "##,
 
@@ -73,8 +77,8 @@ fn foo() {
 }
 ```
 
-Since we cannot access inside function's elements, the visibility of its
-elements does not impact outer code. So using the `pub` keyword in this context
+Since we cannot access items defined inside a function, the visibility of its
+items does not impact outer code. So using the `pub` keyword in this context
 is invalid.
 "##,
 
@@ -122,7 +126,25 @@ pub fn foo() {} // error: unnecessary visibility qualifier
 ```
 
 To fix this error, please remove the visibility qualifier when it is not
-required.
+required. Example:
+
+```
+struct Bar;
+
+trait Foo {
+    fn foo();
+}
+
+// Directly implemented methods share the visibility of the type itself,
+// so `pub` is unnecessary here
+impl Bar {}
+
+// Trait methods share the visibility of the trait, so `pub` is
+// unnecessary in either case
+pub impl Foo for Bar {
+    pub fn foo() {}
+}
+```
 "##,
 
 E0450: r##"
@@ -138,7 +160,9 @@ mod Bar {
                      //        private fields
 ```
 
-To solve this issue, please ensure that all tuple's fields are public. Example:
+To solve this issue, please ensure that all of the fields of the tuple struct
+are public. Alternatively, provide a new() method to the tuple struct to
+construct it from a given inner value. Example:
 
 ```
 mod Bar {
@@ -146,7 +170,66 @@ mod Bar {
 }
 
 let f = Bar::Foo(0); // ok!
+
+// or:
+mod bar {
+    pub struct Foo(isize);
+
+    impl Foo {
+        pub fn new(x: isize) {
+            Foo(x)
+        }
+    }
+}
+
+let f = bar::Foo::new(1);
 ```
 "##,
 
-}
+E0451: r##"
+A struct constructor with private fields was invoked. Erroneous code example:
+
+```
+mod Bar {
+    pub struct Foo {
+        pub a: isize,
+        b: isize,
+    }
+}
+
+let f = Bar::Foo{ a: 0, b: 0 }; // error: field `b` of struct `Bar::Foo`
+                                //        is private
+```
+
+To fix this error, please ensure that all the fields of the struct, or
+implement a function for easy instantiation. Examples:
+
+```
+mod Bar {
+    pub struct Foo {
+        pub a: isize,
+        pub b: isize, // we set `b` field public
+    }
+}
+
+let f = Bar::Foo{ a: 0, b: 0 }; // ok!
+
+// or:
+mod Bar {
+    pub struct Foo {
+        pub a: isize,
+        b: isize, // still private
+    }
+
+    impl Foo {
+        pub fn new() -> Foo { // we create a method to instantiate `Foo`
+            Foo { a: 0, b: 0 }
+        }
+    }
+}
+
+let f = Bar::Foo::new(); // ok!
+```
+"##,
+
+}

src/librustc_privacy/lib.rs

@@ -717,7 +717,8 @@ fn check_field(&mut self,
             UnnamedField(idx) => format!("field #{} of {} is private",
                                          idx + 1, struct_desc),
         };
-        self.tcx.sess.span_err(span, &msg[..]);
+        span_err!(self.tcx.sess, span, E0451,
+                  "{}", &msg[..]);
     }
 
     // Given the ID of a method, checks to ensure it's in scope.