Rollup of 2 pull requests

src/doc/reference.md

@@ -2059,31 +2059,31 @@ arbitrarily complex configurations through nesting.
 
 The following configurations must be defined by the implementation:
 
-* `debug_assertions`. Enabled by default when compiling without optimizations.
+* `debug_assertions` - Enabled by default when compiling without optimizations.
   This can be used to enable extra debugging code in development but not in
   production.  For example, it controls the behavior of the standard library's
   `debug_assert!` macro.
-* `target_arch = "..."`. Target CPU architecture, such as `"x86"`, `"x86_64"`
+* `target_arch = "..."` - Target CPU architecture, such as `"x86"`, `"x86_64"`
   `"mips"`, `"powerpc"`, `"arm"`, or `"aarch64"`.
-* `target_endian = "..."`. Endianness of the target CPU, either `"little"` or
+* `target_endian = "..."` - Endianness of the target CPU, either `"little"` or
   `"big"`.
-* `target_env = ".."` - an option provided by the compiler by default
+* `target_env = ".."` - An option provided by the compiler by default
   describing the runtime environment of the target platform. Some examples of
   this are `musl` for builds targeting the MUSL libc implementation, `msvc` for
   Windows builds targeting MSVC, and `gnu` frequently the rest of the time. This
   option may also be blank on some platforms.
-* `target_family = "..."`. Operating system family of the target, e. g.
+* `target_family = "..."` - Operating system family of the target, e. g.
   `"unix"` or `"windows"`. The value of this configuration option is defined
   as a configuration itself, like `unix` or `windows`.
-* `target_os = "..."`. Operating system of the target, examples include
+* `target_os = "..."` - Operating system of the target, examples include
   `"windows"`, `"macos"`, `"ios"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"`,
   `"bitrig"` , `"openbsd"` or `"netbsd"`.
-* `target_pointer_width = "..."`. Target pointer width in bits. This is set
+* `target_pointer_width = "..."` - Target pointer width in bits. This is set
   to `"32"` for targets with 32-bit pointers, and likewise set to `"64"` for
   64-bit pointers.
-* `test`. Enabled when compiling the test harness (using the `--test` flag).
-* `unix`. See `target_family`.
-* `windows`. See `target_family`.
+* `test` - Enabled when compiling the test harness (using the `--test` flag).
+* `unix` - See `target_family`.
+* `windows` - See `target_family`.
 
 You can also set another attribute based on a `cfg` variable with `cfg_attr`:
 

src/librustc_privacy/diagnostics.rs

@@ -0,0 +1,235 @@
+// 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.
+
+#![allow(non_snake_case)]
+
+register_long_diagnostics! {
+
+E0445: r##"
+A private trait was used on a public type parameter bound. Erroneous code
+examples:
+
+```
+trait Foo {
+    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
+at the same level of the public functions or types which are bound on it.
+Example:
+
+```
+pub trait Foo { // we set the Foo trait public
+    fn dummy(&self) { }
+}
+
+pub trait Bar : Foo {} // ok!
+pub struct Bar<T: Foo>(pub T); // ok!
+pub fn foo<T: Foo> (t: T) {} // ok!
+```
+"##,
+
+E0446: r##"
+A private type was used in an exported type signature. Erroneous code example:
+
+```
+mod Foo {
+    struct Bar(u32);
+
+    pub fn bar() -> Bar { // error: private type in exported type signature
+        Bar(0)
+    }
+}
+```
+
+To solve this error, please ensure that the type is also public and accessible
+at the same level of the public functions or types which use it. Example:
+
+```
+mod Foo {
+    pub struct Bar(u32); // we set the Bar type public
+
+    pub fn bar() -> Bar { // ok!
+        Bar(0)
+    }
+}
+```
+"##,
+
+E0447: r##"
+The `pub` keyword was used inside a function. Erroneous code example:
+
+```
+fn foo() {
+    pub struct Bar; // error: visibility has no effect inside functions
+}
+```
+
+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.
+"##,
+
+E0448: r##"
+The `pub` keyword was used inside a public enum. Erroneous code example:
+
+```
+pub enum Foo {
+    pub Bar, // error: unnecessary `pub` visibility
+}
+```
+
+Since the enum is already public, adding `pub` on one its elements is
+unnecessary. Example:
+
+```
+enum Foo {
+    pub Bar, // ok!
+}
+
+// or:
+
+pub enum Foo {
+    Bar, // ok!
+}
+```
+"##,
+
+E0449: r##"
+A visibility qualifier was used when it was unnecessary. Erroneous code
+examples:
+
+```
+struct Bar;
+
+trait Foo {
+    fn foo();
+}
+
+pub impl Bar {} // error: unnecessary visibility qualifier
+
+pub impl Foo for Bar { // error: unnecessary visibility qualifier
+    pub fn foo() {} // error: unnecessary visibility qualifier
+}
+```
+
+To fix this error, please remove the visibility qualifier when it is not
+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##"
+A tuple constructor was invoked while some of its fields are private. Erroneous
+code example:
+
+```
+mod Bar {
+    pub struct Foo(isize);
+}
+
+let f = Bar::Foo(0); // error: cannot invoke tuple struct constructor with
+                     //        private fields
+```
+
+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 {
+    pub struct Foo(pub isize); // we set its field to public
+}
+
+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

@@ -50,6 +50,8 @@ use rustc::front::map as ast_map;
 use syntax::ast;
 use syntax::codemap::Span;
 
+pub mod diagnostics;
+
 type Context<'a, 'tcx> = (&'a ty::MethodMap<'tcx>, &'a def::ExportMap);
 
 /// Result of a checking operation - None => no errors were found. Some => an
@@ -715,7 +717,8 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
             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.
@@ -929,9 +932,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
                         });
 
                     if any_priv {
-                        self.tcx.sess.span_err(expr.span,
-                                               "cannot invoke tuple struct constructor \
-                                                with private fields");
+                        span_err!(self.tcx.sess, expr.span, E0450,
+                                  "cannot invoke tuple struct constructor with private \
+                                   fields");
                     }
                 }
             }
@@ -1043,7 +1046,8 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
         let tcx = self.tcx;
         let check_inherited = |sp: Span, vis: hir::Visibility, note: &str| {
             if vis != hir::Inherited {
-                tcx.sess.span_err(sp, "unnecessary visibility qualifier");
+                span_err!(tcx.sess, sp, E0449,
+                          "unnecessary visibility qualifier");
                 if !note.is_empty() {
                     tcx.sess.span_note(sp, note);
                 }
@@ -1076,8 +1080,8 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
                     match v.node.vis {
                         hir::Public => {
                             if item.vis == hir::Public {
-                                tcx.sess.span_err(v.span, "unnecessary `pub` \
-                                                           visibility");
+                                span_err!(tcx.sess, v.span, E0448,
+                                          "unnecessary `pub` visibility");
                             }
                         }
                         hir::Inherited => {}
@@ -1098,7 +1102,8 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
         let tcx = self.tcx;
         fn check_inherited(tcx: &ty::ctxt, sp: Span, vis: hir::Visibility) {
             if vis != hir::Inherited {
-                tcx.sess.span_err(sp, "visibility has no effect inside functions");
+                span_err!(tcx.sess, sp, E0447,
+                          "visibility has no effect inside functions");
             }
         }
         let check_struct = |def: &hir::StructDef| {
@@ -1193,8 +1198,8 @@ impl<'a, 'tcx> VisiblePrivateTypesVisitor<'a, 'tcx> {
             if !self.tcx.sess.features.borrow().visible_private_types &&
                 self.path_is_private_type(trait_ref.trait_ref.ref_id) {
                     let span = trait_ref.trait_ref.path.span;
-                    self.tcx.sess.span_err(span, "private trait in exported type \
-                                                  parameter bound");
+                    span_err!(self.tcx.sess, span, E0445,
+                              "private trait in exported type parameter bound");
             }
         }
     }
@@ -1435,7 +1440,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> {
         if let hir::TyPath(_, ref p) = t.node {
             if !self.tcx.sess.features.borrow().visible_private_types &&
                 self.path_is_private_type(t.id) {
-                self.tcx.sess.span_err(p.span, "private type in exported type signature");
+                span_err!(self.tcx.sess, p.span, E0446,
+                          "private type in exported type signature");
             }
         }
         visit::walk_ty(self, t)