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 public interface
-pub struct Bar<T: Foo>(pub T); // same error
+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. 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:
+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 Bar<T: Foo>(pub T); // 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 a public type signature. Erroneous code example:
-```
+```compile_fail
mod Foo {
struct Bar(u32);
```
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`.
+can be made inaccessible if necessary by placing it into a private inner
+module, but it still has to be marked with `pub`.
Example:
```
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
}
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. Example:
-```
+```ignore
struct Bar;
trait Foo {
A tuple constructor was invoked while some of its fields are private. Erroneous
code example:
-```
+```compile_fail
mod Bar {
pub struct Foo(isize);
}
```
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
+are public. Alternatively, provide a `new()` method to the tuple struct to
construct it from a given inner value. Example:
```
pub struct Foo(isize);
impl Foo {
- pub fn new(x: isize) {
+ pub fn new(x: isize) -> Foo {
Foo(x)
}
}
E0451: r##"
A struct constructor with private fields was invoked. Erroneous code example:
-```
+```compile_fail
mod Bar {
pub struct Foo {
pub a: isize,
// is private
```
-To fix this error, please ensure that all the fields of the struct, or
-implement a function for easy instantiation. Examples:
+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 {
}
let f = Bar::Foo{ a: 0, b: 0 }; // ok!
+```
-// or:
+Or:
+
+```
mod Bar {
pub struct Foo {
pub a: isize,