A private trait was used on a public type parameter bound. Erroneous code
examples:
-```
+```compile_fail
trait Foo {
fn dummy(&self) { }
}
-pub trait Bar : Foo {} // error: private trait in exported type parameter bound
+pub trait Bar : Foo {} // error: private trait in public interface
+pub struct Bar2<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:
+To solve this error, please ensure that the trait is also public. The trait
+can be made inaccessible if necessary by placing it into a private inner
+module, but it still has to be marked with `pub`. Example:
-```
+```ignore
pub trait Foo { // we set the Foo trait public
fn dummy(&self) { }
}
pub trait Bar : Foo {} // ok!
+pub struct Bar2<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:
+A private type was used in a public type signature. Erroneous code example:
-```
+```compile_fail
mod Foo {
struct Bar(u32);
- pub fn bar() -> Bar { // error: private type in exported type signature
+ pub fn bar() -> Bar { // error: private type in public interface
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:
+To solve this error, please ensure that the type is also public. The type
+can be made inaccessible if necessary by placing it into a private inner
+module, but it still has to be marked with `pub`.
+Example:
```
mod Foo {
E0447: r##"
The `pub` keyword was used inside a function. Erroneous code example:
-```
+```compile_fail
fn foo() {
pub struct Bar; // error: visibility has no effect inside functions
}
```
-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.
"##,
E0448: r##"
The `pub` keyword was used inside a public enum. Erroneous code example:
-```
+```compile_fail
pub enum Foo {
pub Bar, // error: unnecessary `pub` visibility
}
Since the enum is already public, adding `pub` on one its elements is
unnecessary. Example:
-```
+```compile_fail
enum Foo {
- pub Bar, // ok!
+ pub Bar, // not ok!
}
+```
-// or:
+This is the correct syntax:
+```ignore
pub enum Foo {
Bar, // ok!
}
A visibility qualifier was used when it was unnecessary. Erroneous code
examples:
-```
+```compile_fail
struct Bar;
trait Foo {
```
To fix this error, please remove the visibility qualifier when it is not
-required.
+required. Example:
+
+```ignore
+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() {}
+}
+```
"##,
-}
\ No newline at end of file
+E0450: r##"
+A tuple constructor was invoked while some of its fields are private. Erroneous
+code example:
+
+```compile_fail
+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 {
+ Foo(x)
+ }
+ }
+}
+
+let f = bar::Foo::new(1);
+```
+"##,
+
+E0451: r##"
+A struct constructor with private fields was invoked. Erroneous code example:
+
+```compile_fail
+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 are public,
+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!
+```
+"##,
+
+}